GitLab CI/CD Associate course and practice exam: GitLab Certified CI/CD Associate

This GitLab CI/CD Associate course has 25 video lessons and 29 graded labs, and its GitLab CI/CD Associate practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.

Pipelines, runners, security scanning and troubleshooting in GitLab

Prepares you for the GitLab CI/CD Associate exam: pipeline configuration in YAML, runners, container and package registries, security scanning, and troubleshooting.

Intermediate · 2 hours · 25 lessons · 46 labs

GitLab CI/CD Associate exam guide

The GitLab CI/CD Associate exam (GitLab Certified CI/CD Associate, by GitLab): 75 minutes; questions: 50; pass mark: 75%.

  • Format: 50 questions, multiple choice or multiple response; unanswered questions are scored as incorrect, no penalty for guessing
  • Duration: 75 minutes
  • Questions: 50
  • Pass mark: 75%
  • Valid for: Does not expire; GitLab may require recertification after a major product version
  • Delivery: Online, unproctored; 2 attempts within the 14 days of access per registration; repurchase allowed 14 days after the first purchase. The exam agreement bans notes, reference materials and AI assistance
  • Prerequisites: None formally required

Exam domains and weights

  • YAML Configuration: 22%
  • Pipeline Development: 18%
  • CI/CD Fundamentals: 18%
  • Troubleshooting and Optimization: 14%
  • Container and Package Management: 12%
  • Security Integration: 8%
  • Runner Configuration: 8%

A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

10 GitLab CI/CD Associate sample questions with answers: free to read, no account needed.

Common questions

How long is the GitLab CI/CD Associate exam?

The GitLab CI/CD Associate exam lasts 75 minutes.

How many questions are on the GitLab CI/CD Associate exam?

50.

What is the GitLab CI/CD Associate passing score?

The pass mark is 75%.

Is there a free GitLab CI/CD Associate practice test?

Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

Source: GitLab Certified CI/CD Associate exam page (GitLab University) (GitLab), checked 2026-10-03.

Who it is for

Intermediate level.

For engineers who build or maintain GitLab pipelines and want to pass the GitLab CI/CD Associate exam, from the CI file and runners to registries and security scans.

What you don't need yet:

What helps:

No formal prerequisites. The courses under "Take first" cover what helps.

Take first:

Take next:

Learning paths:

Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.

What this exam proves, and what it doesn't

GitLab CI/CD is a multiple-choice and multiple-response exam: passing shows you know how GitLab pipelines work. It doesn't test hands-on skill or replace running real pipelines; our graded labs use a pipeline simulator.

Exam objectives this course teaches

GitLab Certified CI/CD Associate

Labs

46 labs, 29 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.

What is free

Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.

Course outline

Start Here

  1. The Merge Request That Deployed To Production (2 labs): You can read a job's rules the way GitLab does, in order with the first match winning, explain why a rule that checks only changed files lets a merge request deploy, and fix it with one rule that checks both conditions.
  2. How The Exam Works: Fifty Questions, No Notes (1 lab): You can plan your attempt from GitLab's published facts: seventy five minutes for fifty questions, the seventy five percent pass mark, the domain weights, two attempts in fourteen days, and a code of conduct that rules out notes, documentation and AI help.

CI/CD Fundamentals

  1. Continuous Integration, Delivery And Deployment: One Keyword Apart (2 labs): You can define continuous integration, continuous delivery and continuous deployment, show which one a GitLab pipeline implements from its deploy job, and explain why a pipeline can pass while a manual production job still waits.
  2. From Push To Runner: How GitLab Starts A Pipeline (2 labs): You can follow a change through GitLab's integrated platform: which event creates which pipeline type, what CI_PIPELINE_SOURCE says for each, how runners fetch jobs, and where results come back in the merge request.

YAML Configuration

  1. Anatomy Of .gitlab-ci.yml, And Three Ways To Check It (3 labs): You can tell global keywords from jobs in .gitlab-ci.yml, reuse configuration with anchors, merge keys and !reference, and catch YAML and keyword mistakes with yamllint, GitLab's schema and CI Lint before a pipeline fails.
  2. Jobs And Stages: Who Waits, Who Runs, Who Gets Skipped (2 labs): You can predict the order of a stage-based pipeline, what happens to later stages when a job fails, and how when, allow_failure, parallel and the .pre and .post stages change it.
  3. Rules, Workflow Rules And The Legacy only And except (2 labs): You can write job rules with if, changes, exists and when, use workflow:rules to get one pipeline per push without losing jobs, and read legacy only and except configuration.
  4. Reuse With extends And include, And What Survives The Merge (2 labs): You can share configuration across jobs and projects with extends and the four main include types, and predict the merged job: hashes merge key by key, while lists such as script and rules are replaced whole.

