Every fast system is on its way to becoming a slow one. Nobody decides to make it slower: a dependency upgrade costs 4%, a feature adds two queries, the dataset doubles past the page cache, a marketing campaign changes the traffic mix, and each change on its own is too small to notice. The earlier chapters of this track were about understanding and fixing performance. This one is about keeping it: capacity models that turn business plans into hardware before the hardware is needed, load tests that find the real limit, budgets and regression detection that catch slowdowns while they are still small and cheap, and the ownership model that makes all of it someone's job.
The most common capacity plan is a trend line on fleet CPU, extended six months, with a percentage added. It works until the thing that changes is not volume. Traffic grows, but so do the ratios between traffic and work, and those ratios change at different times for different reasons. A CPU trend line mixes them all together, so it cannot tell you why the forecast was wrong, and it cannot see a product decision before it ships.
A useful model is a chain of ratios, each with an owner. It starts from a business driver that someone outside engineering already forecasts — sessions, orders, active tenants, messages sent. It multiplies by product ratios (searches per session), then architecture ratios (shard queries per search, calls per request), then service demand D — resource-seconds per unit of work — and divides by the target utilisation the headroom policy allows. The result has a property the trend line lacks: when a PM proposes search-as-you-type, you can change one number and price the feature in cores before anyone writes code.
step 1
peak sessions / s
3,000
business driver
drifts via: marketing, seasonality, a TV spot
step 2
× searches / session
2.5
product ratio
drifts via: UX change: search-as-you-type ×5
step 3
× shard queries / search
24
architecture ratio
drifts via: re-sharding, index split
step 4
× CPU-ms / shard query
1.2 ms
service demand D
drifts via: corpus growth, code, runtime
step 5
÷ target utilisation
0.45
headroom policy (7.2)
drifts via: failure domains, deploy, forecast error
Search-as-you-type turns step 2 from 2.5 into ~12 and the tier from 480 to ~2,300 cores — a product decision with a capacity price that a CPU-trend forecast cannot see until it ships.
Picking the driver is the first real decision, and the criterion is stability of the ratio, not how intuitive the driver is. Orders are what the business watches, but orders per unit of backend work swing with conversion rate: a campaign that doubles low-intent traffic doubles browse load while orders rise 20%. Sessions track browse load far more closely. Test candidate drivers by computing demand ÷ driver per hour over several months and keeping the one with the smallest coefficient of variation. Where no single driver works, as with a multi-tenant system whose largest customers have very different usage, model per-segment and sum. The alternative is a model that is right on average and wrong exactly when a large tenant onboards. Multi-Tenant SaaS Architecture covers the per-tenant cost side of this.
Service demand is where most models quietly lose accuracy. The utilisation law, U = X · D, invites you to compute D as current CPU divided by current throughput. That mixes the fixed cost — GC, agents, health checks, idle connection churn, background compaction — into the per-request number, and then scales it with traffic as if it were marginal. Fit a line through hourly (throughput, CPU) samples instead. The slope is the marginal demand and the intercept is the fixed cost, and they belong in different parts of the model: the slope scales with the driver, the intercept scales with host count.
Fit only the linear range; the points past the bend are the Universal Scalability Law showing up (chapter 1) and belong to the headroom calculation, not to the per-unit demand.
Two more inputs decide whether the forecast is useful. The horizon is set by lead time, not by the planning calendar: if new capacity takes 12 weeks to procure, rack and qualify — or if a cloud quota increase or a reserved commitment needs a finance cycle — then a forecast shorter than that is a history report. And forecast at a quantile, not the mean. Ask the business for a plausible high case as well as the plan, provision against the high case for anything with long lead time, and keep elastic capacity for the rest. Then track forecast error per link in the chain. When the model misses, the chain tells you whether marketing, product, architecture or code was wrong, and that is the only way the model gets better.
Architect's note · the ratios are the contract
“Run at 70% CPU” is folklore with no derivation behind it. Headroom exists to absorb specific events, and each event has a size you can estimate. Start from the utilisation at which the binding resource hits the latency knee for your p99 target — chapter 1, Queueing Theory You Can Use, shows how to find it, and for many services it sits well below 100% CPU. Then divide by one factor per contingency. Losing one of three zones means the survivors carry 1.5×. A rolling deploy that takes 10% of hosts out is 1.11×. Forecast error on the peak is perhaps 1.1×. A zone evacuation lands traffic on hosts whose local caches and JIT profiles are cold, which costs more CPU per request for minutes — another 1.1× in this example.
Naive · everything at once
provision 1 ÷ 0.372 = 2.69× peak demand
Co-occurrence · worst plausible scenario
0.75 ÷ (1.5 × 1.1)
0.75 ÷ (1.11 × 1.1)
excluded: deploys halt during evacuation
binding scenario 45.5% → 2.20× · 18% fewer cores
The saving is bought with policy, not optimism: an automated deploy halt during zone evacuation and a cache-warming path are what make the scenarios mutually exclusive. Without the policy the naive column is the honest one.
Multiply everything and you get 37% at peak, which feels absurd and is why teams quietly ignore the calculation. The fix is to price only the contingencies that can actually happen together. Zone loss and cold caches are correlated: one causes the other, so they multiply. Zone loss and a deploy do not have to co-occur. Make deploys halt automatically during an evacuation — a policy that SRE / Reliability would want for blast-radius reasons anyway — and that pair drops out. Take the minimum across plausible scenarios rather than the product of all factors, and the target moves from 37% to about 45%, 18% fewer cores for the same risk. At fleet scale that is a budget line, bought with a runbook change.
Two further corrections are worth making, and they pull in opposite directions. First, the forecast-error factor is often double-counted. If 7.1 already provisions long-lead capacity against the business's high case rather than the plan, the error margin is in the demand number; dividing by another 1.1 prices the same uncertainty twice. Keep the factor only for the gap between the high case and what you are genuinely unwilling to miss. Second, the scenario minimum hides a joint-probability decision. “AZ loss at the high-case peak” is two tail events at once. If the high case is a one-in-ten outcome and a zone-level event in any given peak week is, say, a few percent, pricing both together is insuring against roughly a one-in-three-hundred week. That can be exactly the right call for checkout and an expensive one for an internal search index that can shed load instead. Write the chosen joint probability down per tier. It is the honest form of the “how much headroom” argument, and it converts a debate about percentages into a debate about which failures the business is willing to degrade through.
Two contingencies are routinely left out, and both show up as outages rather than slow pages. The first is degraded-mode capacity. Every fallback is a capacity promise. If the cache tier fails and requests fall through to the database, the database must survive the full miss rate, and at a 95% hit ratio that is 20× its normal read load. If it cannot, the fallback does not exist; you have a longer outage with extra steps. Either provision for it, shed load in front of it, or remove it from the design doc. The second is retry and recovery load. After a partial outage, queued work and client retries arrive together, and the recovery peak can exceed the organic peak. How Large Systems Actually Fail in the SRE track covers the metastable dynamics. For capacity purposes the question is simply whether the recovery peak was in the model.
The recovery arithmetic is short and routinely skipped. A 10-minute outage on a 700 rps queue-backed path leaves 420k items of backlog. The drain rate is the spare capacity, not the total: at a 1,000 rps ceiling that is 300 rps and about 23 minutes pinned at 100% busy, during which the queueing curve from chapter 1 says every synchronous caller sharing the tier is far past its p99. Cap the drain at 85% utilisation to protect live traffic and it takes ~47 minutes. Drain time scales as 1 ÷ headroom, so the team that trimmed headroom from 30% to 15% to save money has also doubled every future recovery. The retry term is worse because it is multiplicative: three client retries without a budget turn 700 rps of organic demand into 2,800 rps offered, and once offered load exceeds capacity on recovery, timeouts generate retries faster than the system serves them. That is the metastable state — hosts healthy, CPU saturated, goodput near zero — and no amount of headroom you would actually buy covers it. The capacity fix is a retry budget (retries capped at ~10% of requests per client) plus admission control that serves new work ahead of the backlog; the capacity model then only has to price the drain.
Headroom sets recovery time, not just peak safety: halve the spare capacity and the drain takes twice as long, during which p99 is blown for everyone. Without a retry budget, offered load after recovery exceeds capacity on its own and the system stays down with every host healthy.
0.75
knee utilisation (example)
× 1/1.5
N−1 of 3 zones
37% → 45%
naive → co-occurrence
20×
DB load if 95% cache dies
Pitfall · the autoscaler is not headroom
The criterion that decides whether autoscaling can cover a given event is one inequality: headroom ≥ ramp rate × lead time, where lead time is metric window + cooldown + provisioning + boot + warm-up, measured end to end. For a typical VM-based tier that sum is minutes, not seconds, and the warm-up term is the one teams omit — a JVM or a service with a local cache can take several minutes to serve at full per-host rate, so newly added capacity arrives at a fraction of its nominal size. Organic diurnal ramps are slow enough that a few percent covers them. A push notification to the whole user base, a TV spot or a ticket drop can ramp at tens of percent per minute, and no reactive target survives that; the answer is scheduled pre-scaling keyed to the marketing calendar, which means the 7.1 driver file needs launch dates, not just volumes. Anything faster than both belongs to load shedding, not capacity.
The autoscaler fired at minute 7.5 and was still late. What matters is not the target but the ratio of ramp rate to lead time: anything that ramps faster than headroom ÷ lead time must be pre-scaled or shed.
Most load tests answer a question nobody asked: how fast is this code on an empty database, behind mocks, under a uniform request mix, for twenty minutes? Every one of those simplifications removes a mechanism that decides real capacity. Coordinated omission and open-versus-closed load generation are covered in chapter 2, Measuring Latency Without Lying. The fidelity problems below remain even after the generator is correct.
Key distribution. Uniform random keys give a pessimistic cache hit ratio and never create a hot key. Production is Zipf-like, which makes the cache look better and a single partition look much worse. A test with uniform keys finds the wrong bottleneck. Data shape. A 20 GB staging database on a 64 GB host tests memory; the 2 TB production database tests disk and the buffer-pool eviction policy. Scaling the data down scales the physics away. Dependency latency. This one is subtle and very common. By Little's law, in-flight requests to a dependency equal rate × latency. At 5,000 rps a mock answering in 2 ms keeps 10 requests in flight; the real dependency at 40 ms median keeps 200, and far more during its own p99 excursions. A connection pool of 100 is fine against the mock and exhausted against production, so the test passes on a limit it never reached. Duration. Twenty minutes misses old-generation GC, cache TTL cliffs, compaction, certificate and token refresh, connection re-balancing and slow leaks. Run a soak test long enough to cover the longest periodic behaviour in the system.
Staging tests are safe and tell you about code. Only production tests tell you about the system. The last column is why you need both: the methods that find real limits are the ones that can hurt real users, so they need abort criteria wired to the SLO before they start.
The conclusion is uncomfortable but consistent across large operators: the methods that find the real limit run in production. Log replay fixes the mix but not the dependencies. Shadow traffic gets close, but it doubles load on everything downstream, and any write path has to be dropped or redirected, which changes what you are measuring. The highest-fidelity method is a squeeze test: shift live traffic weight at the load balancer so that fewer hosts serve the same users, and raise per-host load step by step until a health signal reaches a threshold. Facebook described running these tests routinely across its fleet in the Kraken paper (OSDI 2016). Nothing is synthetic, so every mechanism above is present by construction.
The output is a single number per host class — requests per second at the SLO — plus the name of the resource that bound it. The knee is already inside that number, so only the contingency factors from 7.2 apply on top. A CPU autoscaling target set at 70% would never have fired before this service breached.
A squeeze test needs three things before it is safe. It needs automated abort criteria tied to the SLO — p99 and error rate on the squeezed hosts, measured on a short window — not a human watching a graph. It needs small steps with a bake time at each, because queues and caches take minutes to reach a new steady state. And it needs a ceiling below the knee, since finding the exact knee in production means crossing it. The result is the number the capacity model in 7.1 was missing: requests per second per host at the SLO, measured, plus the name of the resource that bound it. When that resource is not CPU — a pool, a lock, a downstream quota — the CPU-based autoscaling target is wrong, and the test tells you by how much.
Squeeze tests fail in ways that make the number look better or worse than it is. Weights do not move long-lived connections. With HTTP/2 or gRPC channels pinned to backends, a load-balancer weight change affects only new connections, so the squeezed hosts see far less load than the weight implies until clients reconnect; either force connection recycling (max-age on the server side) or measure actual per-host rps rather than trusting the weight. Shared downstreams change the question. Squeezing one cluster of 20 hosts to 1.6× per-host load leaves total load on the database unchanged, so the test cannot find a limit that lives downstream — it measures the host class, not the system. A regional squeeze (drain one region into the others) is the version that exercises the shared tiers, and it is also a rehearsal of the zone-loss contingency in 7.2. Abort latency matters more than the threshold. If the abort signal uses a one-minute p99 window and the restore takes another minute, the test can spend two minutes past the knee, long enough to fill queues and trigger client retries that outlive the test. And squeezed hosts are warm hosts: the measured number is for a steady-state host, so it must not be reused as the capacity of a freshly booted one during an evacuation — that is exactly the cold-cache factor 7.2 prices separately.
Architect's note · the synthetic tenant
A budget turns “be fast” into a number with an owner. Start at the journey, where users feel latency, and allocate its p99 across the hops that serve it, each with a named owning team. Chapter 3, Tail Latency at Scale, covers deadline propagation at run time. The budget here is the planning version: the artifact that decides whether pricing may add a 60 ms call, and whose slack pays for it.
edge + TLS
platform
gateway / auth
platform
checkout svc
checkout
pricing
pricing
inventory
inventory
payment provider
external · contract
unallocated
journey owner
checkout svc · resource budget
Latency budgets are outcomes: noisy, only meaningful under load, known after the fact.
Resource budgets are inputs: near-deterministic per request, attributable to one commit, checkable in a unit test.
Keep ~10–15% of the journey unallocated and owned by the journey owner. It is the only currency for saying yes to the next feature without a renegotiation.
Allocating percentiles has a statistical trap that cuts both ways. For hops in series with smooth, independent latency distributions, the journey p99 sits below the sum of hop p99s, because hops rarely have a bad moment on the same request — so budgets that sum to the target are conservative. With correlated slowness (shared hosts, a GC pause, a noisy database) the p99s add almost exactly. The dangerous case is the sub-percentile stall. Suppose each of seven hops has a 0.5% chance of a 400 ms hiccup — a retry after a connection reset, a pool wait, a safepoint. Every hop meets its p99 budget, because 0.5% is below the 1% line. The journey hits at least one stall on 1 − 0.995⁷ ≈ 3.4% of requests, so the journey p99 is the stall, and the budget is blown by teams who are all green. Quantiles are not subadditive — the same reason Value-at-Risk fails as a risk measure. The practical rule: for a journey of k hops, budget each hop at roughly the 1 − 1%/k quantile (p99.85 for seven hops), not at p99, and derive the journey distribution from traces rather than from arithmetic before handing out slack.
Every hop is green on its own p99 in all three curves. P(≥1 stall) = 1 − (1 − p)ᵏ, so once k · p passes ~1% the journey p99 is set by events no hop's dashboard shows as a violation.
The more important point is that latency is the wrong thing to gate on at the service level. It is an outcome: noisy, dependent on load and neighbours, and measurable only after deployment. Pair every latency budget with a resource budget per request: CPU time, bytes allocated, database queries, downstream calls, response bytes. These are the inputs that cause the latency. They are nearly deterministic per request type, attributable to a single commit, and checkable in an ordinary integration test with a query counter and an allocation counter. A test asserting that the checkout handler issues at most six queries catches an N+1 at review time, which no latency dashboard will do until a large cart hits it in production. The CPU budget is the capacity model's D, so the budget file and the model share one number.
Web front ends have used this idea for years as bundle-size and render budgets enforced in CI. The back-end version is rarer because back-end teams think of performance as a load-test concern. It is not; most regressions are visible on a single request if you count the right things.
Pitfall · budgets with no exchange rate
The typical CI performance gate runs a benchmark a few times, compares the mean with the main branch and fails the build if it is more than 5% slower. It produces both kinds of error at once. It fires on noise, so engineers learn to re-run it until it passes. And it cannot see a real 2% regression, so those merge freely. The problem is not the threshold. It is that the minimum detectable effect of the setup was never computed.
MDE ≈ 2.8 · CV · √(2/n), normal approximation; with a t-test at n = 5 it is ~15% worse, at n = 3 about a third worse. The formula also assumes independent runs; runs on one host in one job are not, which is why interleaving baseline and candidate (ABAB…) on the same machine matters more than adding runs.
For a two-sided test at the usual confidence and 80% power, the smallest reliably detectable difference is about 2.8 × CV × √(2/n), where CV is the run-to-run coefficient of variation and n is runs per side. On a shared CI runner with 5% noise and five runs, nothing under about 9% is reliably visible. The same five runs on pinned bare metal at 1% noise see about 1.8%. Noise reduction is therefore worth more than extra runs: dedicated hosts, fixed CPU frequency with turbo disabled, pinned cores, an isolated benchmark process, and interleaved baseline and candidate runs on the same machine, so thermal and neighbour drift hit both equally. Even then, wall-clock benchmarks carry a floor of noise from sources nobody controls. Mytkowicz and colleagues showed at ASPLOS 2009 that changing environment-variable size or link order can move measured performance by amounts comparable to the optimisations being evaluated. A 3% “win” from an unrelated commit is quite likely a layout change.
This is why the most reliable gates count things rather than time them. Instruction counts from hardware counters or a simulator, allocation counts and bytes, syscalls, and query counts have run-to-run noise around 0.1%, so a 0.5% change is visible in a single run. The Rust compiler's performance tracking uses instruction counts as its default metric for this reason. The limitation is real: instruction counts miss cache misses, branch mispredictions and contention, so a change that cuts instructions but thrashes the cache looks like a win. Gate per-PR on counters. Track wall-clock on dedicated hardware post-merge, as a time series.
The other statistics failure is scale. A suite of 200 benchmarks, each tested at α = 0.05, raises about ten false alarms on a PR that changes nothing; engineers learn within a month that the red cells are noise. Either gate on a small set of pre-registered metrics tied to the budget file — a dozen, not hundreds — or control the false discovery rate across the suite (Benjamini-Hochberg is the usual choice) and report the rest as information, not as a failure. Tightening α alone does not fix it; it just moves the suite back toward detecting nothing.
Post-merge, stop comparing pairs and look for change points. A series of nightly results on main, analysed with a change-point algorithm, finds the commit where the level shifted even when each individual step was inside the noise. MongoDB published its use of E-Divisive change-point detection on CI performance data for exactly this reason: per-commit thresholds produced too many false alarms to be trusted. When a change point is found, bisect automatically across the commits in the window and open a ticket against the owning team with the benchmark, the size and the suspect commit.
2.8·CV·√(2/n)
min detectable effect
~9%
5 runs · CV 5%
~0.1%
noise on counters
1.005²⁴ ≈ 1.13
two 0.5% slips / month, 1 yr
Architect's note · ratchet the wins
CI sees code. A large share of real regressions have no code change in the service at all: a runtime or kernel upgrade, a library bump, a config change, a feature flag turned on for a larger cohort, a tenant whose access pattern is unlike anyone else's, or data growth that pushes a working set past memory. None of these shows up in a benchmark on main. They need production measurement, and each has a different detector.
Four shapes, four detectors. Steps at deploy time (A) are a canary problem. Steps with no deploy (B) need efficiency trended against data and traffic, not versions. Creep (dashed) is only visible as a change point on a long series. And a fix (C) is only a win if something stops the creep from spending it again.
For regressions that arrive with a deploy, the detector is the canary judge. Two details matter. Compare canary and baseline at the same time, on equally sized cohorts that receive the same traffic, not the new version against last week's numbers, because diurnal and mix changes swamp a 3% effect. Compare distributions, not averages: Netflix's Kayenta judge uses a Mann-Whitney U test per metric for this reason. The baseline should be a freshly deployed cohort of the old version, the same size as the canary, rather than the long-running fleet — Spinnaker's canary guidance recommends exactly this. Against the fleet, the canary is judged with cold caches and an unwarmed JIT, which biases it toward failing, and without the heap fragmentation and slow leaks of week-old processes, which biases it toward passing; the two errors do not cancel, they just make the verdict unreadable. And add an efficiency metric — CPU-ms per request, tagged by build — to the latency and error metrics the judge already checks. A canary that serves the SLO but burns 8% more CPU is a capacity regression that will not appear in any latency graph until the next peak.
For regressions with no deploy, trend efficiency against drivers. Plot CPU-ms per request, bytes read per query and cache hit ratio per endpoint over months, with change-point detection and an annotation layer carrying every deploy, config push, flag change and infrastructure upgrade. A step with no annotation is almost always data or traffic shape, which raises a measurement problem: aggregate CPU per request moves when the endpoint mix moves, even if no endpoint got more expensive. A campaign that doubles cheap product-page views can make the service look, say, 15% more efficient and masks a real regression in checkout underneath. Report efficiency as a fixed-weight index — per-endpoint CPU-ms weighted by a frozen reference mix, re-based quarterly, the way a price index holds its basket constant — alongside the raw ratio. When the raw ratio moves and the index does not, it is mix, and it belongs in the capacity model's product ratios. When the index moves, it is cost, and it belongs to the service team. A continuous profiler (chapter 4, Profiling in Production) turns “CPU per request rose 12% on the 8th” into a function-level diff between two weeks of profiles, which is the difference between a two-hour investigation and a two-week one.
Creep is the hardest shape. At 1% a month it is invisible to every per-change detector and adds up to 12–13% in a year — capacity you will buy at the next forecast without anyone deciding to buy it. The only defences are long-horizon change-point detection and the ratchet from 7.5. There is also an organisational one: a fixed, recurring slot where someone looks at the year-over-year efficiency chart and asks why.
Pitfall · the forecast miss is your last detector
Performance is a commons. Every team benefits from a fast shared platform, and each team's feature work spends a little of it. A team that adds 20 ms to shared middleware spends every other team's latency budget and pays none of the cost. Left alone, commons degrade. The habits that keep a fast system fast all address the same problem: making the cost visible to the person who incurs it, and making someone responsible for every number.
Give performance a price. Engineers make good trade-offs when they know the exchange rate. Convert CPU per request into money for each major service: at 50,000 requests per second, one extra CPU-millisecond per request is 50 busy cores. At a 45% target that is about 111 provisioned cores. At an illustrative $0.04 per core-hour, that is roughly $39,000 a year per millisecond. Publish that number next to the service dashboard. A 3 ms regression becomes a six-figure decision someone has to make on purpose. A two-day fix that saves 3 ms becomes easy to prioritise. Latency has a price too, in conversion and retention, but measure it in your own product with holdbacks or natural experiments. The latency-to-revenue figures that circulate at conferences are old, context-specific and rarely reproducible.
Two refinements keep the price honest. It is a marginal price, and it only applies where capacity binds. A service pinned at its minimum replica count for availability, or whose binding resource is a connection pool, saves nothing when CPU per request drops; quoting $39k for its milliseconds teaches engineers the number is theatre. Publish the price per service with the binding resource next to it, and zero where nothing binds. And a saving is realised only when cores are returned, a purchase is deferred or a commitment is shrunk. An optimisation that leaves the fleet the same size has bought headroom that the next quarter's features will spend silently. Close the loop explicitly: the efficiency win and the matching capacity reduction ship as one change, or the win is recorded as headroom, not dollars.
1 ms CPU
per request
× 50k rps
= 50 busy cores
÷ 0.45
≈ 111 provisioned
≈ $39k / yr
at $0.04 / core-hr (illustrative)
Split instruments from budgets. A central efficiency team pays for itself in two places. The first is the instruments: continuous profiling, benchmark hardware, change-point detection, per-service cost data. The second is the shared layers — RPC, serialization, compression, memory allocation, hashing, runtime flags — where one change pays off across the whole fleet. Google's ISCA 2015 study of fleet-wide profiles, Profiling a Warehouse-Scale Computer, called this the “datacenter tax” and found it took a large share of cycles across very different applications. The central team should not own product teams' budgets or fix their regressions for them. When it does, performance becomes someone else's job, and the central team is permanently behind.
The central team owns instruments and shared layers; it does not own anyone's budget. When it starts fixing product teams' regressions for them, the product teams stop owning performance and the central team becomes the bottleneck it was created to remove.
Run the rituals. The ones that matter are the ones that force a decision with a name on it: a weekly review of this week's change points, each closed as fix, revert, or accept-and-re-budget; a quarterly walk of the 7.1 chain with forecast error per link; and postmortems for capacity misses with the same rigour as outages. The ritual most organisations skip is the one that changes incentives: realised efficiency wins announced in the same channel as launches, with the dollar figure attached. Promotion committees read that channel. If they only ever see features, engineers learn which work counts.
Finally, stop letting a misquoted sentence set policy. Knuth's line about premature optimisation continues, in the same paragraph, “Yet we should not pass up our opportunities in that critical 3%”. The point was to measure first and then act on what matters, which is what everything in this track has been about. Teams use “premature optimisation” to dismiss any performance work that is not yet an incident, and so the only performance work they ever do is incident response.
Design review · questions a principal engineer asks
Track wrap-up · Performance Engineering & Tail Latency