Vibe Engines is free, interactive AI engineering & system design — runs in your browser. Pick a learning path →
18 stations. 3 tracks. From Linux, networking and distributed systems through SLOs, error budgets, alerting and incident response, then reliability patterns, chaos engineering and disaster recovery — become the engineer who keeps it up when everything else says it should be down.
18 stations on 3 ladders, in order — each rung is written assuming the one above it. Mark them off as you go; your progress is saved in this browser.
F1 · 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.
Build itArgue why a 99.99% availability target can be worse for users than 99.9%. When is chasing another nine actively harmful?
✓ CheckpointExplain why a team might deliberately target 99.9% over 99.99% — in terms of the error budget it buys back, not laziness.
F2 · 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.
Build itA service is using 100% CPU but doing no useful work. List the first three commands you run and what each would tell you.
✓ CheckpointDiagnose a vague "it's slow" report with top/strace/perf, narrowing to a specific resource or syscall instead of guessing.
F3 · 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.
Build itA page loads slowly for 1% of users in one region. Walk the request path and name where you would look, in order.
✓ CheckpointTrace a slow request end-to-end and name, in order, every hop where the fault could actually be hiding.
F4 · 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.
Build itOne replica in a 5-node cluster gets slow, not dead. Explain how that single slow node can take down the whole service.
✓ CheckpointExplain how one slow — not dead — replica can take down an entire cluster, and why that's scarier than a clean crash.
F5 · 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.
Build itYou 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.
✓ CheckpointLook at a recurring manual fix and sketch the automation that replaces it, including the one check that makes it safe to run unattended.
F6 · 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).
Build itGiven only a rising error rate, decide which of the three pillars you reach for first — and what each of the other two would add.
✓ CheckpointGiven one symptom, pick which pillar — metrics, logs, or traces — to reach for first, and say what the other two would add.
6 rungs · ~5h · ends at Release Engineering.
T1 · 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.
Build itYour SLO is 99.9% over 30 days. Compute the error budget in minutes, then explain what a 10x burn-rate alert is actually catching.
✓ CheckpointCompute an error budget in minutes from an SLO, and explain what a burn-rate alert is actually measuring.
T2 · 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.
Build itYour team gets 40 pages a week and ignores most. Give three rules for deleting an alert — and one alert you would never delete.
✓ CheckpointLook at a noisy alert and decide, by rule rather than gut feel, whether to delete it, fix it, or protect it.
T3 · 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.
Build itA 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".
✓ CheckpointState the first three things an incident commander does in a sev-1 — and explain why none of them is "find the root cause."
T4 · 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.
Build itA deploy took the site down. Rewrite the blaming line "Alex pushed a bad config" as a systemic finding with a real fix.
✓ CheckpointRewrite a blaming postmortem line into a systemic finding with a real fix attached.
T5 · 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.
Build itLoad tests show latency fine to 8k RPS, then a cliff. Explain what "the knee" is and why you provision for 5k, not 8k.
✓ CheckpointFind "the knee" in a load-test curve and explain why you provision below it, not at it.
T6 · 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.
Build itA canary at 1% shows a small error-rate bump. Describe the automated rule that halts the rollout — and why humans are too slow here.
✓ CheckpointDescribe an automated rollback rule for a canary deploy, and explain why a human reacting is too slow to trust here.
6 rungs · ~6h · ends at The SRE Career & Culture.
P1 · 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.
Build itA retry storm is amplifying an outage. Explain how backoff + jitter + a circuit breaker each independently defuse it.
✓ CheckpointExplain how backoff+jitter and a circuit breaker each independently stop a retry storm from amplifying an outage.
P2 · 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.
Build itDesign a first chaos experiment for a checkout service. State the hypothesis, the blast radius, and the abort condition.
✓ CheckpointDesign a first chaos experiment with a stated hypothesis, blast radius, and abort condition.
P3 · 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.
Build itA readiness probe is set to the same endpoint as liveness. Explain the outage that can cause during a slow start.
✓ CheckpointSpot a liveness probe pointed at the same endpoint as readiness, and explain the outage it causes on a slow start.
P4 · 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.
Build itPick 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?
✓ CheckpointPlace a recurring task on the runbook → script → self-healing ladder, and say what has to be true before the last step is safe.
P5 · 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.
Build itDefine RTO and RPO for a payments database, then explain why an untested backup is a liability, not an asset.
✓ CheckpointDefine RTO and RPO for a real system, and explain why an untested backup isn't actually a backup.
P6 · 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.
Build itA team wants to launch a service with no SLOs and no runbook. Design the production-readiness review that says "not yet" without saying "no".
✓ CheckpointDesign a production-readiness review that blocks an unready launch without just saying no.
The common questions before you start — how long it takes, whether to follow it in order, and how it stays current.
It runs 18 stations across 3 tracks — roughly ~17h of focused learning, plus the time you spend actually building. It is self-paced, so most people work through it over a few weeks, an evening or a single station at a time.
The tracks are ordered so each station builds on the one before, and following them start to finish is the intended path. But every station also stands alone — if you already have the foundations, jump straight to the part you need.
Yes. The whole roadmap, and every handbook, lab, and challenge it links to, is free and open — no sign-up and no paywall.
It teaches the durable fundamentals of the role first, then the tooling and the AI-era shifts on top — so most of it stays relevant as individual tools churn, and it is revised as the role itself changes.
Anyone stepping into or leveling up in the SRE role — whether you are switching in, early-career, or a senior filling gaps. Start where you are; the ladder shows what is left.
See this alongside everything else on the same subject — handbooks, system designs, challenges and tools, in one place.