The disciplines that come after DevOps — and why each of them exists because the previous one succeeded.

~5,400 words across 4 notes. Built August 2026. [reference].

The one idea: Waterfall, Agile, DevOps, SRE, platform engineering and DevSecOps are not competing philosophies or a seniority ladder. Each solved the bottleneck the previous one created by working. Optimise any stage of a pipeline and the constraint relocates — that’s the whole sequence.

Why this exists

devops/ had eleven sections covering the tools — pipelines, Terraform, Kubernetes, Prometheus — and devops-reference had two paragraphs on the disciplines that decide how those tools get used. The vault knew what an error budget was (observability 01 covers SLI/SLO/SLA properly) but had zero occurrences of “toil”, nothing on on-call design, incident command or blameless postmortems, one passing mention of Internal Developer Platforms, and no note on DevSecOps at all.

So: the vocabulary of the roles the vault is preparing you to hold, which existed everywhere in job ads and nowhere in these notes.

Reading order

Read 01 first — the other three are its branches.

  1. How Delivery Practice Evolved — [Beginner] — five transitions, each fixing the last one’s bottleneck. The spine of the folder
  2. Site Reliability Engineering — [Intermediate] — toil and the 50% cap, on-call design, incident command, blameless postmortems, capacity planning, DORA’s four
  3. Platform Engineering — [Intermediate] — the two ways a DevOps team breaks, the IDP, golden paths not golden cages, and cognitive load as the actual thesis
  4. DevSecOps — [Intermediate] — what runs at which pipeline stage, SAST vs SCA vs DAST, SBOMs, policy as code, and the alert fatigue that kills most rollouts

The things worth carrying

  1. Each era created the next era’s problem by succeeding. Agile made dev fast → ops became the wall. DevOps fixed the wall → nobody owned production. SRE fixed that → the DevOps team didn’t scale → 01
  2. They coexist. “We’ve moved past DevOps” is nearly always a misreading — the platform is built by people doing DevOps work → 01
  3. The error budget turns a values argument into arithmetic. Nobody debates reliability vs features; the number decides → 01
  4. Toil is automatable manual work that scales with the service — distinct from overhead, and capped at 50% with enforcement. Drop the enforcement and SRE becomes a renamed sysadmin role → 02
  5. Every noisy alert makes the system less reliable. Deleting alerts is real reliability work → 02
  6. Mitigate first, diagnose second. The rollback is reversible; live debugging on a burning system isn’t → 02
  7. Blameless isn’t kindness, it’s evidence collection. Punish the name and you lose the detail you needed → 02
  8. A central DevOps team becomes the wall it was created to remove — and embedding engineers instead just trades the queue for twelve incompatible setups → 03
  9. Golden paths, not golden cages. Mandatory means teams route around it invisibly → 03
  10. Measure users’ outcomes, not the platform’s output. Time-to-first-deploy, not modules shipped → 03
  11. If your platform must be understood in addition to the tools underneath, it made things worse → 03
  12. SCA is the highest-value scanner for most teams — most of your code is code you didn’t write → 04
  13. A scanner nobody acts on is worse than none — it converts a known gap into false confidence → 04
  14. A leaked secret isn’t fixed by deleting the commit. Rotate first, clean history second → 04

Where this connects

07-observability/The prerequisite. SLI/SLO/SLA and error budgets live there; note 02 deliberately doesn’t repeat them
05-ci-cd/The pipeline all four notes assume
GitOpsThe deploy mechanism most IDPs sit on
cybersecurityNote 04’s other half, at depth
the engineering rolesWhat each of these is like to hold as a job
availabilityWhere the nines come from

The honest note

[reference], and unusually so — three of these four are organisational disciplines, and you cannot validate an organisational discipline by reading about it or by building a toy. A one-person project has no dev/ops wall, no ticket queue, no on-call rotation and no cognitive-load problem. The conditions that make these ideas necessary are conditions of scale.

What would close the gap, honestly ranked:

  1. Define one real SLO on something you actually run — including the bit everyone skips: decide in advance what you’ll stop doing when the budget is gone. Note 02 is theatre until that decision is real
  2. Write a postmortem for a failure you caused. Blameless is easy when it’s someone else. It’s a genuinely different exercise on your own mistake, and it’s the one worth doing
  3. Track a week of your own work as toil / engineering / overhead. Cheap, and usually uncomfortable
  4. Add SCA to one repo — Dependabot or Trivy, ten minutes. Then actually resolve what it finds, which is the part that teaches you why baselining exists
  5. Add secret scanning with a pre-commit hook, then deliberately try to commit a fake AWS key and watch it fail
  6. Build the smallest possible golden path — one create-service script producing a repo with CI, a Dockerfile and a dashboard already wired. Note 03 at a scale of one, and it still teaches the trade
  7. The reading: the Google SRE Book and SRE Workbook (free); Accelerate (Forsgren, Humble, Kim) for the DORA evidence; Team Topologies (Skelton & Pais) for the cognitive-load argument note 03 rests on

What’s missing: chaos engineering in any depth (it’s in devops-reference and distributed systems testing), FinOps and cost as a reliability constraint, progressive delivery specifics, compliance frameworks (SOC 2, ISO 27001 — see GRC), and anything about the politics of actually introducing these to an organisation that hasn’t asked for them, which is the hardest part in practice.

→ Reading is not a rank.

↑ Back to DevOps