performance
Performance
How to find why software is slow and actually make it faster — measure first, then fix the real bottleneck instead of guessing.
Start track →Start from zero
Before the senior material: what performance work even is, and the handful of words the rest of the track assumes you already know.Profile first: measure where time actually goes
Why intuition fails more than half the time, how Amdahl's law caps every speedup you can ship, and the measurement loop senior engineers run before touching a line of code.Hot paths: diagnosis, shapes, and fixes
A hot path is a function the profiler finds over and over. Five shapes (CPU, allocation, cache, lock, syscall), one diagnostic loop, and the hardware counters that resolve ambiguity — from junior intuition to senior TMA.Cache vs big-O: when the textbook lies
An O(N) scan on contiguous memory routinely beats an O(log N) tree traversal — because cache lines, prefetchers, and branch prediction dominate wall-clock time in ways big-O cannot model.Garbage collection: pause budgets, allocation pressure, and the tail you don't see
GC pause is the symptom; allocation rate is the cause. Reduce allocations first, tune the collector second, switch collectors last.N+1: one logical operation, many round-trips
Why one screen renders into 200 database queries, the four fix patterns (JOIN, IN, batch-loader, prefetch) with their tradeoffs, and how the same problem repeats across REST, gRPC, and microservice fan-out.Batching: amortize fixed cost per operation
Per-op fixed cost dominates? Batch. Window = batch size and max wait; bigger batches buy throughput, charge tail-latency.Bundle budgets: the bytes your users actually pay for
JS bundle bytes = parse + compile + execute on the user's CPU. Set per-route budgets, enforce at CI, monitor with RUM.Putting it together: performance as a discipline, not a project
Seven tools, one loop. Profile, classify, fix, verify, enforce. The loop is what makes performance a durable property of the team, not a one-time project.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.
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.
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.
Crash-safe key-value store with a WAL
Build a tiny on-disk KV store that survives a kill -9 mid-write by appending to a write-ahead log before touching the main file.
Data Engineering
Working with data at scale — storing huge volumes cheaply and running analytics and search over it. Advanced; learn regular databases first.