Appearance
CI/CD Fundamentals
170. What is DevOps, and how does it relate to CI/CD?
The short answer
DevOps is a way of working in which the people who build software and the people who run it share responsibility for it, from the first line of code to how it behaves in production. It relies on automation, small frequent changes, fast feedback and measuring results. CI/CD is the core technical practice that makes this possible: an automated path that takes every change from a commit to production quickly and safely.
The problem DevOps solved. For decades, companies split the work in two. Developers wrote features and wanted to ship them fast. A separate operations team ran the servers and wanted nothing to change, because change caused outages. Developers threw releases "over the wall" every few months. Each release was huge, risky and painful, and when something broke, each side blamed the other.
DevOps joins the two sides. The name, from "development" and "operations", came from a 2009 conference called DevOpsDays. The core ideas are often remembered with the letters CALMS:
- Culture. Shared ownership. The team that builds a service also cares how it runs. "You build it, you run it."
- Automation. Builds, checks, deployments and infrastructure are done by machines, the same way every time.
- Lean. Small batches of work, flowing steadily, with waste removed.
- Measurement. Decisions based on data, such as how often you deploy and how often deployments fail (question 294).
- Sharing. Knowledge, tools and lessons from incidents are shared openly.
Where CI/CD fits. You cannot ship small changes many times a day if every release takes a week of manual work. CI/CD is the automation that makes frequent, low-risk releases possible:
- Continuous integration keeps everyone's changes merged and checked all the time (question 171).
- Continuous delivery keeps every checked change ready to release (question 172).
- Continuous deployment releases it automatically (question 173).
A common misunderstanding: DevOps is not a tool, and not only a job title. Buying a CI server does not make a company "do DevOps". The tools support the way of working. Without the shared ownership, they just automate the old wall.
171. What is Continuous Integration?
The short answer
Continuous integration is the practice of every developer merging small changes into the shared main branch often, at least daily, with each merge automatically built and checked. When a check fails, fixing it becomes the team's top priority. The goal is to find conflicts and mistakes while they are small and fresh, instead of in a painful merge weeks later.
The problem it solves: "integration hell". Imagine five developers who each work alone on a branch for a month. On merge day, their changes collide: two people renamed the same function, one person's change breaks another's assumptions. Nobody remembers why they made each change. Merging takes days, and bugs slip through.
The fix is to integrate continuously:
- Small changes. A pull request is a few hours or a day of work, not a month.
- Merge often. Everyone merges into the main branch at least once a day.
- Automatic checks on every change. A CI system builds the code and runs fast checks, such as formatting, linting, type checks and unit checks, on every pull request and every merge.
- A red build is fixed first. If main is broken, nobody piles more changes on top. Fix it, or revert the change that broke it, within minutes.
- Fast feedback. Checks finish in minutes, so developers stay focused on the change.
A short history. The term appeared in the early 1990s, and became a core practice of Extreme Programming, an agile method, later that decade. Martin Fowler's widely read article on it popularised the idea.
Why it works: problems found an hour after they are written cost minutes to fix. The same problems found a month later can cost days.
172. What is Continuous Delivery?
The short answer
Continuous delivery means every change that passes the automated pipeline is ready to go to production at any moment. The release itself is one button press, a business decision about when, not a technical project about how. Getting there requires automating everything between a merge and production: building, checking, deploying to test environments and proving the change works.
The term was made popular by the 2010 book Continuous Delivery by Jez Humble and David Farley.
What "always releasable" requires:
- Continuous integration underneath: main is always green.
- One artifact, built once, and promoted through environments (question 219).
- Automated deployment to every environment, including production, using the same method each time.
- Automated checks in production-like environments, so passing them really means "safe to release".
- Configuration and infrastructure as code, so environments can be recreated exactly.
What changes for the business. A release stops being a big event. If marketing wants a feature live on Tuesday, someone presses the button on Tuesday. If a security fix lands at 3 p.m., it can be live at 3:30.
What continuous delivery does not require: deploying every change automatically. A person may still approve production releases. That approval is what separates it from continuous deployment (question 174).
173. What is Continuous Deployment?
The short answer
Continuous deployment goes one step further than continuous delivery: every change that passes all the automated checks is released to production automatically, with no human approval step. The pipeline itself decides. It demands very strong automated checks, safe rollout methods such as canary releases, and fast, automatic rollback.
What it looks like: a developer merges a change at 10:02. By 10:20 it has been built, checked, deployed to staging, checked again, rolled out to 5% of production traffic, compared with the old version, and rolled out to everyone. Nobody pressed a button.
What it requires, beyond continuous delivery:
- Checks you trust completely. Without a human gate, the checks are the only gate.
- Safe rollouts. Canary or progressive releases that expose a new version to a few users first (question 282).
- Automatic rollback when error rate or latency gets worse (question 283).
- Feature flags to separate deploying code from turning features on (question 285).
- Good monitoring, so problems are noticed in minutes.
Who does it: companies that deploy many times a day, often hundreds or thousands of times across many services. Who often does not: regulated industries that require a named person to approve each production change, and teams whose checks are not yet strong enough.
174. How do Continuous Delivery and Continuous Deployment differ?
The short answer
Only in the last step. In both, every change is automatically built, checked and made ready for production. In continuous delivery, a person decides when it goes to production. In continuous deployment, it goes to production automatically as soon as it passes. Delivery means "could release at any time". Deployment means "does release every time".
| Continuous delivery | Continuous deployment | |
|---|---|---|
| Every change is releasable | Yes | Yes |
| Production release | A person decides when | Automatic |
| Release frequency | When the business wants | Every passing change |
| Main risk control | Checks plus human judgment | Checks, canaries, automatic rollback |
Which is "better"? Neither, in general. Continuous deployment removes waiting and keeps changes tiny, which lowers risk per release. Continuous delivery keeps a human checkpoint, which some regulations and some risk-averse businesses require. Many teams use both: continuous deployment for most services, and a manual gate for a few critical ones, such as payments.
175. Why is a pipeline alone not sufficient to establish good continuous integration practices?
The short answer
Because continuous integration is something people do, not something a server does. A pipeline that checks long-lived feature branches merged once a month is not continuous integration, just automated checking. The practice needs everyone merging small changes to main at least daily, fast and trustworthy checks, and a team habit of fixing a broken main branch immediately. Without those habits, the pipeline gives a false sense of safety.
Signs of a pipeline without continuous integration:
- Long-lived branches. Developers keep work on branches for weeks. The pipeline runs on each branch, but the branches are not integrated with each other until the end, so integration problems still pile up.
- Red is normal. Main is broken half the time, and people merge anyway, because "it's probably the flaky check".
- Slow feedback. The pipeline takes an hour, so developers batch up changes and push rarely, which makes each change bigger and riskier.
- Checks nobody trusts. Flaky checks are re-run until they pass. Real failures hide among the false ones (question 210).
- Weak checks. The pipeline compiles the code and little else, so green tells you almost nothing.
A quick self-test, based on one Jez Humble often uses:
- Does every developer merge into the main branch at least once a day?
- Does every merge trigger automated building and checking?
- When the build breaks, is it usually fixed within about ten minutes?
If any answer is "no", you have a pipeline, but not yet continuous integration.
What turns the tool into the practice: small pull requests and trunk-based development (question 188). Feature flags, so unfinished work can be merged safely (question 285). Checks that run in minutes. And a team agreement that a broken main branch stops everything until it is fixed or reverted.
176. What are the typical stages of a software delivery pipeline, from commit to production?
The short answer
It starts with the source and the build. Fast checks follow, such as linting and unit checks. The result is packaged into an artifact, such as a container image, and scanned for security problems. It is deployed to a test environment for slower integration checks, then to staging. A gate comes next, then a careful production rollout. Finally, you verify that it is healthy in production. Fast, cheap stages come first so most problems are caught within minutes.
- Checkout. Fetch the exact commit being built.
- Build. Compile, bundle, install dependencies from the lock file.
- Fast checks. Formatting, linting, type checks and unit checks. Seconds to a few minutes.
- Package. Build the container image once, tag it with the commit ID, and push it. Record the digest.
- Scan. Static analysis of the code, dependency vulnerabilities, secrets and the image itself (question 215).
- Test environment. Deploy the image, run integration and end-to-end checks against real dependencies.
- Staging. A production-like environment for final checks, often with production-shaped data.
- Gate. Policy checks, such as "signed, scanned, no critical findings", and an approval if required.
- Production. Roll out gradually: a canary or a rolling update (question 280).
- Verify. Watch error rates and latency. Roll back automatically if they get worse.
The ordering principle: each stage should be faster and cheaper than the ones after it, so that most failures are found early, when they cost the least (question 201).
177. What is the difference between a build pipeline and a release or deployment pipeline?
The short answer
A build pipeline turns source code into a verified artifact: it checks out the code, builds it, checks it and publishes the result, such as an image. A release or deployment pipeline takes an already-built artifact and moves it through environments to production, with gates, approvals, rollout steps and rollback. Keeping them separate means you can redeploy or roll back without rebuilding, and production credentials never sit in the build.
| Build pipeline (CI) | Release or deployment pipeline (CD) | |
|---|---|---|
| Starts from | A commit or pull request | A versioned artifact |
| Produces | An image or package | A running version in an environment |
| Runs on | Every change | Each promotion to an environment |
| Needs | Source access, registry push | Environment credentials, approvals |
| Typical length | Minutes | Minutes to hours, with gates |
Why separate them:
- Rollback without rebuilding. Rolling back means running the release pipeline for the previous artifact. No build, no surprises (question 134).
- Least privilege. The build pipeline runs on every pull request, including code nobody has reviewed yet. It must never hold production credentials. Only the release pipeline, which deploys already-reviewed artifacts, needs them (question 271).
- Different speeds. The build pipeline should be fast. The release pipeline may wait hours for a canary to prove itself.
- Clear audit trails. "Which artifact went where, when, approved by whom" lives in the release pipeline's history.
In GitOps setups, the "release pipeline" is partly the GitOps tool itself: CI writes the new digest into a configuration repository, and the GitOps tool deploys it (question 507).
178. What is the difference between an artifact and a deployment environment?
The short answer
An artifact is the thing you deploy: a built, versioned, unchangeable package, such as a container image or a JAR file. An environment is a place you deploy it to, such as development, staging or production, made of infrastructure, configuration, secrets and data. The same artifact runs in every environment, and each environment gives it different settings.
The artifact is the "what":
- Built once, from one commit.
- Immutable: once published, its contents never change.
- Identified by a version and a digest.
- Stored in an artifact repository or registry (question 216).
- Examples:
checkout-api@sha256:41c9...,payments-lib-2.3.1.jar, a Python wheel.
The environment is the "where":
- Infrastructure: a cluster, a network, a database server.
- Configuration: database addresses, feature flags, log levels.
- Secrets: that environment's own passwords and keys.
- Data: test data in staging, real customer data in production.
- Rules: who may deploy, and which approvals are needed.
Keeping them separate is the whole point. If the database address were baked into the image, you would need a different image per environment, and the image you tested would not be the image you ship. So the artifact stays the same, and each environment injects its own configuration at deploy time (question 226).
179. What are the differences between source code, a build artifact, a container image, and a running workload?
The short answer
Source code is what people write and keep in Git. A build artifact is what the build produces from it, such as compiled files or a JAR. A container image packages that artifact together with its runtime and system libraries into a standard, runnable package. A running workload is that image actually running somewhere, with its configuration, its resources and its state. Each step turns the previous one into something closer to production.
| Source code | Build artifact | Container image | Running workload | |
|---|---|---|---|---|
| Example | src/server.ts | dist/server.js | checkout-api@sha256:41c9... | 3 pods in shop-prod |
| Where it lives | Git | CI, then an artifact store | A registry | A cluster |
| Changes? | Constantly | Never, once built | Never | Its state changes all the time |
| Contains runtime? | No | No | Yes | Yes, plus configuration |
Why the distinction matters in practice. When someone says "the bug is in version 1.4", you need to know which of these they mean. Is it the commit, the image, or what is actually running? A common incident is a pipeline that says it deployed version 1.4 while the running workload is still on 1.3 (question 299). Being able to trace a running pod back to its image digest, and the image back to its commit, is what makes those incidents quick to solve (question 196).
180. What is pipeline-as-code, and why should pipeline definitions be version controlled?
The short answer
Pipeline-as-code means the pipeline is described in a text file that lives in the repository, such as a Jenkinsfile, a GitHub Actions workflow or a .gitlab-ci.yml, instead of being configured by clicking in a web interface. Keeping it in Git means every change to the pipeline is reviewed, recorded and reversible, the pipeline evolves together with the code it builds, and anyone can rebuild it exactly.
A GitHub Actions example, kept at .github/workflows/ci.yml:
yaml
name: ci
on:
pull_request:
push:
branches: [main]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with: { node-version: 20, cache: npm }
- run: npm ci
- run: npm run lint
- run: npm run buildWhy keeping it in Git matters:
- Review. A change to the pipeline is a pull request. Someone checks it before it can, say, skip a security scan.
- History. You can see who changed the pipeline, when, and why. When builds start failing, you can find the change that caused it.
- Revert. A bad pipeline change can be undone like any other commit.
- It moves with the code. A branch that needs a new build step carries its own pipeline change. Old releases can still be rebuilt with the pipeline they used at the time.
- No hidden configuration. Pipelines set up by clicking drift apart, and nobody can tell what they do. A file in the repository is the complete truth.
- Reuse. Shared templates and reusable workflows can be imported, versioned like libraries (question 259).
The one thing to be careful about: whoever can change the pipeline file can change what the pipeline does with its credentials. That is why pipeline files need the same branch protection and review as code, and why untrusted pull requests must not run with secrets (question 250).
181. What is a CI runner, agent, worker, or executor?
The short answer
They are different platforms' names for the same idea: a machine, or a process on a machine, that picks up pipeline jobs and runs their steps. A central CI server decides which job runs where, usually by matching labels such as "linux" or "gpu", and the runner does the work and reports results back. GitHub and GitLab say runner, Jenkins and Azure Pipelines say agent, and some tools say worker or executor.
Every CI system splits into two parts:
- The coordinator, which holds the pipeline definitions, decides what to run and shows the results. In Jenkins this is the controller. In GitHub Actions and GitLab it is the hosted service, or your own GitLab server.
- The runners, which run the jobs. A runner asks the coordinator for work, runs each step, streams logs back, and reports success or failure.
| Platform | Name | Notes |
|---|---|---|
| GitHub Actions | Runner | Hosted by GitHub or self-hosted |
| GitLab CI | Runner | Uses an executor: shell, Docker or Kubernetes |
| Jenkins | Agent | Each agent has executors: parallel job slots |
| Azure Pipelines | Agent | Grouped into agent pools |
Labels decide where a job runs. A job asks for, say, runs-on: [self-hosted, linux, arm64], and only runners carrying all those labels pick it up. That is how you send GPU work to GPU machines and ARM builds to ARM machines.
Two words worth separating: in Jenkins, an agent is a machine and an executor is one slot on it, so an agent with four executors can run four jobs at once. In GitLab, an executor is how the runner runs the job: directly in a shell, inside a Docker container, or as a Kubernetes pod.
182. What is the difference between a self-hosted runner and a managed runner?
The short answer
A managed runner is a machine the CI provider runs for you: usually a fresh virtual machine for every job, with no maintenance on your side, paid by the minute. A self-hosted runner is a machine you run yourself, in your own network or cloud. It can reach private systems, use special hardware and keep caches warm, and it is cheaper at large scale, but you must patch, secure and scale it.
| Managed runner | Self-hosted runner | |
|---|---|---|
| Who maintains it | The CI provider | You |
| Fresh machine per job | Usually yes | Only if you build it that way |
| Reach private networks | Not directly | Yes |
| Special hardware | Limited choices | Anything: GPUs, ARM, large memory |
| Caching between jobs | External cache only | Local disk can stay warm |
| Cost | Per minute | Your machines, cheaper at high volume |
| Security burden | The provider's | Yours |
When managed is right: most teams, most of the time. No servers to keep patched, and every job starts clean.
When self-hosted is right:
- Private access. Deploying to a database or cluster that has no public address.
- Special hardware. GPUs for machine learning, ARM machines for native builds (question 83).
- Speed. Warm caches and big machines can make builds much faster.
- Cost at scale. Thousands of build hours a month can be cheaper on your own machines.
- Rules. Some companies require builds to stay inside their own network.
The big risk with self-hosted runners: a runner runs whatever code the pipeline gives it. If a public repository's pull requests from strangers can run on your self-hosted runner, a stranger's code runs inside your network. Question 272 covers how to harden them, and the safest pattern is a fresh, short-lived runner for every job (question 183).
183. What are the advantages and disadvantages of ephemeral CI runners?
The short answer
An ephemeral runner is created for one job and destroyed right after it. Every job starts on a clean machine, so nothing leaks between jobs: no leftover files, no stolen credentials, no attacker hiding on the machine for the next build. Jobs are also more reproducible. The costs are slower jobs, because caches start empty and the machine must start up first, and the work of running the system that creates and destroys runners.
Advantages:
- Security. If a malicious job takes over the runner, it cannot leave anything behind for the next job, because the machine is destroyed. This is the main reason to use them.
- No leftover state. A previous job's files, dependencies or environment variables cannot change the result of the next job. "It works because the last build left that file behind" never happens.
- Reproducibility. Every job starts from the same image, so results are consistent.
- Easy scaling. Create as many as the queue needs, then destroy them. In Kubernetes, tools such as the GitHub Actions Runner Controller create a runner pod per job.
Disadvantages:
- Cold caches. Dependencies and build layers must be downloaded every time, unless you add an external cache (question 77).
- Start-up time. A new virtual machine or pod takes seconds to minutes to become ready.
- More moving parts. Something must create, register and delete runners reliably, and that system needs looking after too.
The common compromise: ephemeral runners, plus remote caches for dependencies and image layers, plus a pool of a few pre-started runners waiting, so jobs do not wait for a machine to boot.
184. What starts a pipeline: a push, pull request, merge, schedule, tag, manual action, or another pipeline?
The short answer
Any of them, depending on how the pipeline is configured. Pushes and pull requests run the normal checks. A merge to main, which is just a push to main, usually builds and publishes. Tags usually start a release. Schedules run nightly or weekly jobs such as security rescans. Manual triggers start deployments or maintenance on demand. And one pipeline can trigger another, for example when a shared library is published.
| Trigger | Typical use | GitHub Actions example |
|---|---|---|
| Push to a branch | Build and check | on: push |
| Pull request opened or updated | Checks before merge | on: pull_request |
| Push to main, after merge | Build, publish, deploy to dev | on: push: branches: [main] |
| Tag | Release a version | on: push: tags: ['v*'] |
| Schedule | Nightly scans, cleanup | on: schedule: - cron: '0 3 * * *' |
| Manual | Deploy, rerun, maintenance | on: workflow_dispatch |
| Another pipeline | Chain workflows | on: workflow_run |
| External event | A webhook from another system | on: repository_dispatch |
A few details worth knowing:
- A "merge" is not a separate event. Merging a pull request creates a commit on main, which is a push to main.
- Pull request pipelines usually check the merged result. GitHub, for example, builds a temporary merge of the pull request into its target, so you check what main would look like after merging.
- Schedules use cron syntax, five fields for minute, hour, day of month, month and day of week.
0 3 * * *means 03:00 every day, in UTC on GitHub. - Filters narrow triggers. Branch filters, tag patterns and path filters stop pipelines from running when they are not needed (question 245).
185. What is the difference between a pull request check and a post-merge pipeline?
The short answer
A pull request check runs before merging, on a proposed change that nobody has approved yet. It answers "is this safe to merge?", so it must be fast, report its result on the pull request, and never touch production or hold deployment secrets. A post-merge pipeline runs after the change is on main, on reviewed code. It builds the official artifact, publishes it, and starts its journey through the environments.
| Pull request check | Post-merge pipeline | |
|---|---|---|
| Runs on | Unreviewed, proposed code | Reviewed code on main |
| Question answered | Safe to merge? | Build, publish and release it |
| Speed target | Minutes | Can be longer |
| Publishes artifacts | No, or only temporary ones | Yes, the official image |
| Deploys | Preview environments at most | Dev, staging, production |
| Secrets | None, or read-only | Deployment credentials |
Why both are needed:
- Trust. Pull request code might be broken or even malicious, especially from forks. It runs with minimal permissions. Only after review does code reach the pipeline that has deployment power.
- Freshness. A pull request may have passed its checks yesterday. Since then, other changes merged into main. The post-merge pipeline checks the real combination. A merge queue solves this more strictly: it tests each pull request against the latest main, including everything queued ahead of it, before merging.
- One official artifact. Building the release image only after merge guarantees it comes from reviewed code on main (question 276).
186. What are protected branches, required status checks, and mandatory code reviews?
The short answer
A protected branch, such as main, has rules the platform enforces. Nobody may push to it directly or rewrite its history. Changes arrive only through pull requests. Required status checks are pipeline jobs that must pass before a pull request can merge. Mandatory code reviews require one or more approvals from other people, often from the code's owners. Together they guarantee that nothing reaches main without passing checks and a second pair of eyes.
Typical protection rules for main:
- No direct pushes. Every change goes through a pull request.
- No force pushes and no deletion, so history cannot be rewritten or erased.
- Required status checks. Named pipeline jobs, such as
build,lintandsecurity-scan, must pass. Often the branch must also be up to date with main before merging. - Required reviews. For example, one approval, or two for sensitive folders.
- Code owners. A
CODEOWNERSfile names who owns which paths. Changes todeploy/might need the platform team's approval. - Dismiss stale approvals. If new commits are pushed after an approval, the approval no longer counts.
- Rules apply to administrators too, so nobody can quietly bypass them.
- Optional extras: signed commits, a linear history without merge commits, and a merge queue.
A CODEOWNERS example:
text
# .github/CODEOWNERS
* @shop/developers
/deploy/ @shop/platform
/src/payments/ @shop/payments-leadsThe last matching line wins. A change under /src/payments/ needs approval from the payments leads.
Why they matter for delivery: the pipeline's post-merge job deploys whatever is on main. Branch protection is what makes "whatever is on main" safe to deploy automatically (question 192).
478. What does "shift left" mean in DevOps?
The short answer
"Shift left" means moving checks earlier in the life of a change, towards the developer, where problems are cheapest to fix. Picture the process as a line running left to right, from writing code to production. Checks such as security scanning, linting and configuration validation move left. They run in the editor, in pre-commit hooks and in pull request checks. They no longer happen just before release, or after an incident.
Why it pays off. A bug found while typing costs seconds. The same bug found in a pull request costs minutes. Found in staging, it costs hours of investigation. Found in production, it can cost customers, money and a long night.
What shifting left looks like:
| Check | Late, on the right | Early, on the left |
|---|---|---|
| Security flaws in code | Penetration test before launch | Static analysis in the editor and the pull request |
| Leaked secrets | Found after a breach | Secret scanning in a pre-commit hook |
| Bad Kubernetes configuration | Rejected at deploy time | Policy check in the pull request |
| Vulnerable libraries | Found by an audit | Dependency scan on every change |
Doing it well. Shifting left fails if it just dumps more work on developers. The checks must be fast, accurate and easy to act on. A scanner that produces fifty false alarms per pull request gets ignored. Platform teams make shifting left work by providing good tools with good defaults.
The other half: shift right. Some problems only show up with real traffic. So mature teams also "shift right": canary releases, feature flags, production monitoring and deliberately testing failure in production-like conditions. Left catches the cheap problems early. Right catches what no earlier check could see.
479. What is the difference between DevOps, SRE, and platform engineering?
The short answer
DevOps is the culture and the set of practices: shared ownership, automation and fast, safe delivery. Site reliability engineering, SRE, is a specific way of running production created at Google, which treats operations as an engineering problem and manages reliability with service level objectives and error budgets. Platform engineering builds an internal platform of self-service tools and paved paths, so product teams can follow good practice without becoming infrastructure experts.
| DevOps | SRE | Platform engineering | |
|---|---|---|---|
| What it is | A culture and practices | An engineering discipline for reliability | Building internal products for developers |
| Core question | How do we deliver fast and safely together? | How reliable must this be, and how do we keep it there? | How do we make the right way the easy way? |
| Key tools | CI/CD, automation, metrics | SLOs, error budgets, postmortems, toil limits | Templates, self-service portals, paved paths |
| Typical output | Frequent, safe releases | Reliability targets and their enforcement | An internal developer platform |
SRE in more detail. Google started SRE in 2003, putting software engineers in charge of operations. Its main ideas:
- Service level objectives. A target such as "99.9% of requests succeed" (question 630).
- Error budgets. The 0.1% allowed to fail is a budget. While budget remains, the team ships fast. When it is spent, reliability work comes first (question 631).
- Limit toil. Toil is repetitive manual work that scales with the service. SREs aim to spend no more than about half their time on it, and automate the rest.
- Blameless postmortems after incidents (question 455).
A Google phrase sums up the relationship: SRE is one concrete way to implement DevOps.
Platform engineering in more detail. As companies grew, "you build it, you run it" asked every team to understand Kubernetes, networking, security and pipelines. That is too much. A platform team builds a shared internal platform: a standard pipeline, a template for a new service, self-service environments, built-in monitoring. Product teams use it like any product, often through a portal such as Backstage. The idea is often called paved roads or golden paths: a well-supported default way to do things, which teams may leave when they have a good reason.