Git Rebase vs Merge: When to Use Each

Both rebase and merge integrate changes between branches. Understanding when to use each keeps your Git history clean and your team happy.

The Difference#

Merge:
- Creates a merge commit
- Preserves complete history
- Shows when branches diverged and joined
- Non-destructive

Rebase:
- Rewrites commit history
- Creates linear history
- Moves commits to new base
- Cleaner but rewrites SHAs

Visual Comparison#

Before (both):
main:    A---B---C
              \
feature:       D---E

After merge:
main:    A---B---C-------M
              \         /
feature:       D---E---/

After rebase:
main:    A---B---C
                  \
feature:           D'---E'

When to Merge#

# Merge preserves history - good for:
# - Shared branches
# - PR/MR completion
# - Release branches
# - When history matters

# Merge feature into main
git checkout main
git merge feature-branch

# Merge with no fast-forward (always create merge commit)
git merge --no-ff feature-branch

# Squash merge (combine all commits into one)
git merge --squash feature-branch
git commit -m "Add feature X"

When to Rebase#

# Rebase for:
# - Updating feature branch with main
# - Cleaning up local commits before PR
# - Linear history preference
# - NEVER on shared/public branches

# Update feature branch with latest main
git checkout feature-branch
git rebase main

# Interactive rebase to clean up commits
git rebase -i HEAD~3

# Rebase onto specific commit
git rebase --onto main feature-base feature-branch

Interactive Rebase#

# Clean up last 5 commits
git rebase -i HEAD~5

# Editor opens with:
pick abc1234 First commit
pick def5678 Second commit
pick ghi9012 Fix typo
pick jkl3456 WIP
pick mno7890 Final implementation

# Commands:
# pick   = keep commit as-is
# reword = keep commit, edit message
# edit   = stop for amending
# squash = combine with previous
# fixup  = squash but discard message
# drop   = remove commit

# Example: squash WIP commits
pick abc1234 First commit
pick def5678 Second commit
fixup ghi9012 Fix typo
fixup jkl3456 WIP
pick mno7890 Final implementation

# Result: 3 clean commits instead of 5

Handling Conflicts#

# During rebase conflict
git rebase main
# CONFLICT in file.js

# Resolve conflict
# Edit file.js to fix conflicts
git add file.js
git rebase --continue

# Or abort rebase
git rebase --abort

# During merge conflict
git merge feature
# CONFLICT in file.js

# Resolve and complete merge
# Edit file.js
git add file.js
git commit

Team Workflows#

# Workflow 1: Rebase before merge (recommended)
# On feature branch:
git fetch origin
git rebase origin/main
# Resolve any conflicts
git push --force-with-lease  # Only if already pushed
# Then create PR/merge

# Workflow 2: Squash merge
# Complete feature work
git checkout main
git merge --squash feature-branch
git commit -m "Feature: Add user authentication"

# Workflow 3: Merge commits (preserve history)
git checkout main
git merge --no-ff feature-branch

Golden Rule#

# NEVER rebase shared branches
# Bad - rewrites history others depend on:
git checkout main
git rebase feature  # DON'T DO THIS

# These commits are shared - don't rebase:
# - main/master
# - develop
# - release branches
# - Any branch others are working on

# Safe to rebase:
# - Your local feature branch
# - Before pushing
# - After pushing with --force-with-lease (solo branch)

Practical Examples#

# Example 1: Update feature branch
git checkout feature/user-auth
git fetch origin
git rebase origin/main
# Now feature branch has latest main commits

# Example 2: Clean up before PR
git checkout feature/user-auth
git rebase -i origin/main
# Squash/fixup WIP commits
# Reword unclear commit messages
git push --force-with-lease

# Example 3: Fix commit message
git rebase -i HEAD~1
# Change 'pick' to 'reword'
# Save and edit message

# Example 4: Remove accidental commit
git rebase -i HEAD~3
# Change 'pick' to 'drop' for unwanted commit
# Save

# Example 5: Reorder commits
git rebase -i HEAD~3
# Reorder lines to reorder commits

Autosquash#

# Create fixup commit
git commit --fixup abc1234

# Create squash commit (keeps message)
git commit --squash abc1234

# Rebase with autosquash
git rebase -i --autosquash main

# Auto-configure
git config --global rebase.autosquash true

Recovering from Mistakes#

# Undo last rebase
git reflog
# Find the commit before rebase
git reset --hard HEAD@{2}

# Recover dropped commits
git reflog
# Find the dropped commit
git cherry-pick abc1234

# Abort in-progress rebase
git rebase --abort

Comparison Table#

| Aspect          | Merge              | Rebase             |
|-----------------|--------------------|--------------------|
| History         | Non-linear         | Linear             |
| Commits         | Preserved + merge  | Rewritten          |
| Conflicts       | Once               | Per commit         |
| Shared branches | Safe               | Dangerous          |
| Traceability    | Complete           | Simplified         |
| Rollback        | Easy               | Harder             |

Best Practices#

Rebase:
✓ Local feature branches
✓ Before creating PR
✓ To update with latest main
✓ Interactive to clean history

Merge:
✓ Completing PRs
✓ Shared branches
✓ When history matters
✓ Release branches

Avoid:
✗ Rebasing public branches
✗ Force push without --force-with-lease
✗ Rewriting shared history
✗ Complex rebases without backup

Use rebase to keep feature branches updated and history clean. Use merge to integrate completed work into shared branches. Never rebase commits that others depend on. When in doubt, merge is safer—it doesn't rewrite history.