Things I ran into and had to work out. Mostly Rails, Postgres and background jobs, usually written up because I'd have wanted to read it six hours earlier.
Eleven seconds of spinner became 400ms to first token with no speedup at all. Server-sent events over ActionCable, the SSE frame-splitting bug everyone ships, and the capacity arithmetic that breaks when a request holds a thread for eleven seconds.
34% of search sessions ended right after a back navigation and nobody filed a bug. The URL is the only state the browser can restore, and restoring scroll position needs the content to exist first.
24 vCPUs at 11% utilisation, and requests still queueing. Puma workers versus threads under the GVL, the connection-pool arithmetic that autoscaling breaks, and how CFS quota throttling hides behind a healthy-looking average.
Schema-per-tenant makes DDL O(tenants), and at 1,412 tenants a nullable boolean took fifty minutes and left the fleet half-migrated. What row-level security actually buys you, and how I'd choose now.
118 controlled fields, one state object, and 70ms per character on a five-year-old laptop. Why I stopped reaching for memoisation, when uncontrolled inputs are correct, and the profiler setting that made the bug visible at all.
The dashboard said 240ms; support had a video of eleven seconds. You cannot average percentiles, queue time is invisible from inside a request, and fan-out turns a 1% tail into one page load in five.
Their client timed out at 30 seconds, ours completed the charge at 31. A timeout tells the caller nothing, so every mutating endpoint owes them a way to retry safely. The unique index does the arbitrating.
Thirty archived threads came back after a tunnel. Optimistic updates are a promise, and rollback needs a snapshot rather than a reverse operation — plus the missing fetch timeout that made every error handler unreachable.
We cached a 900ms endpoint and the database hit 100% CPU for the first time. Cache stampedes scale with your traffic, stale-while-revalidate is usually the answer, and averages hide the trade you just made.
`rename_column` runs in 8ms and breaks every container still on the previous release. Expand and contract, why removing a column is more dangerous than adding one, and the list of migrations I check before shipping.
Scaling from one container to four sent 3,100 customers four copies of the same email. Singleton work in a multi-container deployment: dedicated schedulers, Postgres advisory locks, Kubernetes CronJobs, and why none of them are the actual fix.
The sidebar showed the old name until reload. Eleven copies of the same database row, each fetched independently, and the distinction between client state and a cache of someone else's data.
Twenty-three orders refunded twice, found by a finance spreadsheet eleven days later. A read-modify-write race that reads as obviously correct, and why wrapping it in a transaction fixes nothing.
Nine aggregate tiles, nine table scans. Why page caching made it a correctness argument, why counter caches couldn't help, and how one materialized view with filtered aggregates got it to 40ms.
Fixing an N+1 dropped the query count from 501 to 2 and made the page four times slower. Why object allocation beats query count, and how `includes` silently switches between two completely different strategies.