Deep dives into database internals, query optimization, schema decisions, and the trade-offs that shape how data systems actually work.
A timestamp column that looks fine in development can quietly shift by hours in production, merge two events into one during a DST change, or put a meeting at the wrong time after a government changes its clocks. Here's what your database actually stores, and how to choose between instants, wall times, and zones.
When COMMIT returns, your row usually isn't in the table file yet. It's a few bytes appended to a log. That log is why a database survives power loss, why replicas and point-in-time restores work, and why a forgotten replication slot can fill your disk. Here's how a write-ahead log works.
Adding a read replica is the easiest scaling win there is — until a user saves their profile, gets redirected, and sees the old values staring back. Replicas are always a little bit behind, and that gap isn't a bug you can fix. It's a property you design around.
You've maxed out the biggest instance your cloud sells. Read replicas help reads but every write still lands on one machine. Sharding splits your data across many databases — and hands you a new set of problems around shard keys, hotspots, and queries that can no longer see all your data at once.
Your database has plenty of CPU and memory to spare, but requests are timing out with 'too many connections' or hanging forever waiting for a pool slot. The pool that was supposed to make you fast is now the bottleneck. Here's why pools exhaust, and how to size them without guessing.
You added an index, ran EXPLAIN, and the planner still chooses a sequential scan. Here are the six most common reasons your database ignores your index -- and the exact fixes for each one.
Soft deletes sound safe -- just set a flag and the data is 'gone.' But they quietly introduce query complexity, unique constraint headaches, and storage bloat. Here's a clear-eyed look at both strategies and when each one actually makes sense.
Two users edit the same row at the same time. One strategy blocks the second user. The other lets both proceed and detects the conflict later. The right choice depends on your collision rate.
Your database has four isolation levels, each with different guarantees about what concurrent transactions can see. Most developers never change the default -- and that default might not be what you think.
OFFSET pagination seems simple until you have millions of rows. Here's why it degrades linearly, how cursor-based pagination stays constant-time, and when each approach makes sense.
Your API returns 20 items and fires 21 database queries. Here's exactly how the N+1 problem happens, why ORMs make it worse, and the three patterns that fix it for good.