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.
At-least-once job queue
Build a durable job queue on Postgres with visibility timeouts and idempotent consumers, so a crashed worker never drops a job.
Bloom filter
Build a space-efficient probabilistic set that answers membership queries in O(1) with a tunable false-positive rate — and understand exactly why it can never produce false negatives.
Cache stampede lab
Reproduce a thundering-herd cache miss under load, then kill it with single-flight and early-expiry recomputation.
Circuit breaker
Build a circuit breaker that stops hammering a failing dependency, probes it safely with a half-open state, and resets automatically — the exact pattern that keeps microservice cascades from turning one bad node into a full outage.
Collaborative cursors
Show every connected user's live cursor and selection in a shared document, conflict-free, over WebSocket.
Command palette
A ⌘K command palette with fuzzy ranking, async action sources, and complete keyboard control (arrows, Enter, Escape, scoping) — the interaction layer every power-user tool needs.
Consistent hashing ring
Build a virtual-node hash ring that remaps only the minimum set of keys when a node joins or leaves — the foundational primitive behind Dynamo, Cassandra, and every sharded cache that must survive node churn without a full reshuffle.
Feature-flag service
Build a small flag service with targeting rules, percentage rollouts, and a typed SDK that evaluates flags client-side from a cached ruleset.
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.
Huffman coding
Build a lossless compressor from scratch: construct the optimal prefix-free code tree bottom-up, derive the bit strings, and prove the round-trip is exact and the output is shorter than fixed-width encoding.
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.
LRU cache
Build a Least-Recently-Used cache that evicts in O(1) by combining a hashmap and a doubly-linked list — the canonical interview problem that teaches you exactly why cache eviction is harder than it looks.
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.
Offline PWA sync
Offline-first notes PWA: a local write queue (IndexedDB) that syncs on reconnect with last-writer-wins conflict resolution, a service worker for asset caching, and background sync for missed flushes.
Personal portfolio page
Build a one-page site about you with plain HTML, CSS, and a sprinkle of JavaScript — no framework, no build step, just files you can open in a browser. By the end you'll have something real to show, and you'll actually understand every line of it because you wrote it yourself.
Presigned upload flow
Direct-to-storage uploads via presigned URLs with size/content-type limits and a completion webhook that verifies the object actually arrived — so your API server never touches file bytes.
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.
Query plan visualizer
Paste an EXPLAIN (ANALYZE, FORMAT JSON) and render the plan tree with per-node timing and row-estimate error, so a bad join jumps out visually.
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.
Regex engine
Build a regular expression engine from scratch using Thompson NFA construction and subset simulation — the same technique that makes grep and re2 immune to catastrophic backtracking.
Signals mini
Build a ~100-line reactive signals library (signal/computed/effect) with automatic dependency tracking and glitch-free batched updates — the same model that powers Solid, Preact Signals, and Vue 3.
Skip list
Build a probabilistic ordered data structure that delivers O(log n) search, insert, and delete without the rotation bookkeeping of balanced trees — just layered express lanes through a sorted linked list.
Static page deploy
Take a static HTML/CSS page from a file on disk to a public URL with a deploy you can re-run — your first real delivery, no build step required.
Text diff — Myers algorithm
Implement the Myers diff algorithm from scratch: compute the longest common subsequence, backtrack an edit script, prove minimality, and apply patches so any round-trip is byte-perfect.
Topological build scheduler
Build a DAG-based task scheduler — like Make or a CI pipeline — that orders jobs by dependency, detects cycles before they deadlock, and identifies which tasks can run in parallel.
Trie autocomplete engine
Build a prefix tree that powers ranked autocomplete — insert words with weights, walk every prefix in O(prefix length + results), and handle tie-breaking deterministically without a database.
Union-Find (Disjoint Set Union)
Build a disjoint-set structure from a naive parent array up to near-constant amortized time — then use it to drive Kruskal's MST algorithm on a weighted graph.
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.