This course contains the use of artificial intelligence.
Your dashboards were green. Your users were failing. That gap — between what your graphs said and what your customers felt — is where production careers are made and lost, and closing it is a learnable engineering discipline. This course teaches it the way it is practised: on one running system, with every claim measured on a board, a drill, or a trace you can read yourself.
**The core ten lectures** build the discipline in order: why monitoring is not observability; the four golden signals and the RED/USE methods that tell you what to measure first; Prometheus metrics without the cardinality trap that melts servers (one label, multiplied by 2.1 million users, is 1.3 billion series — you will do that multiplication yourself); logs that earn their keep, structured and carrying trace IDs; distributed tracing with OpenTelemetry; dashboards built as answers to questions instead of walls of charts; alerting that pages on symptoms, not causes; SLOs and error budgets — the numbers that end arguments between product and engineering; a six-step incident method; and the full-stack blueprint with its sampling and retention economics priced out.
**Then you work three production projects on SwiftCart, one running example system you reproduce locally from fixtures.** Project 1: you write the telemetry contract, census its twelve signal groups, build RED metrics and the four-panel Grafana dashboard — then run the load drill that finds the saturation wall at 150 requests per second in an afternoon, instead of letting the sale find it in production. Project 2: you price full trace capture (31 gigabytes a day), design the sampling policy that cuts it to 3.4, and hunt the incident through a single 53-span trace to the 47 database calls an N+1 deploy was hiding — then prove the fix on a signed before/after board. Project 3: you set a 99.9% SLO, turn its 43.2-minute error budget into burn-rate alerts that page at 14.4× and ticket at 3×, strike the four cause-based paging rules — including a CPU page that cried wolf eleven times in a month with zero user impact — and pass PagerGate, a five-gate ship board you will watch fail three sabotage drills on purpose.
**Then you crack the interview.** Four lectures with the arithmetic done live: observability for a payments platform at 5,000 requests per second (432 million requests a day, budgeted to the series), a 3 a.m. incident debugged minute-by-minute — paged at 03:12, rolled back by 03:23, about half a budget-minute spent (≈1.2% of the month’s budget) — whiteboard SLO and telemetry-cost math, and a five-move playbook with a ten-question rapid-fire drawn from the whole course.
Every number in this course comes from the system on screen — census counts, drill boards, trace trees, budget tables. Nothing is asserted from memory. You also get downloadable code and exercise books, six quizzes — four checkpoints, an interview primer and a cumulative final, with a 70% mastery rule on the checkpoints and the final — five hands-on assignments with worked solutions, and a capstone: make your own production system observable, behind your own PagerGate.
AI disclosure: this course’s narration uses a cloned voice of the instructor, created with the instructor’s consent; all content, code, and curriculum are authored and verified by the instructor team.
