100+ Free GitLab CI/CD Associate Practice Questions

Pass your GitLab Certified CI/CD 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 file at the root of a GitLab repository defines the CI/CD pipeline?

.gitlab-ci.yml

gitlab-ci.yaml

.pipeline.yml

.gitlab/pipeline.yaml

to track

2026 Statistics

Key Facts: GitLab CI/CD 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 CI/CD Associate exam has approximately 30 questions in 90 minutes with an 80% passing score. Topic areas: CI/CD Fundamentals (25-30%), GitLab Workflow (30-35%), Continuous Integration (20-25%), and Continuous Deployment (15-20%). Includes multiple-choice, multiple-response, and scenario-based questions plus a practical lab. Tests .gitlab-ci.yml authoring, runners, jobs and stages, variables, artifacts, environments, rules and workflow patterns, includes, components, and deployment patterns. Exam fee is $99 USD. Certification is valid for two years.

Sample GitLab CI/CD Associate Practice Questions

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

1Which file at the root of a GitLab repository defines the CI/CD pipeline?

A..gitlab-ci.yml

B.gitlab-ci.yaml

C..pipeline.yml

D..gitlab/pipeline.yaml

Explanation: GitLab automatically detects `.gitlab-ci.yml` at the repository root and uses it to configure the CI/CD pipeline. The path is configurable per project (Settings → CI/CD → General pipelines → CI/CD configuration file) but the default and convention is `.gitlab-ci.yml`. Exam tip: split large pipelines using `include:` to keep the root file readable.

2Which top-level keyword defines the ordered list of stages in a pipeline?

A.phases

B.stages

C.steps

D.pipelines

Explanation: `stages:` at the top level is an ordered list of stage names. Jobs declare which stage they belong to via `stage: <name>`. Default stages if `stages:` is omitted are `build`, `test`, `deploy`. The other keywords are not valid GitLab CI keys. Exam tip: jobs in the same stage run in parallel; stages run sequentially in declared order.

3Which keyword on a job specifies which Docker image to use as the execution environment?

A.image

B.container

C.runtime

D.engine

Explanation: `image:` specifies the Docker image for the job's runner to pull and execute the job in. Can be set globally (default for all jobs) or per-job. Examples: `image: node:20`, `image: { name: alpine, entrypoint: ['/bin/sh','-c'] }`. The other keywords are not valid. Exam tip: `image: node:20` requires a Docker executor runner; the shell executor ignores this.

4What is a GitLab Runner?

A.An agent process that polls GitLab for jobs and executes them on configured executors

B.A web-based UI for pipelines

C.A Git hook

D.A container registry

Explanation: GitLab Runner is a separate, open-source agent that registers with a GitLab instance and polls for jobs to run. It supports multiple executors: Docker, Kubernetes, Shell, SSH, VirtualBox, Docker Machine. Runners can be shared (whole instance), group-level, or project-level. Exam tip: install the runner on dedicated infrastructure — never on the GitLab server itself.

5Which command registers a GitLab Runner with a GitLab instance using a registration token?

A.gitlab-runner register

B.gitlab-runner connect

C.gitlab-runner install

D.gitlab-runner setup

Explanation: `gitlab-runner register` (interactive or non-interactive with flags) prompts for the GitLab URL, the registration token, executor type, and other options. It writes the runner config to `/etc/gitlab-runner/config.toml`. Modern GitLab uses authentication tokens generated in the UI per-runner instead of legacy registration tokens. Exam tip: scope the runner to a project, group, or instance based on intended use.

6What does the `tags:` keyword on a job do?

A.Restricts the job to runners that have at least all the specified tags

B.Marks the job for git tag triggers

C.Adds Docker image tags

D.Categorizes the job in the UI

Explanation: `tags:` on a job filters which runners can pick it up — only runners with ALL the listed tags qualify. Tags are configured when a runner is registered. Useful to route jobs to specific hardware (e.g., `tags: [gpu]`) or environments (e.g., `tags: [production]`). Exam tip: a runner without the matching tags will simply ignore the job; the job stuck in 'pending' often indicates a tag mismatch.

7Which keyword defines a script to run before the main `script` of a job?

A.before_script

B.pre_script

C.setup

D.init

Explanation: `before_script:` runs before `script:` in the same job. Can be set globally (applied to all jobs) or per-job (overrides global). Useful for installing dependencies or setting up env. The companion `after_script:` runs after `script` regardless of pass/fail. Exam tip: `after_script` runs in a separate shell context — it cannot use variables defined in `script` unless they were exported.

8Which keyword specifies that a job should pass files or directories to subsequent jobs?

A.files

B.artifacts

C.cache

D.outputs

Explanation: `artifacts:` defines paths that are uploaded to GitLab when the job succeeds (or fails, with `when:`). Subsequent jobs in later stages download them automatically (unless `dependencies:` overrides). Artifacts have configurable expiration (`expire_in`). `cache:` is for speeding up jobs by re-using files between runs but is best-effort. Exam tip: use artifacts for build outputs (binaries, reports); use cache for dependency directories like node_modules.

9What is the difference between `artifacts:` and `cache:` in GitLab CI?

