Top 20 Git Interview Questions and Answers for 2025

Q1) What do you understand by the term Git?

Git is a distributed version control system (DVCS) and a source code management (SCM) tool. It is specifically designed to handle projects of any size, ranging from small to large-scale, with remarkable speed and efficiency. Git allows developers to efficiently track changes, collaborate with team members, and manage code across multiple development environments. Its distributed architecture ensures that every contributor has a complete copy of the repository, enhancing collaboration and resilience.

Q2) Explain a Git repository.

A Git repository serves as a storage location for a project’s source code and its entire history of changes. When a project is initialized as a Git repository, a hidden .git directory is created within the project folder. This directory contains all essential metadata, objects, and configuration files required by Git for version control operations.

The repository allows developers to:

• Track changes to files over time.
• Create branches for independent development.
• Collaborate by pushing and pulling changes to/from remote repositories.

This system ensures that every contribution is tracked and easily accessible, promoting effective collaboration and preserving repositories and branches in Git to maintain code integrity throughout the project lifecycle.

Q3) What is the main difference between Git and SVN?

The key distinction between Git and SVN lies in their version control architectures:

1. Git (DVCS):

   • Each user has a complete copy of the repository, including its entire history.
   • Enables offline work since all data is stored locally.
   • Highly flexible, with features like branching and merging that are faster and more robust.
   • Promotes a decentralized workflow, reducing reliance on a central server.

2. SVN (CVCS):

   • Operates with a central repository where all changes are stored.
   • Requires an active connection to the central server for most tasks, limiting offline functionality.
   • Branching and merging are more complex and slower compared to Git.

While SVN suits some centralized workflows, Git's distributed nature makes it a preferred choice for modern development practices.

Q4) What do you mean by Git fork?

A Git fork refers to the act of creating a personal copy of someone else’s repository. This copy exists independently and is often used to experiment with changes, test new features, or fix bugs without affecting the original repository. Forking is commonly used in open-source projects, where developers can propose changes or improvements.

For example, if a developer wants to contribute to an open-source project, they can fork the repository, make changes in their fork, and then submit a pull request to the original repository for review and potential integration.

Q5) What do you understand by the term cherry-pick in Git?

Cherry-picking in Git is the process of selecting a specific commit from one branch and applying it to another branch. This operation is useful when developers want to include certain changes without merging an entire branch.

For example, suppose a bug fix is committed to a development branch, and that fix is needed in the main branch. Instead of merging the entire development branch, the specific bug fix commit can be cherry-picked into the main branch.

While cherry-picking is powerful, it should be used sparingly, as it can lead to a more complex commit history and potential conflicts.

Q6) What is the function of the clone command in Git?

The git clone command creates a complete copy of an existing Git repository. It is typically used to copy remote repositories onto a developer’s local machine. The cloned repository includes all branches, tags, and the project’s entire commit history.

This command is especially helpful for:

• Setting up new local environments for development.
• Sharing code with team members.
• Creating a local backup of a repository.

For example, if a repository is hosted on GitHub, developers can use git clone to download the project and start contributing immediately.

Q7) What is the concept of ‘head’ in Git, and how many heads can be created in a repository?

In Git, a head is a pointer that represents the most recent commit in a branch. The default head of a repository is often called master (or main in newer versions).

A repository can have multiple heads, as each branch represents a separate head. Developers can create and switch between these heads to work on different features, bug fixes, or experiments simultaneously without interfering with each other’s work.

For example, creating a new branch named feature-login establishes a new head for tracking commits related to that feature.

Q8) What are some examples of Git repository hosting services?

Some widely used Git repository hosting services include:

1. GitHub: Known for its extensive collaboration tools, open-source community, and integrations with CI/CD pipelines.
2. GitLab: Offers built-in DevOps features like CI/CD, project management tools, and issue tracking.
3. Bitbucket: Popular for teams using Atlassian products like Jira, with strong support for private repositories.

These platforms enhance Git’s capabilities by adding layers of functionality such as pull requests, code reviews, and team management.

Q9) What is the main function of the ‘Git reset’ command?

The git reset command is used to undo changes and reset the state of the repository to a specific commit. Depending on the options used, it can:

• Unstage files: Remove files from the staging area without deleting changes.
• Undo changes: Reset both the staging area and working directory to match a previous commit.
• Adjust branch state: Move the branch pointer to a specific commit, discarding subsequent commits.

This command is particularly useful for fixing mistakes, such as staging or committing unintended changes.

Q10) What is a ‘conflict’ in Git?

A conflict in Git occurs when two or more commits attempt to modify the same part of a file in different ways. This situation typically arises during a merge operation, where Git cannot automatically reconcile the differences.

To resolve a conflict, developers must manually review the conflicting file, decide which changes to keep, and edit the file accordingly. After resolving the conflict, the file must be staged and committed to complete the merge.

Git provides tools like merge markers to help developers identify conflicting sections, ensuring that the resolution process is straightforward and transparent.

Q11) What is a ‘bare repository’ in Git?

A bare repository in Git is a repository that contains only the version control data but no working files. Unlike a standard Git repository, a bare repository lacks the working directory and does not contain the special .git subdirectory. Instead, it directly includes the contents of what would typically reside within the .git directory. Bare repositories are commonly used for remote repositories to facilitate collaboration without the need for local file access.

Example:
If you create a bare repository, it will look like this:

git init --bare my-bare-repo.git

Q12) What programming language is Git written in, and why?

Git is written in the C programming language. The use of C ensures that Git operates with exceptional speed and efficiency by reducing the runtime overhead often associated with higher-level programming languages. This choice allows Git to handle large-scale projects and operations with outstanding performance.

