Search the practice set
126 questions, 454 terms and 400 topics in 20 areas.
60 results for “Performance Budgets”
Application Performance Monitoring
Instrumentation inside the application that attributes latency and errors to specific code paths, queries and dependencies.
Bloom Filter
A compact probabilistic structure that answers "is this key definitely absent, or possibly present?" — no false negatives, tunable false positives.
Bloom Filter Cache Guard
Placing a Bloom filter in front of an expensive lookup so that keys which certainly do not exist never reach it.
Burstable Instance
An instance that provides a low baseline CPU allocation and accrues credits while idle, spendable for short periods of full performance.
Cache Invalidation
The problem of removing or refreshing cached data when the underlying source changes, and the reason caching is harder than it looks.
Caching Strategy
The chosen pattern for how a cache is populated, read and invalidated — cache-aside, read-through, write-through or write-behind.
Cardinality Estimation
The planner's prediction of how many rows each step of a query will produce — the input that determines every other choice it makes.
Concurrency
The number of operations in progress at once — distinct from parallelism, which is how many are literally executing simultaneously.
Connection Pool
A fixed set of reusable database connections shared by an application's requests, and one of the most common hidden capacity ceilings.
Covering Index
An index that contains every column a query needs, so the query is answered from the index without reading the table at all.
DORA Metrics
Four measures of software delivery performance — deployment frequency, lead time for change, change failure rate, and time to restore service.
Database Index
A secondary structure that lets the engine find rows without scanning, trading write cost and storage for read speed.
Denormalisation
Deliberately duplicating data across records to make reads cheap, accepting the write-time cost of keeping copies in step.
Error Budget Policy
The written agreement about what happens when the error budget is exhausted, which is what turns an SLO from a number into a control.
Google Maps and Planetary-Scale Spatial Serving
Map serving is fast because almost nothing is computed on request — the world is precomputed into a pyramid of tiles, and space is indexed onto a one-dimensional curve.
Hedged Request
Sending a duplicate of a request to a second replica after a short delay and using whichever response returns first, to cut tail latency.
Horizontal vs Vertical Scaling
Adding more machines versus making one machine bigger — and the fact that vertical is underrated for stateful tiers.
Indexing Strategy
Choosing the set of indexes a table carries by working backwards from its actual queries, and accepting the write cost that each one adds.
Join Strategies
The three ways a database combines two row sets — nested loop, hash join and merge join — and the conditions under which each is correct.
Little's Law
In a stable system, the average number of items in it equals the arrival rate times the average time each spends in it — L = λW.
Load Testing
Driving a system with realistic traffic at a target volume to verify it meets its performance targets before real users do.
Materialized View
A precomputed, stored result of a query, refreshed on a schedule or from a change stream, read instead of recomputing.
Partial Index
An index built over only the rows matching a predicate, so it is far smaller and cheaper to maintain than a full index.
Query Plan
The database's chosen strategy for executing a query, and the first thing to look at when one is slow.
Snapshotting
Periodically storing an aggregate's computed state so it can be loaded without replaying its entire event history.
Tail Latency
The latency experienced by the slowest small percentage of requests, which is what users and dependent services actually feel.
Throughput
The rate of work a system completes per unit of time — and a quantity that trades against latency rather than tracking it.
Twitter's Timeline Fan-Out
Twitter precomputes each user's timeline at write time but handles very-high-follower accounts at read time, because neither strategy alone survives both ends of the distribution.
A dashboard query that took 200ms now takes 40 seconds. The table has grown to 200 million rows. Walk me through diagnosis and fix, including what you would not do.
What the interviewer is testing Whether you diagnose with evidence before changing anything, and whether you know the costs of the fixes you propose. Diagnosis,
A product catalogue page does 40,000 reads per second against a database that can serve 5,000. Walk me through the caching design, including what happens at 3 AM when the cache is empty.
What the interviewer is testing Whether you can design a cache including its failure modes, rather than saying "put Redis in front of it". The base design Cache
A table has 14 indexes and writes have become slow. How do you decide which to remove?
The approach 1. Get usage statistics, not opinions. Every major engine reports index scan counts — PostgreSQL's pg stat user indexes , SQL Server's sys.dm db in
Peak trading day is six weeks away and expected to be four times normal traffic. What do you do in those six weeks?
What the interviewer is testing Whether you can run a readiness programme rather than just "add servers", and whether you know what fails at peak that does not
Precompute every user's timeline at write time, or assemble it at read time? Explain why the answer for a social feed is neither.
Why each pure strategy fails Fan out on read. Store each post once; on timeline load, query the posts of everyone the user follows and merge. Writes are trivial
Performance Budgets
Targets enforced in CI so regressions fail the build.
Application Performance Monitoring
Attributing latency to code paths, queries and dependencies.
Caching for Performance
Layer choice, hit ratio as a first-class metric, and cold-cache recovery.
Database Performance
Plans, indexes, contention and the pool in front of the database.
Error Budgets
Unreliability as a resource that feature velocity spends.
Network Performance
Latency floors, bandwidth-delay product, and what no code change fixes.
Network Performance Tuning
Keep-alive, compression, payload size and round-trip elimination.
Performance & Capacity
General material on performance and capacity engineering.
Performance vs Cost
Buying latency, and knowing what the last millisecond is worth.
Bottleneck Analysis
Finding the constraint, and expecting a second one behind it.
Capacity Modelling
Arithmetic before load tests, and headroom for failure as well as peak.
Concurrency
Operations in flight, and the limits that are the real capacity ceiling.
Connection Pooling
The most common hidden ceiling, and the metric nobody collects.
Cost Governance
Budgets, anomaly alerts, quotas and preventive policy.
Horizontal vs Vertical Scaling
Scale out for stateless, scale up first for stateful.
Latency
Distributions rather than averages, and the floors physics imposes.
Little's Law
L = λW, and the pool sizes it computes directly.
Load Testing
Realistic data, realistic mix, and a ramp rather than a step.
Peak Event Readiness
Freeze, pre-scale, shed order, warm caches and rehearse.
Profiling & Optimisation
Measuring before optimising, and optimising the dominant term.
Queueing Theory
Why latency explodes as utilisation approaches capacity.
Retries & Backoff
Exponential backoff, jitter, retry budgets, and how retries become the outage.
Soak Testing
Long runs that surface leaks and slow degradation.
Stress Testing
Pushing past target to learn what breaks first and how it fails.
Tail Latency
p99 behaviour, amplification across fan-out, and hedged requests.
Throughput
Work completed per unit time, and why it trades against latency.