observability
Observability
How to see what your running system is doing — through logs, metrics, and traces — so that when something breaks at 3am you can actually find out why.
Start track →Start from zero
Before the senior material: what observability even is, and the handful of words the rest of the track assumes you already know.Three pillars: metrics, logs, and traces
Metrics, logs, and traces each answer a different question most cheaply. Join keys and exemplars make them compose into one navigable surface.Structured logging: schema, levels, redaction
Why production logs in 2026 are JSON-or-nothing, what a usable log schema actually contains, how levels and sampling control the bill, and why PII discipline and log injection are first-class engineering concerns — not afterthoughts.OpenTelemetry: API, SDK, Collector, OTLP
The four pieces of OTel — the API your code calls, the SDK that builds telemetry, the Collector that processes and routes it, and OTLP that carries it — and how the layered model lets you instrument once and swap backends without rewriting code.RED and USE: the two halves of every dashboard
Why RED (Rate, Errors, Duration) describes services from the caller's side, USE (Utilization, Saturation, Errors) describes resources from the kernel's side, and why senior engineers run both — plus the cardinality tax that punishes naive labelling.SLI, SLO, and error budgets: reliability in numbers
SLI is a good/total ratio; SLO is the target; error budget is 1 − SLO. MWMBR alerting, error budget policy, SLO platforms, and the cultural adoption pattern that turns arithmetic into decisions.Trace propagation: the headers that stitch services together
Why the W3C traceparent header is the load-bearing 55-byte string that turns 50 disconnected services into one navigable trace, how baggage carries context across async boundaries, and how head vs tail sampling decide which traces survive.Profiling: where the CPU and the bytes actually went
How sampling profilers turn an unfair share of CPU into a flame graph you can read in 60 seconds, how eBPF and continuous profiling watch production at 2-5% overhead, and how on-CPU vs off-CPU profiles answer different questions about the same slow request.Putting it together: a production observability story
How RED + USE + SLO + traces + profiles compose into one debugging loop, how OpenTelemetry unifies four signals through one SDK and one wire format, and what 'observability that pays for itself' actually means at production scale.Build with this track
Guided projects that exercise what you learn here.
Collaborative cursors
Show every connected user's live cursor and selection in a shared document, conflict-free, over WebSocket.
A concurrent Go ingest service
Build a concurrent ingest/fan-out worker in Go — then operate it: bound the work, apply backpressure, make downstream calls survive failure, ship it in a minimal container, and work a goroutine-leak incident before it eats your memory.
Grounded RAG Service
A RAG demo that answers from a corpus is easy; a RAG service you'd trust in front of users is not. The hard part isn't retrieval, it's grounding: making the model say only what the retrieved text supports, attaching citations the reader can check, and proving with an eval set that the answers don't drift into confident fiction. You'll build the whole loop — chunk, embed, store, retrieve top-k, ground, cite, score — and feel exactly where it leaks.
Job scheduler
A cron + backoff job runner with at-least-once delivery, idempotent handlers, and visibility timeouts — so no job is silently lost even when workers crash mid-execution.
A Next.js app to production
Build a multi-tenant content app on the App Router — then run it: lock down auth and secrets, layer the caches, decide every edge-vs-node call, and work the incident when one tenant poisons a shared ISR page.
Mini OAuth 2.0 + PKCE login
Implement the authorization-code + PKCE flow end to end against a real provider, so you understand every redirect and token instead of trusting a library.
Async Python service, built and operated
Build an async FastAPI ingestion service that validates, pipelines, and survives load — then run it: package it, containerize it with correct PID-1 behaviour, and work the incident when a swallowed CancelledError quietly leaks tasks until the event loop starves.
Distributed rate limiter
Build a token-bucket limiter that holds across many app instances by keeping the counter in Redis, not in process memory.
React feature at scale
Ship one real production React feature — a live collaborative activity dashboard — then operate it: optimistic edits, streaming updates, a frame budget, full a11y, and an incident drill when a render storm freezes the tab.
URL shortener at scale
Build a URL shortener that survives real traffic — then run it: deploy it, watch it, and work the incident when one hot link melts your cache.
Virtual data grid
Render and smooth-scroll 100k rows at 60fps with windowing/virtualization, sticky headers, and full keyboard navigation — no library, just math.
Deployment & Infra
How your code gets from your laptop to running servers — packaging it in containers, putting new versions live without downtime, and describing infrastructure as code.