Git and GitHub skills
employers expect in 2027

Git is the version control system behind almost all software, data science and infrastructure work, and GitHub is where much of that work is shared, reviewed and automated. Employers assume Git; they test it to make sure new hires won't lose work, break history or make reviews painful.

GitHub is also a public portfolio, particularly important in India's growing developer community. GitHub's Octoverse 2025 reported that India added more than 5.2 million developers in 2025 — the largest source of new developers on the platform — and projected India to become the world's largest developer community by 2030.⁵⁶

Developers India added on GitHub in 2025 (Octoverse)

5.2M+

Developers GitHub projects for India by 2030

~57.5M

Most-asked Git questions: merge vs rebase, reset vs revert

2

Command that rescues most "lost" commits: git reflog

1

Table: How Git and GitHub skills are tested (editorial summary)

git switch feature/invoice-export
git fetch origin
git rebase origin/main            # replay your commits on the latest main
# resolve any conflicts, then:
git add -A && git rebase --continue
git rebase -i origin/main         # squash "fix typo" commits into meaningful ones
git push --force-with-lease       # safer than --force: refuses if someone else pushed

Explain the choices: rebase onto the latest main for a clean history, interactive rebase to make commits meaningful, and --force-with-lease so you never overwrite a teammate's work. Then add: "I'd only do this on my own branch — never on a shared one."

"Merge or rebase?"

Merge preserves true history and is safe on shared branches; rebase gives linear history but rewrites commits. Rebase your own branches; merge shared ones (or follow team policy).

"How do you undo a commit that's already pushed?"

git revert creates a new commit undoing it — safe for shared history.

"What is a detached HEAD?"

HEAD points to a commit rather than a branch; new commits there aren't on any branch unless you create one.

"How do you resolve a merge conflict?"

Open the conflicted files, decide the correct combined content, remove markers, test, add and continue the merge or rebase.

"What does git stash do?"

Temporarily shelves uncommitted changes so you can switch context, then reapply them.

"When would you cherry-pick?"

To copy a specific fix to another branch, such as a hotfix to a release branch.

"What is git reflog?"

A local log of where HEAD and branches pointed — used to recover commits after resets or bad rebases.

"What makes a good pull request?"

Small, focused, a clear description of what and why, tests, and screenshots for UI changes.

Table: How Git practice has changed (editorial summary)

1. Conflict drills — Create conflicts deliberately on two branches and resolve them five times.
2. Recover from disaster — Hard-reset away commits, then restore them with reflog.
3. Interactive rebase — Squash, reorder and reword commits on a practice branch.
4. Contribute to open source — Fix a documentation issue in a project and go through review.
5. Tidy your profile — Pin two or three real projects with good READMEs and clean history.

Git is required everywhere; it shows up most in these roles (AmbitionBox, October 2026):

Table: Roles where Git is used daily and typical pay in India (AmbitionBox, October 2026; indicative)

1. Days 1–3: Everyday Git — Commits, branches, push and pull, .gitignore; Pro Git chapters 1–3.
2. Days 4–6: Combining work — Merge, rebase, conflicts.
3. Days 7–9: Undoing — restore, reset, revert, stash, reflog.
4. Days 10–12: GitHub — Pull requests, reviews, Actions basics; an open-source contribution.
5. Days 13–14: Prove it — Take the Git and GitHub Proficiency Certification.

Related: Code Review and Code Quality and CI/CD and DevOps.

• Feature branches — creating a branch per ticket and keeping it up to date with main.
• Pull requests — writing clear descriptions, responding to review and squashing noisy commits.
• Conflict resolution — merging busy branches without losing teammates' changes.
• Releases — tagging versions and cherry-picking hotfixes to release branches.
• Recovery — using reflog or revert when something goes wrong, calmly.
• Automation — GitHub Actions running tests and checks on every push.

• What branching strategy do you use — GitHub Flow, trunk-based or release branches?
• How big are typical pull requests, and how fast are reviews?
• Are branches protected, and what checks must pass before merging?
• How are hotfixes released?
• Do you use a monorepo or many repositories?

"What's the difference between git fetch and git pull?"

fetch downloads remote changes without changing your branch; pull fetches and then merges or rebases them into your current branch.

"How would you split one large commit into several?"

Interactive rebase with edit, then git reset HEAD~ and stage changes in logical groups with git add -p before committing each.

"What is a .gitignore for?"

Listing files Git shouldn't track — build outputs, dependencies, local config and secrets.

"What is the difference between a fork and a branch?"

A branch lives inside one repository; a fork is your own copy of someone else's repository, used to propose changes through pull requests when you can't push directly.

• Force-pushing shared branches.
• Huge PRs that no one can review.
• "fix", "changes", "final" commit messages.
• Committed secrets or build artefacts.
• Panicking instead of using reflog.

Technical references are the Pro Git book, GitHub Docs (pull requests and GitHub Flow) and the Conventional Commits specification; developer-community figures from GitHub's Octoverse 2025 as reported by YourStory. Test formats and the history table are editorial summaries; pay from AmbitionBox (read October 2026). Science of Apps publishes the free certification linked here; it is not affiliated with GitHub. Last reviewed October 2026.

• Commit — a saved snapshot of changes with a message.
• Branch — a movable pointer to a line of commits.
• Rebase — replaying commits on top of another base.
• Pull request — a proposal to merge changes, with review and discussion.
• Reflog — a local record of where HEAD has pointed, used for recovery.