Interview Q&A

A Git tag marks specific points in a repository’s history — usually to label release versions

(like v1.0, v2.1, etc.). It’s like a snapshot that says, “this commit is stable and ready to

release.”

Types of tags:

• Lightweight tag: just a name for a commit.
• Annotated tag: includes metadata like the tagger’s name, date, and message.

Commands:

git tag -a v1.0 -m "Version 1.0 release"

git push origin v1.0

Real-world example:

fter testing your project, you tag the commit representing your first release with v1.0. This

helps other developers or CI/CD pipelines identify which version is live.

A branch in Git is like a separate line of development — a parallel universe for your code. It

llows you to work on new features, bug fixes, or experiments without affecting the main

codebase (usually called the main or master branch).

Why branches are useful:

They make collaboration easier by keeping each developer’s work isolated until it’s ready to

be merged back.

Real-world example:

Imagine your company website is live, but you need to add a “dark mode” feature. Instead

of editing the main code directly (which might break the live site), you create a new branch

called feature/dark-mode to work independently. Once it’s done and tested, you merge it

back into main.

Git is a distributed version control system (VCS) that allows multiple developers to work on

project without overwriting each other's work. It's designed to be fast, flexible, and

scalable, allowing developers to track changes in code and collaborate with ease.

In contrast, SVN (Subversion) is a centralized version control system. This means that SVN

has one central repository, and developers check out code to work locally. Git, on the other

hand, allows every developer to have their own full local repository, including the project’s

history. This makes Git faster and more reliable, especially in distributed teams.

Real-World Example:

If you were working on a website project with a team, using Git allows each developer to

clone the repository, make changes locally, and push their changes without disrupting others.

In SVN, the code is pulled from the central server, and only one developer can commit

changes at a time.

Answer: A distributed version control system (DVCS) for tracking changes in source code during software development.

What interviewers expect

• A clear definition tied to Version Control in Git & GitHub projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Git & GitHub application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Git & GitHub architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Comman

Description Safe for shared

repos?

git revert Creates a new commit that undoes changes from a

previous commit

✅ Yes

git reset Moves the branch pointer back to a previous commit,

potentially removing commits

❌ No (rewrites

history)

Example:

If you realize a commit caused an error:

• git revert will make a new commit that undoes it.
• git reset will erase it as if it never happened (good for local cleanup).

A Pull Request is a request to merge your changes from one branch or fork into another

repository or branch — typically to propose new code, bug fixes, or improvements.

Example:

You fixed a typo or added a feature in your fork of a project. You create a PR asking the

original maintainers to “pull” your changes into their main branch.

PRs enable:

• Code review
• Automated testing
• Discussion before merging

A commit in Git is a snapshot of your project at a specific point in time. It records all the

changes you've made to the files and saves them to the repository. Every commit has a

unique ID, and it's like a save point in a video game—if something breaks, you can go back

to any commit.

Real-World Example:

Let’s say you fixed a bug on the homepage of your app. After completing the fix, you commit

the changes to the repository. Later, if the fix causes an issue, you can roll back to the

previous commit.

git stash temporarily saves your uncommitted changes so you can work on something

else without committing unfinished work.

Example:

You’re fixing a login bug but suddenly need to switch branches to fix a production issue.

Instead of committing half-done code, you run:

git stash

git checkout main

Later, you can come back and reapply your stashed work.

A fast-forward merge happens when the target branch has not diverged — meaning, there

re no new commits on main since you branched off. Git simply moves the branch pointer

forward to include all your new commits, without creating a new merge commit.

Example:

If main has not changed since you created your feature/navbar branch, merging it back

will simply “fast-forward” main to the latest commit.

git merge feature/navbar

No merge commit — just a pointer move.

git stash temporarily saves your uncommitted changes so you can work on something

else without committing unfinished work.

Example:

You’re fixing a login bug but suddenly need to switch branches to fix a production issue.

Instead of committing half-done code, you run:

git stash

git checkout main

Later, you can come back and reapply your stashed work.

• git fetch: It retrieves changes from a remote repository but does not apply them to

