> For the complete documentation index, see [llms.txt](https://www.pranaypourkar.co.in/the-programmers-guide/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.pranaypourkar.co.in/the-programmers-guide/git/workflows/conflict-resolution/force-push-when-and-why.md). # Force Push ## About A **force push** in Git (`git push --force`) is a command used to **push our local branch to the remote repository** while **overwriting the remote branch history**. It **disregards the normal safety checks** that prevent rewriting commits that exist on the remote. Normally, Git protects shared history. If our local branch has diverged from the remote (i.e., the histories are different), a regular push will be rejected. Force push bypasses that rejection. ## Why Force Push Exists Git allows rewriting history locally using commands like: * `git rebase` * `git commit --amend` * `git reset` After such operations, our branch’s history no longer matches the remote. If we try to push, Git will refuse to do so unless we use force. This is where **force push** comes in — it lets us tell Git, “I know what I’m doing, replace the remote history with mine.” ## How It Works When we run: ```bash git push --force ``` Git does **not care** whether the remote branch has new commits. It simply updates the remote branch to point to our current local state. If the remote had commits not present locally, they are **lost**. Git compares commit references (pointers) and updates them directly. ## When to Use Force Push ? ### **a) After Rewriting History** **Scenario:** We have rewritten commit history using `git rebase` or `git commit --amend`. **Why:** These operations **change commit hashes**, making your local branch history different from the remote. A normal `git push` will be rejected. **Example 1 – Rebase:** ```bash # Interactive rebase to edit/squash commits git rebase -i HEAD~3 # Edit or squash commits, then save and exit the editor # Remote will reject a normal push due to changed history git push --force ``` **Example 2 – Amending a commit:** ```bash # Fix last commit message or add forgotten changes git commit --amend -m "Corrected commit message" # Force push to update remote branch git push --force ``` {% hint style="success" %} **Note:** Always ensure no one else is working on the same branch before you force push. {% endhint %} ### **b) Cleanup Before Merge Request** **Scenario:** We want to clean up messy commits before raising a Merge Request or Pull Request. **Why:** To present a **clear and linear commit history**, we may squash multiple WIP (work in progress) commits into one or reorder them. **Example – Squashing commits:** ```bash # Suppose we made 4 messy commits on our feature branch git rebase -i HEAD~4 # Choose 'squash' or 'fixup' in the interactive editor # Push with force to update cleaned-up history git push --force ``` {% hint style="success" %} This is commonly done just **before opening** a PR/MR, or **after feedback**, so the reviewer sees a clean diff. {% endhint %} ### **c) Removing Mistaken Commits** **Scenario:** We accidentally pushed something sensitive (e.g., secrets, large files, wrong code). **Why:** We want to **remove** the commit(s) from remote history so it’s no longer publicly visible or downloadable. **Example – Using `git reset`:** ```bash # Go back to a safe commit before the mistake git reset --hard # Overwrite remote branch with cleaned history git push --force ``` We can find `` using: ```bash git log ``` OR if unsure: ```bash git reflog # shows a list of recent HEAD states ``` {% hint style="warning" %} Use this carefully. If others pulled the bad commit, removing it locally won't remove it from their machines. {% endhint %} ## Risks and Why Force Push is Dangerous **a) Data Loss** Force push **removes remote commits** that are not in our local history. If someone else pushed to the same branch before our force push, their work is **lost**. **b) Team Disruption** If teammates have pulled the old version and we force push a new history: * They get errors when pulling. * They must fix their local branches manually using rebase or reset. **c) Broken CI/CD Pipelines** Force pushing can break automated pipelines that rely on commit history, hashes, or tags. ## When to Use and When NOT to Use Force Push
Situation / ScenarioUse --force?Explanation
After interactive rebase (git rebase -i)YesRebase rewrites history; force push is required to update the remote.
After amending the latest commit (--amend)YesChanges the commit hash; remote needs a force push to accept the new history.
After squashing commits for clean historyYesSquash modifies commit history; you must force push to update the branch on the remote.
After resetting to remove sensitive/mistaken dataYesYou are rewriting history to remove bad commits; force push is required.
Working on your own feature branch aloneYesSafe to force push if no one else depends on the branch.
Collaborating on a shared branch with othersNoForce push can overwrite others’ work; use with extreme caution or avoid it.
Trying to sync local with updated remoteNoUse git pull, git fetch, or merge instead; force push can erase incoming updates.
Undoing a mistake without rewriting historyNoUse git revert to add a new commit that undoes the changes.
On protected branches (e.g., main, release)NoForce push is typically disabled or discouraged to avoid accidental overwrites.
As a shortcut to fix conflictsNoDon't use force push to avoid resolving conflicts. Always handle them properly.
Accidentally diverged due to git pull conflictsMaybeUnderstand what caused divergence. Use --force-with-lease if safe, but only if you're sure.
--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://www.pranaypourkar.co.in/the-programmers-guide/git/workflows/conflict-resolution/force-push-when-and-why.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.