DevOps & Site Reliability Engineering

DORA Metrics, Twelve-Factor Apps, Platform Engineering & SRE

8 modules, 39 lessons: Measurement And Outcomes: DORA; The Twelve-Factor App; Collaboration and Continuous Integration; Continuous Delivery and Deployment; Service Level Objectives (SRE); Incident Response and Postmortems; Platform Engineering and IDPs; The Modern DevOps Toolchain Handoff.

Advanced · 2 hours · 39 lessons · 60 labs

Who it is for

Advanced level.

For engineers and technical leads who already ship services and want to measure and improve delivery: DORA metrics, SLOs, incident reviews and platform teams.

What you don't need yet:

What helps:

Before you start:

Take first:

Take next:

Learning paths:

Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.

Labs

60 labs, 35 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.

What is free

Start free: First 5 lessons free with an account. Pro: Every course, lab, handbook, practice exam and certificate.

Course outline

Measurement And Outcomes: DORA

  1. What DevOps Actually Is (1 lab): You can explain DevOps as a set of measurable capabilities rather than a team or a tool, name DORA's two outcome factors, and read a value stream map to find where delivery time is really spent.
  2. Throughput: Change Lead Time And Deployment Frequency (4 labs): You can define change lead time and deployment frequency in DORA's own words, say what each one excludes, and compute both from a real git history rather than from a survey answer.
  3. Instability: Change Fail Rate And Deployment Rework Rate (3 labs): You can state DORA's definitions of change fail rate and deployment rework rate, explain how they differ, and derive both from the record a repository already keeps.
  4. Restoration: Failed Deployment Recovery Time (3 labs): You can define failed deployment recovery time exactly, say which failures it covers and which it does not, and compute it from the deployment record.
  5. The Four Keys History And Retiring MTTR (2 labs): You can explain why almost every article names four DORA metrics, what changed in 2023 and 2024, and why mean time to restore was replaced rather than renamed.
  6. The Pitfalls Of Measurement (3 labs): You can name DORA's own stated pitfalls, demonstrate how a delivery metric is gamed, and choose a way of reporting these numbers that resists gaming.

The Twelve-Factor App

  1. Codebase And Dependencies (3 labs): You can state the first two factors in the manifesto's own words, tell a codebase from a deploy, and explain why declaration without isolation is not enough.
  2. Config And Backing Services (3 labs): You can apply the manifesto's open source test to any repository, move configuration into the environment, and treat a database or queue as an attached resource that can be swapped without a code change.
  3. Build, Release, Run And Processes (4 labs): You can separate build, release and run as three distinct stages with an append-only release ledger, and explain why a stateless, share-nothing process is a deployment requirement rather than a style preference.
  4. Port Binding And Concurrency (3 labs): You can explain why a twelve-factor app binds a port the platform chooses, describe the process formation model of scaling, and say why processes must never daemonize or write PID files.
  5. Disposability, Dev Prod Parity And Logs (4 labs): You can make a process safe to kill at any moment, close the three gaps between development and production, and treat logs as an unbuffered event stream the platform routes.
  6. Admin Processes And The Open Source Update (6 labs): You can run administrative tasks as one-off processes against the same release, and you can describe accurately what changed when the manifesto was open sourced in 2024, including the proposals in flight.

Collaboration and Continuous Integration

  1. SDLC: From Request To Running Software (3 labs): You can map a software request through delivery and find the queues that make its lead time long.
  2. Trunk-Based Development Versus Git Flow (2 labs): You can choose a branching strategy deliberately and explain the integration cost of long lived branches.
  3. Continuous Integration (2 labs): You can describe continuous integration and inspect a pipeline that tests every change before it can build and deploy.
  4. Testing Strategies And The Test Pyramid (1 lab): You can distinguish test layers and choose a balanced suite that gives fast feedback without abandoning realistic checks.
  5. Building And Versioning The Artifact (2 labs): You can build one identifiable artifact and explain how version information follows it through promotion.

Continuous Delivery and Deployment

  1. Continuous Delivery Versus Continuous Deployment: You can distinguish continuous delivery from continuous deployment and place an approval at the boundary it protects.
  2. Deployment Strategies: Rolling Updates (1 lab): You can explain a rolling update and identify the compatibility constraint created when two versions serve traffic together.
  3. Deployment Strategies: Blue Green (1 lab): You can describe blue green deployment and weigh its fast rollback against the cost of a second production sized environment.
  4. Deployment Strategies: Canary Releases (2 labs): You can use a canary gate to limit blast radius and decide whether to promote or roll back from observed evidence.
  5. Decoupling Release From Deployment: Feature Flags (1 lab): You can use a feature flag for a measured rollout and explain the operational duties that come with flag driven release.

Service Level Objectives (SRE)

  1. Service Level Indicators: You can define an SLI as a measured signal of user visible service behaviour.
  2. Percentiles Rather Than Averages (1 lab): You can read latency percentiles and explain why an average can hide a slow tail.
  3. Service Level Objectives: You can write an SLO that turns an indicator into a time bounded reliability objective.
  4. Service Level Agreements: The Consequence Discriminator: You can distinguish an SLA from an SLO by asking what consequence follows when the objective is missed.
  5. Error Budgets (2 labs): You can calculate an error budget and use burn rate to decide whether to keep shipping or pause and fix.

Incident Response and Postmortems

  1. On-Call And Incident Response: You can explain on call responsibility and assign clear incident roles without relying on heroics.
  2. The Incident Lifecycle (2 labs): You can distinguish detection, declaration, mitigation, outage end and incident closure when reviewing an event.
  3. The Blameless Postmortem: You can write a blameless postmortem that explains contributing conditions and produces owned corrective work.
  4. Writing A Postmortem: The SRE Appendix (1 lab): You can check a postmortem against the SRE appendix structure and identify missing or blaming language before review.

Platform Engineering and IDPs

  1. Developer Toil And Cognitive Load: You can identify developer toil and reduce cognitive load by improving the platform around a team.
  2. Team Topologies: Stream Aligned And Platform Teams: You can explain how stream aligned and platform teams collaborate through a clear service boundary.
  3. Internal Developer Platforms: You can describe an internal developer platform as a product of paved paths, interfaces and feedback.
  4. The CNCF Platforms White Paper: You can evaluate a platform proposal against user needs, golden paths and measurable outcomes.

The Modern DevOps Toolchain Handoff

  1. Infrastructure As Code Context: You can place infrastructure as code in the delivery system and hand implementation details to the parallel course.
  2. Containers And Orchestration Context: You can explain how containers fit the delivery contract while handing container commands and orchestration to the parallel course.
  3. Pipelines And GitOps Context: You can distinguish a delivery pipeline from a GitOps reconciliation loop and place ownership at their boundary.
  4. Observability Context: You can connect logs, metrics and traces to the SLI and SLO definitions while handing implementation to the parallel observability course.

Certification courses