Git Branch Management: The Foundation of Team Collaboration

Branches are like parallel universes — you can create a new universe to experiment in without affecting the main one.

Why Do You Need Branches?

Imagine you're writing a paper. Halfway through, you suddenly have a new idea, but you don't want to mess up what you've already written. What do you do?

Make a copy and go wild with it. That's essentially what a branch is.

In Git, branches let you:

Safely experiment with new features: Messed up? Just delete the branch — the main code stays untouched
Develop with multiple people simultaneously: You work on login, I work on the homepage — no interference
Keep the main branch stable: The main branch is always a working version

Understanding Branches with a Train Track Analogy

Think of a Git repository as a railway system:

main:     ════════════●═══════════●═══════════●
                       \         /
feature-login:          ●═════●
                       /
feature-home:    ══════●═══════════●

main is the main line — the official train that passengers (users) ride
feature-login is a branch line — a construction crew is building a new station on it, and once done, it merges into the main line
feature-home is another branch line — another crew working in parallel

Work on branch lines doesn't affect the main line's normal operations. When it's done, just connect it.

Branch Types at a Glance

Branch Name	Purpose	Example
`main`	Production code, always deployable	Release versions
`develop`	Main development line, feature integration	Daily development
`feature/*`	New feature development	`feature/login`
`bugfix/*`	Bug fixes	`bugfix/header-crash`
`hotfix/*`	Emergency production fixes	`hotfix/payment-error`

Basic Branch Operations

Creating Branches

# View current branches
git branch

# Create a new branch
git branch feature/login

# Switch to the new branch
git checkout feature/login

# Create and switch (common shortcut)
git checkout -b feature/login

# New syntax in Git 2.23+ (recommended)
git switch -c feature/login

Viewing All Branches

# Local branches
git branch

# Including remote branches
git branch -a

# View last commit of each branch
git branch -v

Deleting Branches

# Delete a merged branch
git branch -d feature/login

# Force delete (even if not merged)
git branch -D feature/login

Merging Branches

merge — The Most Common Way to Merge

# Switch back to main
git switch main

# Merge feature/login in
git merge feature/login

There are two merge modes:

Fast-Forward Merge — main has no new commits, so it just "fast-forwards":

Before:
main:        A → B
                      \
feature:               C → D

After (fast-forward):
main:        A → B → C → D

Three-Way Merge — both main and the branch have new commits:

Before:
main:        A → B → E
                      \
feature:               C → D

After:
main:        A → B → E → F (merge commit)
                      \ /
feature:               C → D

rebase — A Cleaner History

# On the feature branch
git rebase main

Rebase "moves" your commits to after the latest position on main, making the history a straight line:

Before rebase:
main:     A → B → E
                    \
feature:             C → D

After rebase:
main:     A → B → E → C' → D'

merge vs rebase — which to choose:

merge preserves real history — good for shared branches

rebase gives a cleaner history — good for personal branches

Golden rule: never rebase a public branch that's already been pushed to a remote

Pull Request (PR) Basics

Pull Requests are the core workflow for code review. After you finish a feature, you request the team to "pull" your code into the main branch.

Creating a PR on GitHub

# 1. Push your branch to the remote
git push origin feature/login

# 2. Go to the GitHub repo page — you'll see a yellow banner
#    Click "Compare & pull request"

# 3. Fill in the PR description
#    - What you did
#    - Why you did it
#    - How to test it

# 4. Wait for review, then merge

PR Description Template

## What I Did
Added user login functionality, supporting email/password login

## Why
Users need an account system to save their data

## How to Test
1. Visit /login
2. Enter email and password
3. Click login — should redirect to homepage

## Screenshots
(Attach screenshots)

Handling Merge Conflicts

Conflicts happen when Git can't automatically merge — two people changed the same line of code.

What a Conflict Looks Like

<<<<<<< HEAD
const title = "Welcome back";
=======
const title = "Hello, welcome";
>>>>>>> feature/login

<<<<<<< HEAD to =======: content from your current branch
======= to >>>>>>> feature/xxx: content from the branch being merged

Resolution Steps

# 1. Start the merge, encounter conflict
git merge feature/login
# CONFLICT (content): Merge conflict in src/app/page.tsx

# 2. See which files have conflicts
git status
# both modified: src/app/page.tsx

# 3. Open the file, manually choose what to keep
#    Delete the <<<<<<< ======= >>>>>>> markers, keep the correct code

# 4. Mark as resolved
git add src/app/page.tsx

# 5. Complete the merge
git commit -m "merge: merge feature/login, resolve conflicts"

Resolving Conflicts with VS Code

VS Code highlights conflicts and provides buttons:

