100+ Free GitLab Git Associate Practice Questions

Pass your GitLab Certified Git Associate exam on the first try — instant access, no signup required.

✓ No registration✓ No credit card✓ No hidden fees✓ Start practicing immediately

Not publicly disclosed Pass Rate

100+ Questions

100% Free

1 / 10

Question 1

Score: 0/0

Which Git command initializes a new, empty repository in the current directory?

git create

git init

git start

git new

to track

2026 Statistics

Key Facts: GitLab Git Associate Exam

~30

Exam Questions

GitLab (plus practical lab)

80%

Passing Score

GitLab

90 min

Exam Duration

GitLab

$99

Exam Fee

GitLab

Online

Delivery

Remote proctored

2 years

Validity

Recertification required

The GitLab Certified Git Associate exam has approximately 30 questions in 90 minutes with an 80% passing score. It includes multiple-choice questions and a practical lab component. Topic areas: Git fundamentals (init, clone, add, commit, push/pull/fetch, diff, log), branching and merging (merge vs rebase, fast-forward, cherry-pick, conflicts), history management (revert, reset, stash, tag, blame, reflog), remote workflows (auth, force-with-lease), and GitLab basics (projects, groups, MRs, issues, branch protection, GitLab Flow). Exam fee is $99 USD. Certification is valid for two years.

Sample GitLab Git Associate Practice Questions

Try these sample questions to test your GitLab Git Associate exam readiness. Each question includes a detailed explanation. Start the interactive quiz above for the full 100+ question experience with AI tutoring.

1Which Git command initializes a new, empty repository in the current directory?

A.git create

B.git init

C.git start

D.git new

Explanation: `git init` initializes a new Git repository in the current directory by creating a `.git/` subdirectory containing the object database, refs, and config. The other commands are not valid Git subcommands. Exam tip: `git init --bare` creates a bare repository (no working tree) typically used as a remote target.

2Which command downloads a copy of an existing repository from a remote URL?

A.git fetch <url>

B.git clone <url>

C.git pull <url>

D.git copy <url>

Explanation: `git clone <url>` downloads the full repository, sets up the `origin` remote, and checks out the default branch. `git fetch` only updates remote-tracking branches in an existing repo, `git pull` fetches plus merges, and `git copy` is not a Git command. Exam tip: `git clone --depth 1` makes a shallow clone (only the latest commit) for faster fetches.

3What does `git add <file>` do?

A.Commits the file to the repository

B.Stages the file's current changes for the next commit

C.Pushes the file to the remote

D.Adds the file to .gitignore

Explanation: `git add <file>` moves the file's current state from the working tree into the staging area (index), preparing it to be included in the next commit. It does not commit, push, or modify .gitignore. Exam tip: `git add -p` lets you interactively stage individual hunks within a file.

4Which command creates a commit with the staged changes and a message in one step?

A.git commit -m 'message'

B.git commit --message='message'

C.Both A and B work — they are equivalent

D.git save -m 'message'

Explanation: Both `git commit -m 'message'` and `git commit --message='message'` are equivalent. Without `-m`, Git opens your configured editor for the commit message. `git save` is not a Git command. Exam tip: `git commit -am 'msg'` adds all tracked-but-modified files and commits in one step (does not include new untracked files).

5What is the difference between `git fetch` and `git pull`?

A.fetch downloads remote changes without modifying your working branch; pull fetches and then merges (or rebases) into your current branch

B.fetch is for tags; pull is for commits

C.There is no difference

D.fetch only works on the default branch

Explanation: `git fetch` updates remote-tracking refs (e.g., `origin/main`) but leaves your working branch unchanged. `git pull` is essentially `git fetch` followed by `git merge` (or `git rebase` if `--rebase` or `pull.rebase=true`). Use fetch when you want to inspect remote changes before integrating them. Exam tip: `git pull --rebase` keeps a linear history by rebasing local commits on top of fetched ones.

6Which command shows the working-tree changes that have NOT been staged?

A.git diff

B.git diff --staged

C.git status

D.git log -p

Explanation: `git diff` (no flags) shows changes in the working tree relative to the staging area — i.e., unstaged modifications. `git diff --staged` (or `--cached`) shows staged changes relative to HEAD. `git status` lists changed files but not the diff content. `git log -p` shows committed diffs. Exam tip: `git diff HEAD` shows both staged and unstaged changes vs the last commit.

7Which command lists all branches including remote-tracking ones?

A.git branch

B.git branch -a

C.git branch --remote

D.git branches

Explanation: `git branch -a` lists local AND remote-tracking branches. `git branch` (no flag) shows local only. `git branch --remote` (or `-r`) shows remote-tracking only. `git branches` is not a command. Exam tip: `git branch -vv` shows the upstream tracking branch and the latest commit message.

8Which command creates a new branch named `feature` AND switches to it?

A.git checkout -b feature

B.git switch -c feature

C.Both — checkout -b is the legacy form, switch -c is the modern form

D.git branch feature && git use feature

Explanation: Both `git checkout -b feature` (legacy) and `git switch -c feature` (introduced in Git 2.23) create and switch to a new branch in one step. `git switch` is the recommended modern command for branch operations; `git checkout` was overloaded for too many tasks. Exam tip: `git switch -` (no args) switches to the previous branch, like `cd -`.

9What is a fast-forward merge?

A.A merge that creates a merge commit with two parents

