CI/CD

How teams organize work: waterfall vs iterative Agile, Kanban boards, and where DevOps fits in.

What pain CI/CD solves: manual deploys, "it works on my machine", integration hell. What the letters stand for.

What runs on every push, fail fast, a green main, and why you need to merge often.

Two things CD can mean: continuous delivery (release by a button) and continuous deployment (straight to prod, automatically).

Stages, jobs, runners, artifacts, cache, variables and secrets, environments: the shared vocabulary of CI/CD.

GitLab CI, GitHub Actions, Jenkins, CircleCI, Argo CD: who's who and how they differ.

We build a simple .gitlab-ci.yml from scratch: hello world, stages, artifacts, a SHA tag.

Seven questions on CI, Delivery vs Deployment, pipeline anatomy, and tools.

We set up the repository where you'll run pipelines: clone the course project, switch origin to your own, and make the first push.

We write a minimal .gitlab-ci.yml, push it, and watch GitLab spin up a container and run the command on its own.

We split the pipeline into build and test, see how stages run in order, and why a failed build cancels everything after it.

Why a file from build isn't visible in test, and how artifacts fix that. We build a public folder and pick it up in the next stage.

We add a deploy stage and a pages job. GitLab publishes the public folder, and the site opens at a link without a single manual step.

Built-in CI_ variables, your own values in .gitlab-ci.yml, and masked secrets in project settings. Plus a colon that breaks YAML.

We swap echo for a real bundler: a node image, npm ci, esbuild, and dist in the artifacts. We dig into where a job's environment comes from.

We speed up dependency installs between runs. A key by the lock file's hash, and why caching node_modules for npm ci makes no sense.

We split deploys by branch, put a manual gate in front of prod, and work out why rules replaced only/except.

A green job that lies, a password in the log, latest instead of a version, a monolithic job, and a dead only. Each one shown on an example.

What a well-built CI/CD pipeline looks like: stage order, fail-fast, fast feedback, and where deploy starts.

How to roll out a new version without downtime and with a way to roll back: rolling, blue-green, and canary, with their upsides and risks.

Manual approvals, protected environments, parallel fan-out/fan-in branches, and conditional job runs.

How a cache differs from an artifact, how to cache dependencies and image layers, and how to pass results between jobs.

What security checks get built into CI, how they differ, and why scanning is a process, not a single tool.