Git & GitHub Complete End-to-End Workflow Guide: Branching, Rebasing & Team Collaboration

Whether you are building backend microservices, writing automation scripts, or managing cloud infrastructure as code (IaC), Git is the universal foundation of modern software engineering. It tracks changes, enables parallel feature development, and provides an immutable history of every line of code.

This comprehensive guide covers the internal mechanics of Git, essential daily commands, branching workflows, resolving complex merge conflicts, and professional GitHub collaboration strategies.

1. Git Architecture: The Three-Tree System

To master Git, you must understand how files transition between its three core local states:

• Working Directory: The actual files on your filesystem currently being modified.
• Staging Area (Index): A staging environment that previews what changes will be packaged into your next commit.
• Local Repository (.git): The immutable history of all committed snapshots on your local machine.
• Remote Repository (GitHub/GitLab): The hosted central repository for team collaboration.

2. Essential Daily Git Commands

Here are the fundamental commands every developer and engineer uses daily:

# 1. Initialize a new local Git repository
$ git init

# 2. Stage specific files or all modified files
$ git add src/main.py
$ git add .

# 3. Commit staged changes with a conventional commit message
$ git commit -m "feat(auth): implement JWT token verification"

# 4. Check status of working directory and staged files
$ git status

# 5. View clean, formatted commit history
$ git log --oneline --graph --decorate --all

3. Branching & Merging: Fast-Forward vs Three-Way Merge

Branches allow engineers to develop features, fix bugs, or experiment safely without corrupting the stable main branch.

# Create and switch to a new feature branch
$ git checkout -b feature/user-profile
# (Modern alternative: git switch -c feature/user-profile)

# Make changes, stage, and commit
$ git commit -am "feat: add user profile picture upload"

# Switch back to main and merge the feature branch
$ git switch main
$ git merge feature/user-profile

# Delete merged branch
$ git branch -d feature/user-profile

4. Merge vs Rebase: Keeping a Linear History

While git merge preserves the complete historical timeline with a dedicated merge commit, git rebase rewrites project history by replaying your branch's commits directly on top of the target branch, creating a perfectly clean, linear history.

# Rebasing feature branch onto latest main
$ git switch feature/auth
$ git fetch origin
$ git rebase origin/main

5. Resolving Merge Conflicts Step-by-Step

A merge conflict occurs when two branches modify the exact same lines in a file. Git pauses the merge and marks the conflict areas:

<<<<<<< HEAD
server_port = 8080  # Your current branch change
=======
server_port = 9000  # Incoming incoming branch change
>>>>>>> feature/port-update

To resolve: Edit the file to keep the desired code, remove the conflict markers (<<<<<<<, =======, >>>>>>>), and run:

$ git add config.py
$ git commit -m "fix(config): resolve port conflict between main and feature branch"

6. Undoing Mistakes Safely in Git

• Discard unstaged changes in a file: git restore filename.py
• Unstage a file without losing code: git restore --staged filename.py
• Revert a public commit safely (creates a new reverse commit): git revert <commit-hash>
• Temporarily stash uncommitted work: git stash (restore later with git stash pop)