55 Git interview questions with answers

All Git interview questions

• What is Git Flow? What are the popular branching strategies?

  Git Flow is a branching strategy with 5 branch types: - main: the code running in production. - develop: where feature work is integrated. - feature/: new features, branched from develop. - release/: preparing a release (small fixes, version bump). - hotfix/: urgent fixes, branched…

• How are git rebase and merge different? When should you use each?

  Both bring changes from one branch into another; they differ in the shape of history. Merge creates a merge commit with two parents and leaves existing commits untouched. Rebase takes each commit of the feature branch and replays it on top of the target branch,…

• How do Git Flow and trunk-based development differ, and when do you use each?

  Git Flow: multiple long-lived branches — main, develop, feature/, release/, hotfix/. Fits: long release cycles, maintaining several versions in parallel, large teams needing isolation. Downsides: long-lived feature branches → large merge conflicts; hotfixes must merge into both main and develop. Trunk-based development (TBD): everyone pushes…

• GitHub Flow vs Git Flow: which should a 5-person startup choose and why?

  GitHub Flow (simple): main is always deployable, all features branch from main, PR → review → merge → deploy immediately. Only one branch type beyond main. Git Flow (complex): main + develop + feature/ + release/ + hotfix/. More process overhead but tighter release control.…

• Your feature branch has lived 2 weeks and is now 50 commits behind main. What strategy merges it safely?

• Multi-team monorepo: what branching strategy fits and how do you prevent teams from blocking each other?

  A monorepo fits best with trunk-based development: short branches merged into main within a day or two. Teams block each other not because of branches but because review and CI go through one shared repo, so split both by directory. - CODEOWNERS: with branch protection…

• Production has a critical bug at 2am during an active sprint. What is the correct hotfix process?

  The right order is limit the damage first, fix second. A hotfix is the smallest possible patch, branched from the line running in production, and it does not go through the sprint branch. 1. Scope it and limit the damage. If the bug came from…

• What is the purpose of a release branch? When is it needed vs. unnecessary overhead?

  A release branch is a branch cut to prepare one release, e.g. release/1.5.0. From that point it only receives bug fixes for 1.5.0, while main (or develop) keeps receiving new features for the next release. Why split it off: if QA tests directly on main,…

• Branch protection rules on GitHub: what should you configure to prevent the team from pushing directly to main?

  Go to GitHub repo → Settings → Branches → Add branch protection rule for main: Minimum required: - Require a pull request before merging — no direct pushes - Require approvals (1-2 reviewers) - Dismiss stale pull request approvals when new commits are pushed —…

• Polyrepo vs Monorepo: how do git workflows differ and when should you migrate?

• What are Conventional Commits? Why enforce them with commitlint rather than just team agreement?

  Conventional Commits is a convention for commit messages in the form type(scope): description. Types: feat, fix, docs, style, refactor, test, chore, perf, ci, build, revert. Why not just agree: a verbal agreement with nothing checking it means people forget or skip it under deadline pressure.…

• Interactive rebase: how do you use squash, fixup, reword, drop to clean up history before merging a PR?

  Interactive rebase (git rebase -i) lets you rewrite local commit history before sharing it. Common workflow before merging a PR: The editor shows: Commands: - squash (s): fold this commit into the previous one; git opens an editor so you can combine/edit both messages -…

• When should you squash merge a PR instead of using a merge commit? What are the trade-offs?

  A squash merge combines all commits of a PR into one commit on main. A merge commit keeps every commit of the branch and adds a commit joining the two branches. The choice depends on whether the small commits in the PR are worth keeping.…

• You just made a bad commit (wrong message or forgot a file). How do you fix it without creating a new commit?

  Amend the last commit — only when the commit has NOT been pushed: If already pushed (your own branch only): Note: - --amend creates a NEW commit with a different hash — it does not edit in place - NEVER amend commits on main/develop or…

• I accidentally ran `git reset --hard` and lost 3 unpushed commits. How do I recover?