your working directory. You can think of it as checking for updates without actually

installing them.

• git pull: This does two things: it fetches the latest changes and then merges them

into your current branch. It's like fetching updates and immediately applying them.

Real-World Example:

If you're working on a project with teammates, git fetch allows you to see what changes

have been made without affecting your code. git pull, on the other hand, will update your

local copy and merge those changes with your work, which can sometimes result in merge

conflicts.

time, including changes and a message.

What interviewers expect

• A clear definition tied to Version Control in Git & GitHub projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Git & GitHub application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Git & GitHub architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: (Duplicate of #4) A snapshot of your project at a specific point in time, including changes and a message.

What interviewers expect

• A clear definition tied to Version Control in Git & GitHub projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Git & GitHub application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Git & GitHub architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

A lightweight, movable pointer to a commit, allowing for parallel development.

What interviewers expect

• A clear definition tied to Version Control in Git & GitHub projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Git & GitHub application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Git & GitHub architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

spect GitHub Flow Git Flow

Purpose Simple branching model for

continuous delivery

Structured model for release

management

Branche

Only main and short-lived feature

branches

Multiple: main, develop, feature,

release, hotfix

Workflow Create branch → Commit → Pull

Request → Merge → Deploy

Feature branches merge into develop,

then release/hotfix merges into main

Use Case SaaS projects, frequent deploys Complex products with scheduled

releases

Example:

• GitHub Flow → Used by startups deploying updates daily.
• Git Flow → Used by large software teams (e.g., enterprise apps) with versioned

releases.

A detached HEAD happens when Git’s HEAD (your current position) points to a specific

commit instead of a branch. If you make new commits in this state, they won’t belong to any

branch — you could lose them if you switch branches.

How to fix it:

If you accidentally commit in a detached HEAD state:

git switch -c temp-branch

This creates a new branch from your current state so your commits aren’t lost.

Example:

You checked out an old commit to test something:

git checkout a1b2c3d

If you make changes, create a branch to save them before switching back.

A detached HEAD occurs when Git’s HEAD (which points to your current branch) points to a

specific commit instead of a branch. This means you’re not working on any branch — any

new commits made in this state are “orphaned” unless you create a branch from them.

Example:

If you check out an old commit directly:

git checkout a1b2c3d

You’re in a detached HEAD state.

If you make changes here and don’t create a new branch, you could lose them later.

Fix:

Create a new branch to save your work:

git checkout -b hotfix/rollback-test

The .gitignore file tells Git which files or directories it should ignore when tracking

changes. This is useful for files that aren’t necessary in the repository, like log files, compiled

binaries, or local configuration files.

Real-World Example:

If you're working on a Node.js project, you likely don’t want to track the node_modules/

directory, since it can be recreated by running npm install. You can add

node_modules/ to your .gitignore file to ensure that Git doesn't track those files.

to build, test, and deploy code directly from GitHub.

What interviewers expect

• A clear definition tied to Version Control in Git & GitHub projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Git & GitHub application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Git & GitHub architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: The default name for the remote repository from which a project was originally cloned.

What interviewers expect

• A clear definition tied to Version Control in Git & GitHub projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Git & GitHub application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Git & GitHub architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

A pointer to the current commit you are on in your local repository.

What interviewers expect

• A clear definition tied to Version Control in Git & GitHub projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Git & GitHub application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Git & GitHub architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: A configuration file that stores user-specific Git settings (e.g., username, email, aliases).

What interviewers expect

• A clear definition tied to Version Control in Git & GitHub projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Git & GitHub application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Git & GitHub architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Shows changes between the staging area and the last commit.

What interviewers expect

• A clear definition tied to Version Control in Git & GitHub projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Git & GitHub application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Git & GitHub architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Displays the commit history of the current branch.

What interviewers expect

• A clear definition tied to Version Control in Git & GitHub projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Git & GitHub application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Git & GitHub architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Shows the URLs of the remote repositories associated with your local repo.

What interviewers expect

• A clear definition tied to Version Control in Git & GitHub projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Git & GitHub application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Git & GitHub architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.