Performance
Performance capstone: a full investigation, end-to-end
You have learned seven tools. This is where they become one reflex. Take a real slow path — a slow endpoint, a heavy page, a lagging job — and run the full loop the track is built on: measure before you touch anything, find the single dominant cost, fix it at the layer where it lives, verify under the same load, and leave a gate behind so it cannot quietly come back.
Turn the whole track into one reproducible investigation: instrument, locate the dominant cost (refusing to guess), classify its shape, fix at the right layer, prove the win with before/after numbers under identical load, and enforce it so the regression cannot recur silently.
Pick one genuinely slow path in a real system (a slow API endpoint, a heavy web route, or a lagging background job — your own service or an open-source app) and bring it under a stated target by running the full Profile → Classify → Fix → Verify → Enforce loop, fixing at the right layer and proving every step with measurements rather than intuition.
- A before/after table measured under the same representative load: the target SLI plus the dominant-cost metric (e.g. flat% of the hotspot, allocation rate, query count, or bundle KB). Numbers, not estimates.
- Evidence that the fix landed at the right layer: the re-captured profile/log/bundle shows the SAME dominant cost reduced — not a different metric improved or the symptom merely masked.
- A short Amdahl write-up: the dominant cost's share of total, the speedup ceiling it implied, and the rejected wrong suspect with the evidence that ruled it out.
- A working CI gate (or alert) that would fail if this specific regression returned, with the threshold and a note on how it was chosen.
- Chain a second fix: after the first dominant cost is gone, re-profile — the new dominant cost is usually different (allocation gone, now cache- or round-trip-bound). Run the loop again and document how the bottleneck moved.
- Write a one-page investigation runbook: the five-step loop, which artifact to capture per cost shape, the fix ladder per shape, and the verify/enforce checklist — usable by an on-call engineer who has never seen this service.
- Pick a path that is slow on TWO axes (e.g. a server endpoint feeding a heavy client route) and show how the same loop applies on both the backend (profile/N+1) and the frontend (bundle budget), with separate before/after numbers for each.
- Add a continuous guard: a canary load test in CI that diffs the profile or bundle against main and fails the build if any function's flat share or any route's bundle grows beyond a set threshold.
This is the discipline the whole track was building toward, run once end to end: measure before you touch anything, let the evidence (and Amdahl) pick the one cost that matters, classify its shape, fix at the layer where that cost is created, verify under identical load, and leave a CI gate so the win persists. Do it once on a real slow path and the loop becomes the reflex you bring to every future incident — performance as a durable property, not a one-time project.