Example:
When you execute a Git command like git log, the speed at which the commit history is retrieved and displayed is a testament to the efficiency of the underlying C code.

Q13) What is the main difference between git pull and git fetch?

The git pull command fetches new commits from a specific branch of a remote repository and integrates them into the current branch of the local repository. On the other hand, the git fetch command retrieves all new commits from a remote branch but stores them in a separate branch within the local repository. Unlike git pull, git fetch does not automatically merge the changes.

Example: 

# Fetch changes but do not merge
git fetch origin main

# Pull changes and merge automatically
git pull origin main

Using git fetch allows you to review changes before integrating them, while git pull directly applies the updates to your local branch.

Q14) How can you revert a commit that has already been pushed and made public?

To revert a commit that has been pushed and made public, you can use the git revert command. This command creates a new commit that undoes the changes introduced by the specific commit. By generating a reverse patch, git revert ensures that the original commit remains in the history while effectively canceling its impact.

Example:
If you want to revert the commit with hash abc123:

git revert abc123

Q15) What is SubGit?

SubGit is a powerful tool designed to simplify the migration from Subversion (SVN) to Git. It enables the creation of a writable Git mirror of an SVN repository, allowing developers to work with both systems simultaneously. This seamless integration eliminates the need for a sudden switch, making the migration process smoother and less disruptive.

How SubGit Works:

1. SubGit establishes a bi-directional synchronization between the SVN repository and the Git mirror.
2. Any changes pushed to the Git repository are automatically reflected in the SVN repository and vice versa.
3. This synchronization ensures developers can choose their preferred VCS during the transition period.

Example Use Case:

• A team wants to migrate their version control system from SVN to Git.
• They install SubGit and set up a Git mirror.
• While part of the team adopts Git for development, others continue using SVN. SubGit keeps both repositories synchronized, allowing the team to gradually transition to Git.

Q16) What are the key objectives of Git design?

The design of Git revolves around addressing the needs of modern software development while ensuring speed, flexibility, and reliability.

Key Objectives:

1. Distributed Workflow:

   • Git allows every developer to have a complete local copy of the repository.
   • Example: Developers can work offline and push their changes when they reconnect.

2. Easy Merging:

   • Git simplifies merging, reducing conflicts and ensuring smooth collaboration.
   • Example: When two team members work on different features, Git helps merge their changes with minimal manual intervention.

3. Integrity:

   • Git uses SHA-1 hashing to ensure the accuracy of commit history and prevent corruption.
   • Example: A commit ID like d6f8e0f... uniquely identifies a state of the repository.

4. Speed & Scalability:

   • Git is optimized for fast performance, even for large-scale projects.
   • Example: Cloning Linux’s source code repository (over 1 GB) is faster with Git compared to other VCS tools.

Q17) What are the benefits of using Git?

Git provides numerous benefits, making it a popular choice for version control:

1. Flexible Workflow:

   • Git supports branching, merging, and rebasing, allowing teams to adopt workflows that suit their needs.
   • Example: Feature branching enables isolated development without affecting the main codebase.

2. Fast Performance:

   • Operations like commits, merges, and branching are lightning-fast due to Git’s distributed architecture.
   • Example: Developers can switch between branches in seconds, even in large repositories.

3. Data Integrity:

   • Git ensures the integrity of files and commit history, preventing unauthorized changes.
   • Example: SHA-1 hashes validate every commit and file state.

4. Free Collaboration:

   • Git is open-source and free to use, reducing costs for teams and organizations.
   • Example: Teams can set up private repositories on platforms like GitHub without paying for the software.

Q18) What is the feature branching strategy in Git?

The feature branching strategy is a Git workflow where developers create a separate branch to work on a specific feature. This branch is isolated from the main branch, ensuring that incomplete or buggy code does not affect the main codebase.

How It Works:

1. Create a feature branch (e.g., feature-login).
2. Develop and test the feature within the branch.
3. Once complete and tested, merge it into the main branch.

Example:

• A developer wants to add a user login feature.
• They create a branch: git checkout -b feature-login.
• After completing the feature and testing it, they merge it back into the main branch using: git merge feature-login.

Benefits:

• Keeps the main branch stable.
• Facilitates parallel development by multiple team members.

Q19) What is the task branching strategy in Git?

The task branching strategy involves creating a dedicated branch for each task, often incorporating the task ID or key into the branch name for easy identification. This strategy is particularly useful in Agile and Scrum workflows.

How It Works:

1. Create a branch named after the task (e.g., task-123-add-login).
2. Develop the changes related to the task within the branch.
3. Merge the branch into the main branch after completion.

Example:

• A task in Jira is assigned with the ID 123 for adding a login button.
• The developer creates a branch: git checkout -b task-123-add-login.
• After completing the task, they merge it and delete the branch.

Benefits:

• Enhances traceability by linking branches to tasks.
• Makes it easy to identify the purpose of each branch.

Q20) What is Git rebase?

Git rebase is a powerful command used to move or combine commits from one branch onto another, creating a linear sequence of changes. Unlike merging, which retains the history of branches, rebasing rewrites commit history to make it appear as though changes were made sequentially.

How It Works:

1. Switch to the branch you want to rebase: git checkout feature-login.
2. Rebase it onto another branch (e.g., main): git rebase main.

Example:

• A feature-login branch was created off main. Since then, new commits have been added to main.
• Rebase applies the feature-login commits on top of the latest commits from main, creating a clean, linear history.

Benefits:

• Maintains a cleaner commit history.
• Simplifies debugging by avoiding unnecessary merge commits.

Caution:

• Avoid rebasing public branches to prevent conflicts for others working on the same branch.