Backend & systems

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 query

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

Race condition

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

Cache invalidation

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

Retry storm

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

Replication lag

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

Flaky test

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

Latency

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

Throughput

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

Tail latency

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

Horizontal scaling

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

Load balancer

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

Connection pool

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 gateway

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

Rate limiting

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

OLTP

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

OLAP

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

Normalisation

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

Denormalisation

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

Schema migration

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

Dirty read

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 locking

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

Pessimistic locking

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

Deadlock

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

Cache-aside

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 live

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

Cache stampede

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

Read replica

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.

Sharding

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

CAP theorem

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

Strong consistency

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

Eventual consistency

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

Message queue

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

Publish-subscribe

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

At-least-once delivery

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

Idempotent

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

Idempotency key

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 queue

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

Backpressure

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

Timeout

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 failure

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

Feature flag

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

Deployment

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

Release

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

Rollback

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

Metric

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

Structured logging

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

Correlation ID

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

Distributed tracing

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

Golden signals

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 objective

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

Blameless postmortem