roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for GitLab CI/CD interview questions on how pipelines are defined, run and secured. Covers pipeline rules and includes, runners, image builds, caching, variables and secrets.
73 of 73 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 73 new. 0 cut, outside your plan.
The usual setting is a .gitlab-ci.yml shared on screen and one question: what will the next push do? DevOps, SRE and platform loops ask it inside their main technical conversation; backend loops reach the same file as the delivery half of a system walk-through.
The questions are about control rather than syntax. Why does one push to a branch with an open merge request start two pipelines, and which workflow:rules stop it? Why does a job sit in pending while runners are online? Why is a deploy job on a feature branch missing a variable that the default branch has? Why does a masked token still turn up in a log once it has been encoded, and why does a cache that hit yesterday miss on another runner, where an artifact would not?
Early in a career the interviewer wants to see that you can read a pipeline and predict it: which jobs a rule creates, and how needs lets a job start before its stage would allow. From senior level the conversation turns to ownership: keeping many repositories on one shared pipeline, choosing an executor whose isolation fits code from untrusted merge requests, giving a deploy job short-lived cloud credentials through id_tokens instead of a stored key, and making a required scan something a project cannot quietly delete.
GitLab's own syntax waits until the second module. The first covers what any CI system shares: how a pipeline is put together and what sets it off, and where its jobs physically run and what one job can see of the next. With those in hand, choosing an executor later reads as an isolation decision rather than a line of configuration.
The GitLab CI hub maps those ideas onto the product, in the order its sections depend on each other. The YAML and its rules decide which jobs exist; runners and executors decide, through tags, where they go. With both in place, environments and review apps record what a job deployed and where, includes, templates and components let one pipeline definition serve many projects, and variables and secrets close the hub with what each job is allowed to read.
What a finished job leaves behind is the next concern. Multi-stage builds keep the compiler out of the image a pipeline ships; promotion moves that one build from test to production instead of rebuilding it per environment. GitLab's registries store it, behind the job's own token.
Speed and security come last because both act on everything above them. Caching follows artifacts on purpose, since the classic mistake is a cache doing an artifact's job. Supply-chain security asks who can tamper with the pipeline definition, the runner or the image, and GitLab's security scanners end the plan as the jobs that report those risks inside the merge request.
Where to begin depends on whether you will be asked to use a pipeline or to own one. A backend developer who mostly has to explain how their code ships should put the hours into the foundations and the YAML-and-rules section, capping level at the seniority in the job ad and raising importance to must know. For a DevOps or platform candidate, by topics is the better study order: take the plan as printed and build alongside it: a project runner with the Docker executor, rules that stop the duplicate merge request pipeline, a protected variable that a feature branch cannot read, and a review app that is stopped when its branch is deleted. Candidates arriving from GitHub Actions or Jenkins already know most of the opening module; the place to slow down is rules: a GitLab job whose rules do not match is never added to the pipeline at all, which changes how a missing job is debugged. The plan stops at the deploy job. A controller inside the cluster that pulls the desired state from Git, instead of a job pushing it, belongs to the [GitOps roadmap](/roadmaps/gitops); the [DevOps and SRE roadmap](/roadmaps/devops) sets this pipeline among the rest of the operations work that loop asks about.
Where to begin depends on whether you will be asked to use a pipeline or to own one. A backend developer who mostly has to explain how their code ships should put the hours into the foundations and the YAML-and-rules section, capping level at the seniority in the job ad and raising importance to must know.
For a DevOps or platform candidate, by topics is the better study order: take the plan as printed and build alongside it: a project runner with the Docker executor, rules that stop the duplicate merge request pipeline, a protected variable that a feature branch cannot read, and a review app that is stopped when its branch is deleted. Candidates arriving from GitHub Actions or Jenkins already know most of the opening module; the place to slow down is rules: a GitLab job whose rules do not match is never added to the pipeline at all, which changes how a missing job is debugged.
The plan stops at the deploy job. A controller inside the cluster that pulls the desired state from Git, instead of a job pushing it, belongs to the GitOps roadmap; the DevOps and SRE roadmap sets this pipeline among the rest of the operations work that loop asks about.