Keying a Kafka topic by the obvious business id quietly capped our consumer throughput, and no number of extra consumers could lift it. A story about hot partitions and the ceiling you cannot scale past.

Comparing two continuously updating caches, equality is the wrong test, because the diff is never zero. You don't compare two live systems, you watch their differences converge.

A dual-key cache write wrapped in MULTI/EXEC is legal on one entity and illegal across a batch. The fix was not a workaround for atomicity, it was realizing the design never needed it.

A cache-seeding job joined two large query results in memory and kept running pods out of memory. The fix was not a bigger pod. It was noticing the rows were already sorted.

An API gateway validated the caller's token, then stripped the credential before forwarding, so the service behind it returned 401 on every request. The bug was not in either auth check. It was the missing contract between them.

The slowest part of a job that moved tens of millions of rows was a tiny lookup that returned one word. The bug was not the query. It was where the query lived.

A cache and its source of truth split after a deploy. The hash was not lying. We were, and the fix started by refusing to read the mismatches one at a time.

A standby is a database replaying another database's history in real time, and it is allowed to kill your read to keep up. Why 'canceling statement due to conflict with recovery' happens, and the two knobs that each cost you something.

We were handed a throughput number to hit. The real ceiling was concurrency, set by one request shape that did unbounded work, and no amount of capacity would have fixed it.

A load test reported a healthy service at a thousand requests a second, while measuring the one request that does no work. The bug was not a line of code, it was a posture, fail open instead of fail closed, and it showed up three separate times.

Every lookup was a cache hit, no misses, no database, and the endpoint still took a third of a second. The slowness wasn't the data; it was crossing the network forty times to fetch it. The N+1 problem, hiding one layer over from where everyone watches for it.