GitLab Certified CI/CD Associate: preparation guide

This page offers a concrete preparation plan for the GitLab Certified CI/CD Associate. The exam asks 50 questions, either multiple choice or multiple response, in 75 minutes, online and unproctored. It has been redesigned and no longer includes a hands-on project to submit, unlike its previous version. The goal here is not to copy the official documentation, but to turn the training and the labs into a realistic practice plan, then to measure yourself against the mock exam that closes this page.

What you will learn

The real exam format, taken from the source, and what its redesign changes
The six published objectives, and the lessons that teach each one
How to turn the training into a certification preparation plan
What to practice first to be comfortable on exam day
The most frequent preparation mistakes and how to avoid them

Prerequisites

This page prepares you for an exam, it teaches no new technical skill. Its only real prerequisite is to have followed the GitLab CI/CD training, at least level C1, "write a pipeline and read its failures": knowing how to write a .gitlab-ci.yml, explain the role of a runner, and read the log of a failing job. The revision weeks below point to the other lessons and labs of the training, to be replayed as the preparation goes.

No particular right or tool is required to read the page or take the mock exam. Only registration for the real exam happens on GitLab University, it is paid and its format is detailed below. The labs cited in the programme each carry their own prerequisites. Upstream lessons:

Core concepts: pipeline, stage, job and runner
First pipeline: write a first .gitlab-ci.yml
Runners: executors and tags
Reading the logs: understand a failing job

Official format to know

The format below was taken from the source on GitLab University on 22 October 2026. It is worth reading before any revision, because it dictates what you need to work on.

What is announced	Value
Number of questions	50, multiple choice or multiple response
Duration	75 minutes
Delivery	online, unproctored
Attempts	2 per registration
Access	14 days after registration
Language	English
Price	150 USD, 120 for partners

This exam has been redesigned, and that is the most important point in this section. The previous version required a hands-on project submission, graded by GitLab engineers. The new one is a questionnaire, and the original page announces the automatic migration of people already registered after 31 January 2026. Anyone preparing with resources older than that date is therefore preparing for an exam that no longer exists.

No per-domain weighting is published. Nothing supports the claim that one subject carries more weight than another in the 50 questions, which is why the mock exam on this page splits its own evenly across the six announced objectives.

The GitLab CI Fundamentals Learning Path remains the closest official path to prepare for this certification.

Before setting your date, always check:

the exact name of the certification
the format currently in force
the announced prerequisites
the associated learning path

In which context?

You are in this case if you already know how to run a simple pipeline and want to consolidate the basics expected to work properly with GitLab CI/CD: understand runners, structure a pipeline, maintain it, and resolve common incidents.

Real situations where this guide is useful:

you must standardize the pipelines of several GitLab teams
you are going through a DevOps or Platform interview with proof of CI/CD skills
you lose time on the same incidents (pending jobs, a pipeline that never shows up, ineffective cache)
you want to frame a team upskilling with a common reference

Who is this certification relevant for?

This certification is relevant if you:

already use GitLab CI/CD daily
must standardize or maintain existing pipelines
want to demonstrate a solid foundation on GitLab CI/CD
are looking for proof of skill more concrete than simply reading documentation

What this certification does not replace

A certification attests a foundation, not expertise. Knowing where this foundation stops avoids two opposite mistakes: overselling it on a CV, or neglecting it because it does not cover everything. Here is precisely what it leaves out.

The GitLab Certified CI/CD Associate does not replace:

real production experience
mastery of Kubernetes or the cloud
the advanced topics of supply chain, trusted delivery or governance
runner architecture choices at large scale

Skills to consolidate to be ready

The certification targets a solid practice of the fundamental mechanisms of GitLab CI/CD, and GitLab publishes the exact list of what it validates. Better to start from that list than from an interpretation: it is what tells you where to spend your time.

The table below starts from the six published objectives, quoted in their original wording, and points to the lessons that perform each of those moves. The first five are the announced tasks; the sixth appears only in the exam's description paragraph, which none of the five tasks repeats.

Published objective	What it requires you to be able to do	Lessons that teach it
Create and configure .gitlab-ci.yml files with proper YAML syntax, variables, artifacts, and caching strategies	Write and fix a pipeline file, place its variables, keep and reuse files between jobs	First pipeline, Variables, Artifacts and cache
Install, configure, and manage GitLab Runners across different environments and executors	Declare a runner, choose its executor, address it by its tags	Runners
Build and manage container images and packages using GitLab's integrated registries	Build then publish an image, manage tags and packages	Image and package registries
Implement security scanning tools within CI/CD workflows and interpret vulnerability reports	Turn the scanners on, read their reports, rule on a false positive	Security scanners
Diagnose pipeline failures and optimize performance using best practices and troubleshooting techniques	Read a log, handle a pending job, tell apart the three cases of a missing pipeline, speed things up and make them reliable	Read the logs, Pending job, Skipped pipeline, Reliability
pipeline development with stages, jobs, and DAG architectures	Organise stages and jobs, then free them from stage order with `needs`	Core concepts, DAG and parallelism

Two subjects in this training appear in no published objective, and knowing that helps you budget your time: YAML factoring (extends and anchors, templates and include) and the whole advanced security strand. They matter for the job, and the security strand is even what this site defends first, but nothing indicates they are assessed. Working on them is useful; working on them instead of the six objectives above would be a preparation mistake.