Accept Current Change — keep the current branch
Accept Incoming Change — keep the branch being merged
Accept Both Changes — keep both sides
Compare Changes — compare differences

Branch Naming Conventions

A good branch name tells you what it's about at a glance:

# ✅ Good names
feature/user-login
feature/payment-stripe
bugfix/header-not-showing
hotfix/fix-payment-crash
chore/update-dependencies

# ❌ Bad names
my-branch
test
fix
new-feature
temp

Naming format: type/short-description

Type	Purpose	Example
`feature/`	New features	`feature/user-profile`
`bugfix/`	Bug fixes	`bugfix/login-error`
`hotfix/`	Emergency fixes	`hotfix/payment-crash`
`chore/`	Housekeeping	`chore/cleanup-deps`
`docs/`	Documentation	`docs/api-guide`
`refactor/`	Refactoring	`refactor/auth-module`

GitHub Flow vs Git Flow

Git Flow — Traditional Large Projects

main ─────────────────────────────
  │                          ↑
  │   ┌─ release/1.0 ────────┘
  │   │
  └── develop ──────────────────
       │      │
       │      └─ feature/B
       └─ feature/A

Best for: large teams, projects with fixed release cycles

GitHub Flow — Simple and Practical (Recommended for Beginners)

main ────────────────────────
  │         ↑        ↑
  ├─ feat/A ┘        │
  │                   │
  └─ feat/B ──────────┘

The rules are simple:

main branch is always deployable
New features branch off from main
Submit a PR when development is done
Merge to main after code review passes
Deploy immediately after merging

If you're a beginner, just use GitHub Flow — it's simple and gets the job done.

Let's walk through the complete workflow:

# 1. Make sure you're on main with the latest code
git switch main
git pull

# 2. Create a feature branch
git switch -c feature/user-login

# 3. Start coding
# Create the login page
# src/app/login/page.tsx

// src/app/login/page.tsx
export default function LoginPage() {
  return (
    <div className="flex min-h-screen items-center justify-center">
      <form className="w-96 space-y-4 rounded-lg border p-8">
        <h1 className="text-2xl font-bold">Login</h1>
        <input
          type="email"
          placeholder="Email"
          className="w-full rounded border p-2"
        />
        <input
          type="password"
          placeholder="Password"
          className="w-full rounded border p-2"
        />
        <button className="w-full rounded bg-blue-500 p-2 text-white">
          Login
        </button>
      </form>
    </div>
  );
}

# 4. Commit the code
git add .
git commit -m "feat: add login page UI"

# 5. Continue development, add login logic
# ... write code ...

git add .
git commit -m "feat: implement email/password login"

# 6. Push to remote
git push -u origin feature/user-login

# 7. Create a PR on GitHub
# Fill in description, wait for review

# 8. After review passes, merge
# Click "Merge pull request" on the GitHub page

# 9. Sync locally
git switch main
git pull

# 10. Delete the feature branch
git branch -d feature/user-login
git push origin --delete feature/user-login

Quick Reference: Common Commands

# Branch operations
git branch                    # View local branches
git branch -a                 # View all branches
git switch -c feature/xxx     # Create and switch to a branch
git switch main               # Switch branch
git branch -d feature/xxx     # Delete a branch

# Merge operations
git merge feature/xxx         # Merge a branch
git rebase main               # Rebase onto main

# Sync operations
git push -u origin feature/xxx  # Push a new branch
git pull                        # Pull latest code

# Conflict handling
git status                    # View conflicting files
# After manually resolving conflicts
git add .                     # Mark as resolved
git commit                    # Complete the merge

Summary

Branches are safe experiment zones — mess up and just delete them
Beginners should use GitHub Flow — simple and sufficient
Branch names should be meaningful — feature/xxx, bugfix/xxx
Conflicts aren't scary — just pick the right code manually
PRs are the core of team collaboration — write good descriptions, be patient with reviews

Branch management isn't some advanced technology — it's just a good habit. The more you use it, the more natural it becomes.

Why Do You Need Branches?​

Understanding Branches with a Train Track Analogy​

Branch Types at a Glance​

Basic Branch Operations​

Creating Branches​

Viewing All Branches​

Deleting Branches​

Merging Branches​

merge — The Most Common Way to Merge​

rebase — A Cleaner History​

Pull Request (PR) Basics​

Creating a PR on GitHub​

PR Description Template​

Handling Merge Conflicts​

What a Conflict Looks Like​

Resolution Steps​

Resolving Conflicts with VS Code​

Branch Naming Conventions​

GitHub Flow vs Git Flow​

Git Flow — Traditional Large Projects​

GitHub Flow — Simple and Practical (Recommended for Beginners)​

Hands-On: Developing a Login Feature with Branches​

Quick Reference: Common Commands​

Summary​