B.A merge where the target branch's tip is moved forward to the source branch's tip because there is a linear path between them

C.A merge that bypasses conflict checks

D.A merge that squashes commits

Explanation: A fast-forward merge happens when the target branch is a direct ancestor of the source branch. Git simply advances the target's pointer to the source's tip — no merge commit is created. Force a non-fast-forward with `git merge --no-ff` to always create a merge commit (preserving branch history). Exam tip: GitLab's MR settings can require `--no-ff` merges to keep visible feature branches in history.

10Which command merges branch `feature` into the current branch?

A.git merge feature

B.git pull feature

C.git combine feature

D.git checkout merge feature

Explanation: `git merge feature` merges the named branch into the current branch. The result is either a fast-forward (if linear) or a merge commit. `git pull` is for fetching + merging from a remote. The other options are not valid. Exam tip: resolve conflicts that arise during merge in your editor, then `git add` the resolved files and `git commit` to finish the merge.

About the GitLab Git Associate Exam

The GitLab Certified Git Associate is an entry-level credential from GitLab University that validates fundamental Git and GitLab platform skills. It tests the day-to-day Git command line, branching and merging, history management, remote workflows, and the GitLab collaboration features that engineers use to ship software.

Questions

30 scored questions

Time Limit

90 minutes

Passing Score

80%

Exam Fee

$99 (GitLab University (online proctored))

GitLab Git Associate Exam Content Outline

30%

Git Fundamentals

git init, clone, add, commit, push, pull, fetch, diff, log, status; staging area; .gitignore and .gitattributes; git config scopes; default branch configuration

25%

Branching and Merging

Creating, switching, renaming, and deleting branches; merge vs rebase; fast-forward vs no-ff; three-way merge; cherry-pick; conflict resolution; branch protection

20%

History Management

git revert, reset (soft/mixed/hard), stash, tag (lightweight vs annotated), blame, reflog, interactive rebase, signed commits, format-patch and am

15%

Remote Workflows

git remote add/set-url, push (including --force-with-lease), fetch, pull --rebase, SSH and PAT authentication, bare repos, mirrors, tracking branches

10%

GitLab Platform Basics

GitLab projects, groups, namespaces, Merge Requests, issues, labels, milestones, GitLab Flow, branch protection, CODEOWNERS, webhooks, Auto DevOps

How to Pass the GitLab Git Associate Exam

What You Need to Know

Passing score: 80%
Exam length: 30 questions
Time limit: 90 minutes
Exam fee: $99

Keys to Passing

Complete 500+ practice questions
Score 80%+ consistently before scheduling
Focus on highest-weighted sections
Use our AI tutor for tough concepts

GitLab Git Associate Study Tips from Top Performers

1Run every command on a real GitLab project — reading is not enough; muscle memory matters

2Master the three-area Git model: working tree, index (staging), and the repository — `git diff`, `git diff --staged`, `git diff HEAD`

3Know merge vs rebase deeply: when each preserves vs rewrites history, and when force-with-lease is needed

4Practice resolving merge conflicts manually in your editor — find the markers, edit, `git add`, then `git commit`

5Memorize branch lifecycle: create → switch → commit → push → MR → merge → delete (locally and remotely)

6Drill the difference between reset (rewrites history), revert (adds an undoing commit), and checkout/restore (modifies working tree)

7Understand GitLab's MR workflow end-to-end: branch → push → open MR → review → resolve discussions → merge → cleanup

Frequently Asked Questions

What is the GitLab Certified Git Associate exam?

The GitLab Certified Git Associate is an entry-level vendor certification from GitLab University. It validates working knowledge of Git command-line operations and core GitLab platform features used in everyday collaboration. The exam combines multiple-choice questions with a practical lab where you perform Git operations against a sample project.

How many questions are on the exam?

The exam has approximately 30 multiple-choice questions plus a practical lab component, with a 90-minute time limit. The passing score is 80%. The exam is delivered as an online, remotely proctored exam through GitLab University.

How much does the GitLab Git Associate exam cost?

The GitLab Certified Git Associate exam costs approximately $99 USD. The fee covers a single attempt; retakes require an additional fee. GitLab occasionally offers promotional pricing or bundles with training courses through GitLab University.

What are the largest topics on the exam?

Git fundamentals (~30%) is the largest area: clone, add, commit, push, pull, fetch, diff, log, status. Branching and merging (~25%) covers create/switch/delete branches, merge vs rebase, fast-forward, cherry-pick, and conflict resolution. History management (~20%), remote workflows (~15%), and GitLab platform basics (~10%) round out the exam.

Does the GitLab Git Associate certification expire?

Yes — GitLab certifications are typically valid for two years. To maintain the credential, you must retake and pass the current exam version before expiration. GitLab updates the exam periodically as the platform evolves.

How should I prepare for the GitLab Git Associate exam?

Plan for 20-40 hours of study over 2-4 weeks. Practice every common Git command in a real terminal — clone a public GitLab project, create branches, commit, rebase, resolve conflicts, push, and open MRs. Use the free GitLab University course materials as your primary guide. Take 100+ practice questions and aim for 90%+ before scheduling.

Who should take this exam?

The exam targets developers, QA engineers, technical writers, DevOps engineers, and anyone whose daily workflow involves Git and GitLab. It is a good first vendor certification for people transitioning into engineering roles or ones requiring proof of Git fluency.