#SRE
9 posts
SRE in Practice #5 Postmortems: Blameless Reviews and Keeping Action Items Alive
Turning incidents into organizational learning: why blamelessness is an information-gathering strategy rather than kindness, trigger criteria for which incidents get a postmortem, the template running from timeline through impact and root-cause analysis to action items, the questioning method that refuses to stop at human error and digs down to system causes, and the tracking rules that keep action items from rotting in the backlog.
SRE in Practice #4 On-Call Operations: Rotations, Escalation, Load Management
Designing an on-call system that people can sustain: the minimum headcount that makes a rotation viable and the shift structures, the escalation chain for when the primary responder is stuck, the handoff routine between shifts, why pages-per-shift needs a measured ceiling, securing follow-up time to pay down what on-call uncovers, and the compensation and culture without which none of it lasts.
SRE in Practice #3 Alert Design: Symptom-Based Alerting and Multiwindow Burn Rates
Designing alerting so that only pages worth waking a human survive: why to move from cause-based alerts (high CPU) to symptom-based alerts (user requests failing), the criterion that separates pages from tickets, building burn-rate alerts as combinations of short and long windows to cut both false positives and false negatives, and the operating routine that measures and reduces alert fatigue.
SRE in Practice #2 Operating the Error Budget: The Policy Document and Burn Rates
Turning the error budget from a concept into an operating tool: the error budget policy document that agrees on actions before the incident, the executive sign-off that makes feature freezes actually work, calculating the burn rate that expresses how fast the budget is being consumed, responding differently to fast burns and slow burns, and the practical patterns that wire the budget into release decisions.
SRE in Practice #1 Designing SLIs and SLOs: What to Measure and How Many Nines to Promise
First post in the SRE in Practice series, on actually designing SLIs and SLOs: picking what to measure from user journeys, why good SLIs take the good/total ratio form, the trade-offs between measuring at the load balancer, the server, or the client, why SLO targets must start from current performance rather than aspiration, choosing the measurement window, and what an SLO specification document must contain.
The Core of Incident Handling — What Matters Most When Things Break
Making incident response run on procedure instead of heroics: recovery before root cause, separating command, communications, and operations, severity levels and declaration criteria, writing blameless postmortems that still name causes, and the conditions that keep on-call sustainable.
Error Budgets — The Concept and Math of a Failure Allowance
The error budget that falls out of any SLO: converting budget size into time and request counts, why burn-rate alerts beat threshold alerts, the policy that fires when the budget runs dry, and running the speed-versus-stability conflict by rule instead of by meeting.
SLI, SLO, SLA — From Metric to Objective to Contract
Sorting out the easily confused trio in working order: choosing good SLIs (the good-events-ratio method), setting SLO numbers realistically, why an SLA must be looser than the SLO, a feel for the nines, and the common mistakes.
SRE vs. DevOps — Where They Overlap and Where They Split
What SRE and DevOps each are, where they overlap, and where they diverge: DevOps as culture and philosophy, SRE as its concrete implementation, the tools unique to SRE (SLOs, error budgets, toil caps), how the roles actually split in organizations, and how to read job postings.