A written version of the interactive roadmap above — every station, what you'll learn, and a small thing to build — laid out for reading, reference and search.
Foundations Start here
F1. The SRE Mindset
Beginner · 45 min
SRE is what happens when you treat operations as a software problem. Learn the core bet — reliability is a feature you budget for, not a value you maximize — plus the vocabulary that follows from it: SLIs, SLOs, error budgets, toil, and why 100% uptime is the wrong target for almost everything.
Skills: Reliability as a feature · Error budgets, intuitively · Toil vs engineering · Ops as a software problem
Build it: Argue why a 99.99% availability target can be worse for users than 99.9%. When is chasing another nine actively harmful?
F2. Linux & Systems
Beginner · 60 min
Reliability lives on real machines. Learn how processes, memory, the filesystem and syscalls actually work, and the tools — top, strace, perf, dmesg, journalctl — that turn a vague "it’s slow" into a specific, fixable cause. This is the layer under every dashboard you’ll ever stare at.
Skills: Processes & memory · Filesystems & I/O · strace / perf / top · Reading system limits
Build it: A service is using 100% CPU but doing no useful work. List the first three commands you run and what each would tell you.
F3. Networking for SREs
Beginner · 55 min
Most outages are network outages wearing a costume. Learn TCP/IP, DNS, HTTP, TLS and load balancing well enough to trace a request end to end, read a latency histogram, and know whether the fault is the client, the network, the load balancer, or the server behind it.
Skills: TCP/IP & DNS · HTTP & TLS · Load balancing · Tracing a request
Build it: A page loads slowly for 1% of users in one region. Walk the request path and name where you would look, in order.
F4. Distributed Systems
Intermediate · 60 min
At scale, everything is distributed, and distributed systems fail in ways single machines never do. Learn CAP, replication and consistency, partial failure, and the tail-latency and cascading-failure patterns that turn one slow node into a full outage — the failure modes SRE exists to survive.
Skills: CAP & consistency · Replication · Partial failure · Cascading failures
Build it: One replica in a 5-node cluster gets slow, not dead. Explain how that single slow node can take down the whole service.
F5. Coding for SREs
Intermediate · 55 min
The line between ops and SRE is code. Learn enough Go or Python to automate the toil away — write tools, not tickets: health checkers, backfill scripts, custom exporters, and the small daemons that turn a manual runbook into a thing that fixes itself at 3am so you don’t have to.
Skills: Go / Python for infra · Automating toil · CLIs & daemons · Writing tools, not tickets
Build it: You do the same 6-step recovery by hand once a week. Sketch the script that replaces it — and the one check that makes it safe to run unattended.
F6. Observability Foundations
Intermediate · 55 min
You cannot operate what you cannot see. Learn the three pillars — metrics, logs and traces — what each is good and bad at, how cardinality quietly bankrupts a metrics bill, and the difference between monitoring (known unknowns) and observability (asking new questions of a live system).
Skills: Metrics, logs, traces · Cardinality & cost · RED / USE methods · Monitoring vs observability
Build it: Given only a rising error rate, decide which of the three pillars you reach for first — and what each of the other two would add.
Reliability Practice The craft
T1. SLIs, SLOs & Error Budgets
Intermediate · 60 min
The heart of SRE. Learn to pick SLIs that reflect user pain, set SLOs that are honest rather than aspirational, and run an error budget as a real policy — the shared number that decides, without an argument, whether the next sprint ships features or pays down reliability debt.
Skills: Choosing good SLIs · Setting honest SLOs · Error-budget policy · Burn-rate alerts
Build it: Your SLO is 99.9% over 30 days. Compute the error budget in minutes, then explain what a 10x burn-rate alert is actually catching.
T2. Monitoring & Alerting
Intermediate · 55 min
A pager that cries wolf is worse than no pager. Learn to alert on symptoms not causes, tie every page to an SLO and a runbook, kill the noisy alerts that train people to ignore the pager, and design dashboards that answer "is it the service or is it me?" in ten seconds.
Skills: Symptom-based alerts · Alert fatigue · Dashboards that answer · Paging vs ticketing
Build it: Your team gets 40 pages a week and ignores most. Give three rules for deleting an alert — and one alert you would never delete.
T3. Incident Response
Intermediate · 55 min
When it breaks, structure beats heroics. Learn incident command — one coordinator, clear roles, a single comms channel — severity levels, and how to drive toward mitigation (stop the bleeding) before diagnosis (understand the cause). The goal is short MTTR, not a clever theory shouted over each other.
Skills: Incident command · Severity levels · Mitigate before diagnose · Comms under pressure
Build it: A sev-1 starts. Write the first three actions the incident commander takes in the first five minutes — none of which is "find the root cause".
T4. Blameless Postmortems
Advanced · 50 min
The outage is the tuition; the postmortem is the lesson. Learn to write blameless postmortems that find the systemic cause instead of a person to blame, turn each into concrete action items with owners, and build the culture where engineers report their own mistakes because it’s safe to.
Skills: Blameless culture · Systemic root cause · Actionable follow-ups · Learning from failure
Build it: A deploy took the site down. Rewrite the blaming line "Alex pushed a bad config" as a systemic finding with a real fix.
T5. Capacity Planning
Advanced · 55 min
Running out of capacity is a self-inflicted outage. Learn load testing, how to find the knee where latency explodes, headroom and forecasting from real growth, and how autoscaling helps and where it quietly fails — because autoscaling can’t save you from a dependency that doesn’t scale.
Skills: Load testing · Finding the latency knee · Headroom & forecasting · Autoscaling limits
Build it: Load tests show latency fine to 8k RPS, then a cliff. Explain what "the knee" is and why you provision for 5k, not 8k.
T6. Release Engineering
Advanced · 55 min
Most outages are self-inflicted, at deploy time. Learn progressive delivery — canary, blue-green, feature flags — automated rollback on SLO regression, and why the ability to ship a change to 1% of traffic and undo it in seconds is the single biggest reliability lever a team has.
Skills: Canary & blue-green · Feature flags · Automated rollback · Progressive delivery
Build it: A canary at 1% shows a small error-rate bump. Describe the automated rule that halts the rollout — and why humans are too slow here.
Scale & Resilience Keep it up at scale
P1. Reliability Patterns
Advanced · 60 min
A handful of patterns prevent most cascading failures. Learn timeouts (never wait forever), retries with backoff and jitter (without stampeding), circuit breakers (fail fast when a dependency is down), bulkheads and backpressure — the small guardrails that keep one failure from becoming all of them.
Skills: Timeouts & deadlines · Retries, backoff, jitter · Circuit breakers · Bulkheads & backpressure
Build it: A retry storm is amplifying an outage. Explain how backoff + jitter + a circuit breaker each independently defuse it.
P2. Chaos Engineering
Advanced · 55 min
You don’t know a system is resilient until you break it on purpose. Learn to run controlled fault injection — kill nodes, add latency, drop packets — as a hypothesis test with a blast radius, and to hold game days that find the failure modes before your users, and your pager, find them for you.
Skills: Fault injection · Hypothesis testing · Blast-radius control · Game days
Build it: Design a first chaos experiment for a checkout service. State the hypothesis, the blast radius, and the abort condition.
P3. Kubernetes Reliability
Advanced · 60 min
Most SREs operate on Kubernetes now. Learn the reliability primitives it gives you — liveness and readiness probes, PodDisruptionBudgets, resource requests and limits, horizontal autoscaling, and multi-AZ spreading — and the classic ways each is misconfigured into an outage instead of out of one.
Skills: Liveness & readiness probes · PodDisruptionBudgets · Requests & limits · Multi-AZ & autoscaling
Build it: A readiness probe is set to the same endpoint as liveness. Explain the outage that can cause during a slow start.
P4. Automation & Toil Elimination
Advanced · 55 min
Toil is manual, repetitive, automatable work that scales with load and teaches you nothing. Learn to measure it, cap it (Google’s 50% rule), and climb the ladder from runbook to script to self-healing system — so the team’s time goes to engineering that removes future toil, not to doing it again.
Skills: Measuring toil · The 50% toil cap · Runbook → automation · Self-healing systems
Build it: Pick a recurring manual task and place it on the ladder runbook → script → self-healing. What has to be true to take the last step safely?
P5. Disaster Recovery
Advanced · 55 min
Backups you have never restored are not backups. Learn RTO and RPO as the two numbers that define your promise, replication and failover across zones and regions, and why the DR drill — actually failing over on a calm Tuesday — is the only thing that tells you whether any of it works.
Skills: RTO & RPO · Backups & restore drills · Failover & multi-region · DR game days
Build it: Define RTO and RPO for a payments database, then explain why an untested backup is a liability, not an asset.
P6. The SRE Career & Culture
Advanced · 50 min
SRE is as much culture as technology. Learn the models — embedded vs central SRE, production-readiness reviews, the shared-ownership handshake with dev teams — and how a senior SRE creates reliability by influence: changing how the org ships, not by being the person who stays up all night.
Skills: Embedded vs central SRE · Production-readiness reviews · Shared ownership · Reliability by influence
Build it: A team wants to launch a service with no SLOs and no runbook. Design the production-readiness review that says "not yet" without saying "no".