Backend

you fetch a list of fifty orders and then the ORM quietly issues fifty more queries, one per order, to load the customer.

N+1 queryBackend

the bug only shows up under load, never in tests, and the outcome depends on which of two threads got there first.

Race conditionBackend

you changed the row and now you have to hunt down every cached copy of it before someone reads the old one.

Cache invalidationBackend

the dependency got slow, everything retried, and the extra load is now the reason it cannot recover.

Retry stormBackend

the replica is forty seconds behind the primary and the report you generated from it is missing this morning's orders.

Replication lagBackend

the test fails one run in twenty, everyone reruns CI until it goes green, and the suite stops meaning anything.

Flaky testBackend

you measure the delay before the work starts moving, separately from how long the work itself takes.

LatencyBackend

you measure how many requests the system finishes per second, which is a different question from how long any one of them takes.

ThroughputBackend

the median request is 40ms, the 99th percentile is four seconds, and every page that fans out to ten services hits it.

Tail latencyBackend

you add three more identical instances behind the load balancer instead of making the existing one bigger.

Horizontal scalingBackend

one address takes all the traffic and spreads it across the instances, skipping the ones failing their health check.

Load balancerBackend

you reuse a fixed set of open database connections instead of paying the handshake on every query.

Connection poolBackend

you put one component in front of all the services to do auth, rate limiting and routing once instead of in each of them.

API gatewayBackend

you cap each client at a hundred requests a minute and start returning 429 once they go over.

Rate limitingBackend

your queries touch a handful of rows by key, thousands of times a second, and each one has to come back in milliseconds.

OLTPBackend

your query reads three columns across two billion rows and nobody minds if it takes forty seconds.

OLAPBackend

you store the customer's address in exactly one table so that changing it cannot leave four stale copies behind.

NormalisationBackend

you copy the customer's name into the orders table so the list page stops doing a join on every render.

DenormalisationBackend

you have to change the shape of a table that is being read and written right now, without stopping either.

Schema migrationBackend

you read a value another transaction had written but not committed, and then it rolled back and the value never existed.

Dirty readBackend

you read the row with its version, write it back only if the version has not changed, and retry the whole thing if it has.

Optimistic lockingBackend

you take a lock on the row up front with SELECT FOR UPDATE, so everyone else waits until your transaction ends.

Pessimistic lockingBackend

two transactions each hold a lock the other one needs and both sit there until the database kills one of them.

DeadlockBackend

you check the cache, miss, go and read the database yourself, and write the value back before you return it.

Cache-asideBackend

you let the cached value expire after a fixed number of seconds instead of trying to work out exactly when it stopped being true.

Time to liveBackend

the popular key expired and ten thousand requests all missed at the same instant and went straight through to the database.

Cache stampedeBackend

you point the reporting queries at a copy of the database so they stop competing with checkout traffic.

Read replicaBackend

one database stopped being enough, so you split the rows across several of them and now every query has to know which one to ask.

ShardingBackend

the network between your two datacentres broke and you had to decide whether to refuse writes or accept divergence.

CAP theoremBackend

every read is guaranteed to see the most recent committed write, so you never have to explain why the value went backwards.

Strong consistencyBackend

you write to one node, read from another a moment later, get the old value, and it is correct a second after that.

Eventual consistencyBackend

you push the slow job onto a queue and return to the user immediately, and a worker picks it up whenever it can.

Message queueBackend

you publish the event once and three different services each get their own copy without the publisher knowing they exist.

Publish-subscribeBackend

the worker processed the message, crashed before acknowledging it, and the queue handed the same message to somebody else.

At-least-once deliveryBackend

you can safely run the same operation five times and the system ends up in exactly the state it would after one.

IdempotentBackend

the client sends a unique id with the payment request so that retrying it cannot charge the card twice.

Idempotency keyBackend

the message failed five times so it gets moved somewhere else, instead of blocking the queue forever by being retried in a loop.

Dead letter queueBackend

the consumer tells the producer to slow down rather than silently buffering work it cannot keep up with.

BackpressureBackend

you give up on the call after two seconds instead of holding the thread open until the other side eventually answers or does not.

TimeoutBackend

after enough consecutive failures you stop calling the provider at all for a while, instead of queueing thousands of doomed requests behind a dead dependency.

Circuit breakerAI

the provider went down and users got a cached answer or an honest error, because you decided that in design rather than at 3am.

Graceful degradationAI

you trace the dependency graph and find one component whose failure takes everything else down with it.

Single point of failureBackend

you ship the code turned off, switch it on for yourself, then for one percent, then for everyone.

Feature flagBackend

you put the new build on the servers, which is a completely separate event from anybody actually using the new behaviour.

DeploymentBackend

you flip the flag and users start getting the new behaviour, on code that has already been running in production for a week.

ReleaseBackend

the deploy broke something so you put the previous version back rather than trying to fix forward under pressure.

RollbackBackend

you record a number over time so you can see the shape of the whole system at once without reading a single log line.

MetricBackend

you log an object with named fields instead of a sentence, so you can query on user id rather than grep for it.

Structured loggingBackend

you generate one id at the edge and stamp it on every log line the request produces anywhere in the system.

Correlation IDBackend

you follow one slow request across six services and see exactly which hop ate eight hundred milliseconds.

Distributed tracingBackend

you put latency, traffic, errors and saturation on one dashboard and stop trying to look at ninety graphs.

Golden signalsBackend

you commit internally to 99.9 percent of requests succeeding over 30 days, and you now have a number that says when to stop shipping features.

Service level objectiveBackend

you write up what happened focusing on why the system allowed it, not on who typed the command.

Blameless postmortemBackend