• What are signed commits with GPG/SSH? When should an enterprise team enforce them?

  Signed commits verify that a commit genuinely came from the person holding the matching private key — preventing identity forgery (anyone can set git config user.email to your email). GPG signing setup: SSH signing (Git 2.34 or later, easier than GPG because it reuses your…

• What are atomic commits? Why is a commit like "feat: add user auth + fix navbar + update deps" an anti-pattern?

  Atomic commit: each commit contains ONE complete logical change — passes tests on its own, can be reverted on its own, and its message fully describes the change. Why a commit that bundles several things is an anti-pattern: 1. No independent revert: you need to…

• How does the CODEOWNERS file work? How do you use it to enforce precise reviews in a large team?

• Merge vs Rebase: when to use which? Explain the golden rule of rebasing.

  Merge: creates a merge commit that joins the two branches and keeps the full history. git log --graph still shows the branch splitting off and coming back. Merge never modifies existing commits. Rebase: takes each commit of the current branch and reapplies it on top…

• You hit complex conflicts across many commits during a rebase. What strategy avoids "rebase hell"?

• Fast-forward merge vs no-ff merge: what is the difference? What does GitHub use by default and why should teams choose deliberately?

  Fast-forward merge (default when possible): if the current branch is a direct ancestor of the branch being merged, git simply moves the branch pointer forward to the latest commit — no merge commit created. History is linear. No-ff merge (--no-ff): always creates a merge commit…

• What is a 3-way merge? How does git auto-resolve, and when must you resolve manually?

• What is `git rerere`? When does it save you from resolving the same conflict multiple times?

• Merging a feature branch into main, you hit a conflict where both sides refactored the same file. What is the safe resolution process?

  The hardest conflict is not a simple add/delete but one where both sides refactored the structure: a function was renamed, logic was reorganized. The conflict markers then only show two different blocks of code, not what each side intended. Safe process: 1. Understand context before…

• Undoing a public commit already merged into main: revert vs reset — when to use which?

  A commit already on main that others have pulled calls for git revert; use git reset only on a local branch nobody else has. git revert git reset --------- What it does Creates a new commit that undoes the old commit's changes Moves the branch…

• Interactive rebase edit mode: what can it do that squash cannot?

• A teammate just force-pushed to a shared branch, losing your commits. How do you recover?

• How does `git bisect` work? Give a real-world scenario of using it to find a regression commit.

• What are `git log -S` and `git log -G` used for? When do they save you during debugging?

  Pickaxe search — find commits that added or removed a specific string in the code. - git log -S "string" (pickaxe): finds commits where the number of occurrences of the string in a file changed. Because it only counts, a commit that merely moves a…

• A branch was accidentally deleted before being merged anywhere. How do you recover it?

  A branch is just a pointer to a commit. Deleting a branch only removes the pointer; the commits stay in the object store, so the job is to find the SHA of the last commit and create a new branch pointing at it. The quickest…

• `git blame` in practice: it is not just for blaming — what are the genuinely useful use cases?

  git blame <file shows for each line: commit hash, author, date, and line content — who wrote that line and when. Genuinely useful use cases: 1. Understanding unfamiliar code: git blame src/utils/pricing.ts -L 23,35 → see line 28 was written by someone 6 months ago…

• You discover a bug right after a production deploy and need to rollback immediately. `git revert` or redeploy from the previous tag?

• `--force` vs `--force-with-lease`: why is force-with-lease safer and how should a team enforce it?

  git push --force: overwrites the remote branch without any checks — if a teammate pushed new commits that you have not fetched, you overwrite and lose their commits. git push --force-with-lease: checks the remote ref before overwriting — only force pushes if the remote ref…

• When is a force push acceptable and when is it absolutely not allowed?

  A force push overwrites the branch history on the remote with yours, and commits that only exist on the remote are lost. So only force push a branch only you use, and always use --force-with-lease instead of --force. --force overwrites whatever the remote has. --force-with-lease…

• You accidentally force-pushed to main and the history was overwritten. What is the emergency recovery process?

• You accidentally committed a `.env` file with credentials to remote. How do you handle it?

  A secret that has been pushed to a remote should be treated as leaked: anyone who cloned the repo, or any bot scanning it, in that window may already have it. So the order is rotate first, clean history second. Cleaning history only tidies the…

• A large file was accidentally committed into git history, making the repo heavy. How do you remove it from history without disrupting collaboration?

• What is `git worktree`? When is it better than stashing or creating a second clone?

• Advanced `git stash`: push, pop, apply, list, show, drop — what real-world patterns do you need to know?

  git stash puts your uncommitted changes (both the working directory and what you already git add-ed) onto a stack and restores a clean working tree so you can switch tasks. Plain git stash is the same as git stash push. Three commands people mix up:…

• `git cherry-pick` in practice: when is it the right tool and when is it a sign of a branching strategy problem?

  git cherry-pick <commit copies one commit from another branch into the current branch — creating a new commit with the same changes but a different hash. When cherry-pick is correct: 1. A hotfix must be applied to several release branches: 2. Getting one specific commit…

• Partial clone and shallow clone: when do you use them in CI/CD to speed up pipelines?

• Git submodules vs git subtrees: why do most teams avoid both?

• What is Git LFS? Practical setup for a project with large design files and build artifacts?

• Why does `git pull` often create unnecessary merge commits and how do you fix it with `--rebase`?

  git pull is git fetch plus git merge. When you have unpushed local commits and a teammate has pushed new commits to the same branch, the two sides have diverged: each has commits the other lacks, so a fast-forward is impossible. The merge then has…

• Setting up a pre-commit hook with Husky + lint-staged: why lint only staged files instead of the whole project?

  A pre-commit hook runs on every commit, so it must be fast. Linting a large repo takes tens of seconds, and with a slow hook developers get used to typing --no-verify. lint-staged only runs commands on staged files (already git added), exactly what is about…

• commit-msg hook with commitlint: how to set it up and how to not block developers for WIP commits?

  commit-msg hook runs after you write the commit message and can reject the commit if the message does not follow the format. Setup: npm i -D @commitlint/cli @commitlint/config-conventional, with .husky/commit-msg (Husky v9) containing the single line npx --no -- commitlint --edit $1. commitlint.config.js: Allow WIP…

• Pre-push hook to run tests: what are the trade-offs and how do you configure it so it does not slow down the developer workflow?

  pre-push is a hook that runs on the developer's machine right before git push sends commits. If the hook exits with a non-zero code, the push is cancelled. The cost is waiting on every push, and if the suite takes minutes developers get used to…

• semantic-release: how do you automate versioning and CHANGELOG generation from conventional commits?

• Server-side hooks (GitHub Actions) vs client-side hooks (Husky): what should each enforce?

• What is the difference between `git fetch` and `git pull`? When should you only fetch?

  git fetch downloads new commits/refs from the remote into remote-tracking branches (origin/main) — it does NOT touch your working directory or local branch. git pull = git fetch + git merge (or + git rebase with pull.rebase configured) — it integrates directly into your current…

• When does a merge conflict happen? What is the basic process to resolve one?

  A conflict happens when git cannot merge automatically: both branches changed the same region of lines in the same file, or one side deleted a file the other side modified. Git pauses the merge and inserts conflict markers into the file: Resolution process: 1. git…

• What is a detached HEAD? How do you check out an old commit to inspect code and then return?

  Normally HEAD points to a branch; new commits move the branch along. When you git checkout <commit-hash (or check out a tag), HEAD points directly at a commit — the "detached HEAD" state. You can still read/build/test the code normally, but commits created here belong…

• A file was committed by mistake (e.g. `node_modules/`, a log file) — you added it to `.gitignore` but git still tracks it. How do you fix it?

  .gitignore only affects files that are not yet tracked. Once a file is committed, git keeps tracking it regardless of .gitignore — you must remove it from the index: Warnings: - Without --cached, git rm deletes the actual file from disk - The file still…

• How does Git differ from SVN (Subversion), and why is Git more widely used?

  The root difference: SVN is a centralized version control system, Git is distributed. With SVN, history lives only on one server; your machine has just a checkout. With Git, every clone gives you the whole repo with its full history locally. SVN Git --------- Model…

• What is the difference between Git and GitHub, and what is each one used for?

  Git is a tool, GitHub is a service. Git is version control software that runs on your machine (written by Linus Torvalds in 2005 for the Linux kernel). GitHub is a website that hosts Git repos on a server and adds collaboration features around them.…