Github has become an indispensable tool for developers over the past decade. As one of the most popular Git repository hosting services, Github allows developers to store, manage, and collaborate on software projects. With over 73 million users and 200 million repositories as of 2022, landing a job that involves Github knowledge is highly competitive.
To stand out from other candidates, you must demonstrate a strong and practical understanding of Github’s key features and workflows. Here are some of the most common Github interview questions you’re likely to encounter with example answers
What is Git?
Git is an open source distributed version control system that tracks changes in any set of files and coordinates work on those files among multiple developers It allows developers to work locally and performs version control operations such as committing and branching without relying on a central server
Key features of Git include:
- Distributed architecture – Enables developers to work offline and synchronize changes later
- Non-linear workflows – Supports thousands of parallel branches to enable flexibility
- Data assurance – Uses SHA-1 hashes and snapshots for data integrity and version tracking
- Efficiency – Only stores delta changes between file versions to optimize disk usage
How do you clone a repository in Git?
Cloning is the process of creating a copy of an existing Git repository, normally from a remote source. To clone a repository
git clone <remote_repo_url>
For example:
git clone https://github.com/user/repo.git
This will copy the entire remote repository and all its history to your local machine. You can now access the files and commit changes as if they were locally hosted.
Explain the difference between git pull and git fetch
Though git pull and git fetch are related Git commands for retrieving remote changes, there is a key difference:
-
git fetchdownloads new commits and files from a remote repo into the local repo. It does not integrate the changes into your working files. This gives you a chance to review changes before merging them. -
git pullfetches remote changes and immediately merges them with your local work. This is convenient but lacks flexibility in reviewing new changes before integrating them.
Walk through the typical Git workflow
Here is how developers typically use Git for version control:
- Modify working files in a local repo
- Stage files to mark changes for commit
- Commit staged snapshot to local history
- Fetch and merge remote changes from a central repository
- Push local commits to the central remote repo
- Remote repo shares changes with other developers
This workflow allows developers to locally track their changes, collaborate with remote teammates, and synchronize work.
How do you resolve merge conflicts in Git?
Merge conflicts occur when competing code changes happen on the same section of a file. To resolve it:
- Determine which branch has the correct code to keep
- Open the conflicted file and locate conflict markers like
<<<<<<< - Edit the file to remove conflict markers and keep the preferred code
- Stage the corrected file
- Commit the changes
- Push cleaned merge to remote repository
Carefully reviewing differences in the code and communicating with teams can help avoid such conflicts.
What is a branch in Git and how is it useful?
A branch in Git represents an independent line of development. Branches serve multiple purposes:
- Feature branches isolate new code under development from production code
- Release branches support preparation of releases with bug fixes and docs
- Experiment branches enable building experimental features safely
- Topic branches compartmentalize changes by context like features or issues
Branching enables developers to divert their work and merge it back cleanly when ready. Teams can thus work in parallel and increase productivity.
How do you create and switch to a new Git branch?
git checkout -b <branch_name>
This command creates a new branch with the given name and also switches the working directory to the new branch. For example:
git checkout -b new-feature
Would create a new-feature branch and make it the active branch to add commits to.
What constitutes a commit in Git?
A Git commit is a snapshot of your local repository at a given point in time. Each commit consists of:
- SHA hash – Unique ID for the commit
- Author metadata – Name, email, timestamp
- Commit message – Brief description of changes
- Pointer to parent commit – Reference to previous snapshot
- Staged file changes – New, modified, deleted files
Commits serve as a historical record of all the changes made to the code base over time.
How do you configure a remote repository in Git?
git remote add origin <remote_url>
This associates a remote repository URL with the name origin, assuming it is the primary remote. Additional remote repositories can be added similarly, each with a unique name.
Some examples:
git remote add origin https://github.com/user/repo.gitgit remote add upstream https://github.com/org/repoThis allows referencing the remotes by these names when pushing or fetching changes.
How do you undo local changes in Git?
To discard uncommitted local changes in Git:
- Check which files have changes:
git status - Reset the changed files:
git restore <file> - Discard all unstaged changes:
git restore .
This will undo all modifications since the last commit.
Alternatively, to revert a specific commit:
git revert <commit_hash>
This will create a new commit that reverses the given committed changes.
How do you squash multiple commits into one in Git?
Squashing commits combines multiple commits into a single new commit. For example:
git rebase -i HEAD~3
Would let you interactively pick 3 recent commits and merge them into one.
Squashing is useful for condensing many small commits related to one change into a concise single commit before merging a feature branch.
What is the difference between Git rebase and merge?
-
Merge – Combines feature branch history with main branch history into new merge commit
-
Rebase – Applies feature branch commits after main commits in linear order
Merging preserves complete project history with a branch point, while rebasing re-writes history by pretending the feature branch was developed after the main branch.
Rebasing is useful for cleaning up local changes before pushing to avoid extensive merge commits in the remote repository.
How do you configure Git to ignore files?
The .gitignore file specifies intentionally untracked files that Git should ignore.
To ignore files:
- Create
.gitignorein the repo root - Specify files to ignore with glob patterns
- Save and commit
.gitignore
Some examples:
# Ignore log files*.log#Ignore build output directories/build/Configured properly, .gitignore helps avoid accidental commits of transient files like logs or compiled binaries.
Explain how Git handles file renaming and moving
Though Git does not explicitly track file movement, it’s able to detect file renaming. If a file is renamed without substantial content changes in the same commit, Git will recognize it and record it as a rename operation.
If the file is completely new, Git will record it as an addition with newly calculated content delta. File moves across directories are generally seen as renames by Git.
This makes Git more intelligent about changes compared to version control tools that do not track renames at all.
How do you contribute to another developer’s repository in Github?
The typical Github workflow to contribute to someone else’s project is:
- Fork their repository – Creates your copy for changes
- Clone your fork locally – Enables you to work on files
- Create a new branch – Isolate your changes from main branch
- Make code changes and commit
- Push commits to your forked repo
- Open pull request to original repo – Ask for changes to be merged
- Collaborator reviews and merges pull request
This model allows contributing without directly changing the original project. The forked repository on Github provides the support for the collaborative workflow.
What is a pull request in Github?
A pull request on Github represents a request to merge code changes from one repository into another repository. This allows repository owners to review changes before integrating them.
To create a pull request:
- Push commits to a public branch on your fork
- Open Github page for original repo and click “New pull request”
- Select branch to merge from your fork
- Review diff of changes between branches
- Add description and create pull request
Now the repo owner can review, discuss, and merge the code changes through the pull request.
How do you integrate an upstream repository into your forked repo in Github?
Add the upstream repo URL as a remote:
git remote add upstream <original_repo_url>
Toptal sourced essential questions that the best Git developers and engineers can answer. Driven from our community, we encourage experts to submit questions and offer feedback.
What is the difference between git pull and git fetch?
While git fetch downloads new data from a remote repository, it doesn’t add any of that data to your working files. All it does is provide a view of this data.
git pull downloads as well as merges the data from a remote repository into your local working files. It may also lead to merge conflicts if your local changes are not yet committed. Use the git stash command to hide your local changes. 2 .
How do you revert a commit that has already been pushed and made public?
One or more commits can be reverted through the use of git revert. In essence, this command makes a new commit with patches that undo the changes made in previous commits. You can use git revert to undo commits if the one you want to undo has already been made public or if you can’t change the repository history. Running the following command will revert the last two commits:
Alternatively, one can always checkout the state of a particular commit from the past, and commit it anew. 3 .
How do you squash last N commits into a single commit?
Squashing multiple commits into a single commit will overwrite history, and should be done with caution. However, this is useful when working in feature branches. Run the following command (with {N} changed to the number of commits you want to squash) to get rid of the last N changes to the current branch:
That’s it! The editor will open with a list of these N commit messages, one on each line. Each of these lines will begin with the word “pick”. Replacing “pick” with “squash” or “s” will tell Git to combine the commit with the commit before it. To merge all N commits into one, make all but the first one of the list of commits “squash.” If there are no conflicts, git rebase will let you make a new commit message for the new combined commit after you close the editor.
Apply to Join Toptals Development Network
and enjoy reliable, steady, remote Freelance Git Developer Jobs
How do you find a list of files that has changed in a particular commit?
Given the commit hash, this will list all the files that were changed or added in that commit. The -r flag makes the command list individual files, rather than collapsing them into root directory names only.
The output will also have some extra information, which can be easily turned off by adding a few flags:
In this case, –no-commit-id will hide the commit hashes from view, and –name-only will only show the file names without their paths. 5 .
How do you setup a script to run every time a repository receives new commits through push?
You need to define either a pre-receive, update, or post-receive hook to make a script run every time a repository gets new commits through push. This depends on when the script needs to be run.
Pre-receive hook in the destination repository is invoked when commits are pushed to it. Any script bound to this hook will be executed before any references are updated. This is a useful hook to run scripts that help enforce development policies.
The update hook works like the pre-receive hook, and it is also set off before any updates are made. However, the update hook is called once for every commit that has been pushed to the destination repository.
Finally, post-receive hook in the repository is invoked after the updates have been accepted into the destination repository. This is a great spot to set up simple deployment scripts, run continuous integration systems, send email alerts to repository administrators, and more.
Hooks are local to every Git repository and are not versioned. Scripts can either be created within the hooks directory inside the “. git” directory, or they can be made somewhere else, and then links to those scripts can be added to the directory. 6 .
What is git bisect? How can you use it to determine the source of a (regression) bug?
Git provides a rather efficient mechanism to find bad commits. With git bisect, the user doesn’t have to go through every commit to find the first one that fixed a problem. Instead, they can do a sort of binary search on the whole history of a repository.
By issuing the command git bisect start, the repository enters bisect mode. After this, all you have to do is identify a bad and a good commit:
Once this is done, Git will then have a range of commits that it needs to explore. At each step, it will check out a different commit from this range and ask you to mark it as good or bad. After that, the range will be cut in half, and the search will take a lot fewer steps than the number of commits in the range. The following command can be used to leave the bisect mode and start over once the first bad commit has been found or in case the mode needs to be ended:
What are the different ways you can refer to a commit?
In Git each commit is given a unique hash. In many situations, like when you use the git checkout {hash} command to try to checkout a certain state of the code, these hashes can be used to find the corresponding commits.
Additionally, Git also maintains a number of aliases to certain commits, known as refs. In addition, each tag you add to the repository acts as a reference, which is why you can use tags instead of commit hashes in some git commands. As the repository changes, Git also keeps track of a number of unique aliases, such as HEAD, FETCH_HEAD, MERGE_HEAD, and so on.
Git also allows commits to be referred as relative to one another. In this case, HEAD^1 means the commit parent to HEAD, HEAD^2 means the commit grandparent of HEAD, and so on. “^” can be used to choose one of the two parents of a merge commit if the commit has two. g. HEAD^2 can be used to follow the second parent.
And finally, refspecs. These are used to map local and remote branches together. But these can also be used to talk about commits that live on remote branches and can be managed and changed from a local Git environment. 8 .
What is git rebase, and how can it be used to fix issues in a feature branch before merging?
For simple explanations, git rebase lets you change where the branch’s first commit starts. For instance, if new commits were made to master after a feature branch was made, git rebase can be used to move the feature branch to the end of master. The command will basically play back the changes that were made in the feature branch at the very end of master. This lets any conflicts be worked out at the same time. If you’re careful, this will make it possible for the feature branch to be merged into master with little trouble, sometimes just by fast-forwarding. 9 .
How do you set up a Git repository so that code sanity checking tools run right before commits and stop them if the test fails?
This can be done with a simple script bound to the pre-commit hook of the repository. The pre-commit hook is run right before a commit is made, even before you have to type a commit message. This script lets you run other tools, like linters, and make sure the changes you’re committing to the repository are correct. For example, the following script:
… checks to see if any . The standard Go source code formatting tool gofmt needs to be run on a go file that is about to be tracked. By exiting with a non-zero status, the script effectively prevents the commit from being applied to the repository. 10 .
Someone on your team deleted a branch by accident and has already pushed the changes to the main Git repository. There are no other git repos, and none of your other teammates had a local copy. How would you recover this branch?.
The most recent change to this branch can be found in the reflog. You can then check it out as a separate branch. 11 .
How can you copy a commit made in one branch to another (e. g. a hot fix commit from released branch to current development branch)?.
You need to use the cherry-pick command. It provides the possibility to play back an existing commit to your current location/branch. So you need to switch to the target branch (e. g. git checkout development) and call git cherry-pick {hash of that commit}.
Even though the same changes are made, it will be a new commit with a new hash because the changes are made to a different place. 12 .
How do you cherry-pick a merge commit?
Cherry-pick uses a diff to find the difference between branches.
As a merge commit belongs to a different branch, it has two parents and two changesets.
Let’s say you want to merge commt ref 63ad84c. You need to use parent 1 as a base and specify -m:
What is a conflict in git and how can it be resolved?
Two or more commits that need to be merged have changes in the same place or line of code. This is called a conflict. Git will not be able to predict which change should take precedence. This is a git conflict.
To fix the conflict in git, make the necessary changes to the files and then add the fixed files by running git add. After that, to commit the repaired merge, run git commit. Git knows you are in the middle of a merge, so it sets the commit’s parents correctly.
There is more to interviewing than tricky technical questions, so these are intended merely as a guide. Not every good candidate for the job will be able to answer all of them, and answering all of them doesn’t mean they are a good candidate. At the end of the day, hiring remains an art, a science — and a lot of work.
Tired of interviewing candidates? Not sure what to ask to get you a top hire?
Let Toptal find the best people for you.
Our Exclusive Network of Git Developers
Looking to land a job as a Git Developer?
Let Toptal find the right job for you.
Job Opportunities From Our Network
Submit an interview question
Questions and answers sent in will be looked over and edited by Toptal, LLC, and may or may not be posted, at their sole discretion.
Mastering Git & GitHub: Top 15 Interview Questions & Answers | Git Interview Mastery
FAQ
How to explain GitHub in an interview?
What is the difference between Git and GitHub interview questions?
Why do you want to work at GitHub?
What is the main objective of Git?
What are basic GitHub interview questions?
Basic GitHub interview questions assess familiarity with GitHub’s interface and basic commands, ensuring the candidate can navigate and utilize GitHub effectively for software development projects. What is GitHub, and how does it differ from Git? How do you create a new repository in GitHub? Explain the concept of a Git branch in GitHub.
How do I prepare for a GitHub interview?
Candidates being asked GitHub interview questions will often be told to differentiate between the online service and the Git tool itself, so be prepared when the opportunity arises. 2. Name two Git commands that are not supported by GitHub Desktop. The GitHub Desktop app is designed primarily to simplify the most commonly used functions.
What are advanced GitHub interview questions 2024?
Mindmajix offers Advanced GitHub Interview Questions 2024 that helps you in cracking your interview & acquire your dream career as GitHub Developer. What is a clone in GitHub? How much space do we get on GitHub? What do you know about GitHub and its repository? Can you tell us a few benefits of using GitHub over other platforms?
How to understand GitHub?
For understanding GitHub, we should understand “Git.” “Git” is the version control system, which means that whenever the developer creates something and makes changes to the code or releases new versions, anyone can keep track of all the modifications in a central repository. Moving to questions and answers: 1. What Is Github?
