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:
- No GitLab account: labs run offline with a pipeline simulator
- No runners or servers of your own
- You don't need security tooling experience: scanners are explained
What helps:
- Git basics: commits, branches and merge requests
- Reading and editing YAML files
No formal prerequisites. The courses under "Take first" cover what helps.
Take first:
- Continuous Integration & Continuous Delivery Pipelines — Intermediate
- Advanced Git Internals & Distributed Workflows — Beginner
Take next:
- Certified Argo Project Associate (CAPA) Exam Prep — Intermediate
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
- YAML Configuration (22% of the exam): Core syntax and structure: write and validate YAML syntax inside .gitlab-ci.yml files; Jobs and stages: define sequential and parallel execution blocks, set up custom stages, and organize job execution order; Keywords and conditional logic: use rules to control when jobs run, and recognise the legacy only and except keywords
- Pipeline Development (18% of the exam): Pipeline concepts: understand stage-based pipelines and DAG architectures using the needs keyword for non-linear execution; Artifacts: implement artifacts to pass generated files and binaries between stages; Caching strategies: implement caching to store and reuse dependencies across pipeline runs; Variables: create, scope, and leverage CI/CD environment variables
- CI/CD Fundamentals (18% of the exam): Core principles: define Continuous Integration (CI), Continuous Delivery (CD), and Continuous Deployment concepts; Platform architecture: identify key components of GitLab's integrated platform and how code changes trigger automated workflows
- Troubleshooting and Optimization (14% of the exam): Debugging pipelines: use GitLab Pipeline Graphs, visualization tools, and logs to identify syntax errors, failed jobs, and broken dependencies; Performance tuning: apply pipeline optimization techniques to minimize execution time and resource utilization
- Container and Package Management (12% of the exam): Registries: build, publish, and manage container images using the integrated GitLab Container Registry; Package management: interact with GitLab's package registries to handle build outputs and dependencies within pipelines
- Security Integration (8% of the exam): DevSecOps scans: implement built-in security scanning tools within CI/CD pipelines (SAST, Secret Detection, Dependency Scanning); Vulnerability management: interpret security scan reports and vulnerability insights inside merge requests and project security dashboards
- Runner Configuration (8% of the exam): Runner types: manage and understand instance, group and project runners (formerly shared and specific runners); Executors: configure and work with Docker, Shell, and Kubernetes runner execution environments; Registration and tagging: create runners and register them with runner authentication tokens, manage configuration settings, and use tags to route jobs to appropriate runner environments
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.
- Pro monthly — $29 a month. Every course, lab, handbook, practice exam and certificate
- Pro yearly — $249 a year. Every course, lab, handbook, practice exam and certificate
Course outline
Start Here
- 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.
- 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
- 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.
- 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
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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.
- 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.
- 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
- 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.
- 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
- 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.
- 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
- 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.
- 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
- 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.
- 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.
- 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
- 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.
- 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.