12 parts · 16 chapters

Site Reliability Engineering

Site reliability engineering is what happens when you treat operations as a software problem and reliability as a number. Its central idea is that 100% is the wrong target: users cannot tell 99.99% from 100%, every extra nine costs more than the last, and the gap between the target and perfect is a budget the team can spend on shipping. SLOs make that budget explicit, error budgets make it enforceable, and everything else in this course (alerts, incidents, postmortems, release safety, toil) is how a team lives within it.

Twelve parts. What SRE is and the contract it makes; SLIs, SLOs and error budgets with burn-rate maths; alerting on symptoms with a sane paging policy; incident response roles, severity and communication; blameless postmortems with action items that get done; capacity planning, load testing and release safety; measuring and removing toil; and the frontend's share: client SLOs, crash-free rate, and what should page a frontend engineer. Four deeper parts follow: observability for operators, dependencies and graceful degradation, disaster recovery and game days, and production readiness with on-call health.

Start reading · Part 0 Present as slides
the contract · SLOs and error budgets · alerting · incidents · postmortems · capacity and release safety · toil · the frontend share · observability · degradation · disaster recovery · readinesssenior → staff · every engineer who carries a pager or decides what ships
the contractReliability versus velocity, settled with a number both sides agree to.
SLIs, SLOs, budgetsChoosing indicators users feel, setting objectives, burn rates and budget policies.
alertingSymptom-based alerts, multi-window burn-rate pages, and an end to alert fatigue.
incident responseCommander, operations, communications; severity levels; status pages; runbooks.
postmortemsBlameless practice, contributing factors over root causes, and action items that close.
capacity and releasesForecasting, load testing, canaries, rollbacks, and freezes tied to the budget.
toilWhat counts as toil, measuring it, and what to automate first.
the frontend shareClient SLOs, crash-free sessions, and the pages a frontend engineer should get.
00

What SRE Is

What SRE is: the contract
1 ch · ~10 min01

SLIs, SLOs and Error Budgets

Choosing SLIs and setting SLOs · Error budgets and burn rates
2 ch · ~18 min02

Alerting

Symptom-based alerting with burn rates · Paging policy and alert fatigue
2 ch · ~16 min03

Incident Response

Roles, severity, communication and runbooks
1 ch · ~12 min04

Postmortems

Blameless practice and action items that get done
1 ch · ~12 min05

Capacity and Release Safety

Capacity planning and load testing · Release safety: canaries, rollbacks and budget gates
2 ch · ~16 min06

Toil and Automation

Measuring toil and what to automate first
1 ch · ~10 min07

The Frontend's Share

Client SLOs and the crash-free rate · What pages a frontend engineer
2 ch · ~15 min08

Observability for Operators

Three signals, two methods, one bill
1 ch · ~11 min09

Dependencies and Graceful Degradation

Keeping a slow dependency contained
1 ch · ~12 min10

Disaster Recovery and Game Days

Recovery objectives, restores and practising failure
1 ch · ~11 min11

Readiness and On-call Health

Before launch, during on-call, across quarters
1 ch · ~11 min
Built on Cloud, Infra and Distributed SystemsThis course assumes the earlier infrastructure courses for the mechanics (observability, deployment, failure domains) and gives them a purpose: a reliability target users feel and a team can afford. The Big-company FE course part 8 is the frontend on-call view; part 7 here connects them.