A.Artifacts are first-class build outputs uploaded to GitLab and downloadable from the UI; cache is a runner-side optimization for re-using files between runs (best-effort, not guaranteed)

B.There is no difference

C.Cache is for binaries; artifacts are for source code

D.Artifacts only work in the build stage

Explanation: Artifacts are stored on the GitLab server and are guaranteed to be passed between jobs (within expiration). Cache is stored on the runner (or a shared cache backend), is best-effort, and intended to speed up jobs by avoiding re-downloads (e.g., npm/pip dependencies). Use the right tool: artifacts for outputs that must survive; cache for ephemeral speed-up. Exam tip: cache:key allows separate cache buckets per branch or per file hash.

10Which keyword specifies that a job should only run on specific branches or events using the modern syntax?

A.only

B.rules

C.Both — rules is the modern recommended syntax; only is legacy

D.filter

Explanation: `rules:` is the modern, more flexible syntax (introduced in GitLab 12.3) that replaces `only`/`except`. Each rule can use `if` conditions, `changes`, `exists`, plus `when:` and `allow_failure:`. `only`/`except` are still functional but considered legacy. Exam tip: `rules` and `only/except` are mutually exclusive on the same job — use one or the other.

About the GitLab CI/CD Associate Exam

The GitLab Certified CI/CD Associate exam validates working knowledge of GitLab CI/CD pipelines: writing .gitlab-ci.yml, configuring runners, managing variables and artifacts, deploying to environments, and integrating common patterns like rules, includes, parent-child pipelines, and CI/CD components.

Questions

30 scored questions

Time Limit

90 minutes

Passing Score

80%

Exam Fee

$99 (GitLab University (online proctored))

GitLab CI/CD Associate Exam Content Outline

30%

GitLab Workflow

Using GitLab features for collaboration: pipelines view, MR pipelines, environments and deployments view, container/package registry, compliance pipelines, deploy freezes

27%

CI/CD Fundamentals

.gitlab-ci.yml structure, jobs, stages, before_script/after_script, default keyword, image and services, includes (local, project, remote, template, component), extends, YAML anchors

23%

Continuous Integration

Runners (shared/group/project, executors), tags, variables (predefined, project, group, file, dotenv artifacts), artifacts vs cache, parallel:matrix, rules (if/changes/exists), needs DAG

20%

Continuous Deployment

Environments and Review Apps, manual jobs, deployment freezes, resource_group serialization, parent-child and multi-project pipelines, release: keyword, canary deployments

How to Pass the GitLab CI/CD 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 CI/CD Associate Study Tips from Top Performers

1Build a real .gitlab-ci.yml from scratch — practice every keyword: stages, image, services, before_script, script, artifacts, cache, rules, needs, environment, trigger

2Master the rules: syntax: if conditions with $CI_PIPELINE_SOURCE / $CI_COMMIT_BRANCH / $CI_COMMIT_TAG, plus changes: and exists:

3Memorize the workflow:rules pattern that prevents duplicate pipelines on push + MR

4Know the difference between artifacts (guaranteed, server-stored) and cache (best-effort, runner-side optimization)

5Practice configuring a runner: docker executor, tags, concurrent setting, registration with token

6Understand needs: as a DAG that can skip stages — a job can need a job in the same stage or earlier (never later)

7Drill GitLab predefined variables: $CI_COMMIT_SHA, $CI_COMMIT_REF_SLUG, $CI_PIPELINE_SOURCE, $CI_REGISTRY_IMAGE, $CI_JOB_TOKEN

Frequently Asked Questions

What is the GitLab Certified CI/CD Associate exam?

The GitLab Certified CI/CD Associate is a vendor certification from GitLab University validating the practical skills needed to build, run, and maintain CI/CD pipelines on GitLab. It tests .gitlab-ci.yml authoring, runners, variables, artifacts, environments, rules, includes, components, and common deployment patterns.

How many questions are on the exam?

The exam has approximately 30 questions over 90 minutes, mixing multiple-choice, multiple-response, and scenario-based items. It also includes a practical lab where you build or modify a real .gitlab-ci.yml in a sample project. The passing score is 80%.

How much does the GitLab CI/CD Associate exam cost?

The exam costs approximately $99 USD. The fee covers a single attempt; retakes require an additional fee. GitLab University periodically offers promotional pricing or training bundles.

What are the largest topic areas on the exam?

Per GitLab's published outline: GitLab Workflow ~30-35%, CI/CD Fundamentals ~25-30%, Continuous Integration ~20-25%, and Continuous Deployment ~15-20%. Practical .gitlab-ci.yml fluency and operating GitLab Runners are central to all areas.

Does the GitLab CI/CD 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 CI/CD Associate exam?

Plan for 25-50 hours of study spread over 3-5 weeks. Build a real GitLab project, register a runner, and write pipelines covering jobs, stages, variables, artifacts, environments, and rules. Use the free GitLab University CI/CD course as your primary guide. Take 100+ practice questions and aim for 90%+ before scheduling.

Should I take the Git Associate first?

GitLab does not require the Git Associate as a prerequisite, but it is highly recommended — the CI/CD Associate assumes you are already comfortable with Git CLI, branching, MRs, and basic GitLab navigation. Many candidates complete the Git Associate first to solidify those foundations.