Pipeline Development

  1. Stages Versus Needs: Building The Pipeline As A Graph (2 labs): You can turn a stage-ordered pipeline into a directed acyclic graph with needs, work out when each job can start, and use needs: [], needs:optional and needs on parallel jobs correctly.
  2. Parent, Child And Multi-Project Pipelines (2 labs): You can split a pipeline into child pipelines with trigger:include, make the parent wait for and mirror a child with strategy: mirror, generate a child configuration in a job, and tell parent-child from multi-project pipelines.
  3. Artifacts: Which Files Reach Which Jobs (2 labs): You can publish job output with artifacts:paths, expire_in, when and reports, pass variables with dotenv reports, and predict which artifacts a job downloads with stage order, dependencies and needs.
  4. Caching: Dependencies That Survive Between Pipelines (2 labs): You can configure cache:key (a fixed key, a per-branch key, or key:files with a prefix), choose pull, push or pull-push, explain the protected and non_protected suffixes and fallback keys, and choose between a cache and an artifact.
  5. CI/CD Variables: Where Values Come From, And Which One Wins (2 labs): You can define variables in YAML and in project, group and instance settings, use protected, masked, file-type and environment-scoped variables, and predict which value a job receives from GitLab's order of precedence.
  6. Environments, Review Apps And Deployments (2 labs): You can declare environments with name, url, deployment_tier, on_stop, action: stop and auto_stop_in, build dynamic review apps from CI_COMMIT_REF_SLUG, and protect production with protected environments, approvals and resource groups.

Container And Package Management

  1. The Container Registry: Build, Tag, Push, Clean Up (3 labs): You can build and push images to a project's container registry with the predefined CI_REGISTRY variables and the job token, choose a tag strategy that always produces valid tags, pick Docker-in-Docker or a daemonless builder, and keep the registry small with cleanup policies.
  2. Package Registries: Publishing With The Job Token (2 labs): You can publish and consume generic, PyPI, npm and Maven packages from CI with CI_JOB_TOKEN and the project's API URL, limit publishing to tag pipelines, and explain duplicate versions and cross-project job token access.

Security Integration

  1. Adding GitLab's Security Scanners To A Pipeline (2 labs): You can add SAST, secret detection, dependency scanning and container scanning with GitLab's templates, predict which scanner jobs appear for a repository and a tier, give them the test stage they need, and configure them with variables.
  2. Reading Security Results: The Merge Request And The Vulnerability Report (2 labs): You can read the merge request security scan report (added and fixed findings), tell findings from vulnerabilities, set a vulnerability's status with the right dismissal reason, and predict what the next default-branch scan does to each status.

Runner Configuration

  1. Runner Types And Executors: Who Runs The Job, And Where (1 lab): You can choose between instance, group and project runners, explain what each executor isolates (Docker, Kubernetes, Docker Autoscaler, Instance, Shell), and read a runner host's config.toml for its executors and concurrency.
  2. Registering Runners And Routing Jobs With Tags (2 labs): You can create a runner in GitLab and register it with its glrt- authentication token, set tags, run-untagged, protected and paused, and predict which runner can pick a job, or why it is stuck.

Troubleshooting And Optimization

  1. Debugging Pipelines: The Graph, The Errors, The Logs (1 lab): You can tell a pipeline that was never created from a job that failed, read GitLab's configuration errors and fix their causes, use the pipeline graph and job logs to find a failure, and use CI_DEBUG_TRACE safely.
  2. Faster Pipelines: Minutes You Can Win Back (2 labs): You can shorten a pipeline and its job minutes with needs, parallel, rules:changes, interruptible with auto-cancel, caching, shallow clones and smaller images, and measure the result as both wall-clock time and job minutes.
  3. Pipeline Clinic: Five Tickets, Five Fixes (1 lab): You can diagnose a broken pipeline with a fixed sequence of questions (created, which jobs, in what order, with which files and variables, with what status) and fix five common real-world faults in rules, needs, artifacts, trigger jobs and manual jobs.

Mock And Review

  1. Recall Sprint: Knowing It Cold, With No Docs And No AI (1 lab): You can prepare for a closed-book exam with retrieval practice, spaced Leitner review and interleaved domains, recall the keywords, defaults and limits the exam tests, and answer from memory before reading the options.
  2. Final Mock And Review: One Question Short (1 lab): You can take a timed mock under exam rules, turn its results into a revision plan by domain, review each miss down to the rule behind it, and walk into the exam with a plan for both attempts.

Certification courses