4-phase preparation plan

The four phases below give the progression to follow; the four-week program in the next section details them and ties them to the labs. Adapt them to your starting level and your real practice of GitLab.

Stabilize the fundamentals

Review the modules of level C1, "write a pipeline and read its failures": YAML structure, rules, runners, variables, debugging.
Industrialize without needless complexity

Work on extends, templates, DAG and workflows to produce readable, fast and maintainable pipelines.
Practice on real cases

Run the labs end to end and redo the ones that fail without looking at the solution.
Simulate incidents

Train on correcting scenarios: missing or skipped pipeline, pending job, missing artifacts, ineffective cache.

Recommended program

This four-week split follows a precise logic: first stabilize what breaks most often (syntax and rules), then learn to diagnose, and only then industrialize. Each tab ends with its validation labs, which are the real criterion for moving on to the next week. If a lab fails, redo it before moving forward: falling behind on the fundamentals costs double in week 3.

Goal: master the foundation

The most profitable week of the whole program. The mistakes that waste time in an exam almost never come from an advanced feature, but from YAML indentation or a misunderstood rules. Spend half the time writing files from a blank page, without copying an existing example.

Review the .gitlab-ci.yml basics
Redo rules, runners, artifacts/cache
Validate with the first pipeline, images and runners, artifacts and cache, controlling execution and validating before you push

Goal: diagnose fast

This week is not learned by reading: cause the failures yourself. A job that stays pending and a pipeline that never shows up are silent symptoms, and they are the ones that block the most candidates. Above all, learn to tell apart the three cases that always get confused, because they do not share a cause: a skipped pipeline, visible but grey, comes from a [skip ci] in the commit message; grey jobs inside a green pipeline come from their rules:; and a completely empty Pipelines tab, with no message at all, means no workflow: rule matched and no pipeline was created. Time yourself: the goal is to identify the cause in under two minutes, not to fix it elegantly.

Work on the logs, the pending job, and the three cases of a missing pipeline
Redo the incidents with a short timer
Validate with reading a failure, triggering a pipeline and debugging a stuck job

Goal: industrialize

At this stage you know how to write a pipeline that works; the challenge becomes a pipeline that another person can take over. extends and include remove duplication, needs removes needless waiting between stages. The trap of this week is the opposite excess: a template hierarchy that is too deep becomes impossible to debug, stay at two levels at most.

Cover extends, templates, DAG, matrix, workflows
Avoid duplication and implicit dependencies
Validate with speeding up the pipeline, extends and anchors, templates and include, matrices, dynamic pipelines and workflows

If you followed this training

You are generally ready to enter the revision phase if you have:

completed level C1, "write a pipeline and read its failures"
practiced the fundamental labs without help
redone the incidents: pending job, skipped pipeline or one never created, cache and logs
covered the basics of industrialization: templates, extends, DAG

Frequent preparation mistakes

These four mistakes have one thing in common: they give the impression of progress. You tick off chapters, you read documentation, and the perceived level rises faster than the real level. The Impact column describes what happens on exam day or during a production incident; it is the one that should alert you, not the Mistake column, from which we always believe ourselves exempt.

Mistake	Impact	Fix
Learning only the syntax	Fragility in a real incident	Do failure scenarios and post-mortems
Ignoring runners	Blocked or unpredictable jobs	Review tags, executors, capacity and quotas
Skipping the industrialization part	Pipelines that are hard to maintain	Work on templates, includes and DAG
Not practicing against a time limit	Stress and slowness on exam day	Simulate timed sessions

Checklist before the exam

Before registering, make sure you can do the following without hesitation:

read and fix a .gitlab-ci.yml
explain the role of a runner and an executor
choose between variables, cache, artifacts and reports
build then publish an image to the Container Registry, and manage its tags
turn the security scanners on and read their reports
diagnose a stuck job, and tell apart a skipped pipeline, skipped jobs and a pipeline that was never created
factor a pipeline with extends, include and templates
explain when to use needs, parallel and workflows
quickly trace the origin of a failure in the logs

Key takeaways

The exam asks 50 questions in 75 minutes, online and unproctored. It has been redesigned: there is no hands-on project to submit any more.
No per-domain weighting is published: prepare the six objectives with equal weight.
The expected level is Associate: a solid operational foundation, not architect-level expertise.
Success comes from repeated practice on concrete cases, not from rote memorization.
The labs remain your best indicator of real preparation, even though the exam no longer measures them.

Mock exam: 50 questions in 75 minutes

This mock exam mirrors the real format: 50 questions, 75 minutes, and an even split across the six published objectives, since GitLab announces no weighting. Questions are shuffled on every attempt and you can navigate between them, just like in the exam. You get a per-topic score, which tells you where to go back to work.

GitLab Certified CI/CD Associate mock exam

50 questions covering the six published objectives of the certification

50 questions

75 min

75% to pass

How it works

The timer starts when you click Start
Multiple choice, true/false and short answer questions
You can move between questions
Detailed results are shown at the end

Passing a multiple-choice test is not a skill, and the exam itself no longer measures one. The previous version required a project graded by GitLab engineers; this one only asks questions. The 21 labs in this training, close to fourteen hours of practice on a real forge, prepare you for the job while this mock exam prepares you for the test. Both are useful, and they do not measure the same thing.