17 articles tagged with "databases"
Your database commit succeeded. Your Kafka publish failed. Now what? The transactional outbox pattern fixes the dual-write problem that every 'just publish an event after saving' tutorial conveniently skips.
DELETE FROM users WHERE id = 42 feels satisfying right up until legal, support, and future-you all ask where that row went. A field guide to soft deletes, hard deletes, and the audit tables that actually save you.
Shared schema, schema-per-tenant, or database-per-tenant? A practical tour of multi-tenancy strategies, the tradeoffs nobody puts on the slide, and the row-level security trick that saves you from your own ORM.
Connection pools were invented to stop you from opening a new database connection per request. Serverless functions spin up a fresh process per request. These two ideas do not get along, and Postgres will tell you so at exactly 2am.
OFFSET pagination works beautifully in every demo and every code review, right up until a customer scrolls far enough to bring your database to its knees. Here's why, and what to do instead.
EXPLAIN ANALYZE is your database confessing exactly what it did and why it took so long. Most engineers run it, see a wall of text, and close the tab. Here's how to actually read the confession.
You write to the database, then publish an event. What happens when the process dies between those two lines? The outbox pattern is the boring, reliable answer to a problem every event-driven system eventually hits.
You save a profile, refresh the page, and your old bio is back. Nobody deleted your change — it's sitting happily on the primary. Your GET request just talked to a replica that hasn't caught up yet. Welcome to read-your-writes consistency, the bug that only shows up in production.
Your monolith had ROLLBACK. Your microservices don't. The saga pattern is how you fake a distributed transaction using nothing but events, compensating actions, and the quiet acceptance that everything is eventually consistent.
Most databases only store the current state — the last write wins and history vanishes. Event Sourcing flips this on its head: store what happened, derive what is. Here's how to apply it without drowning in ceremony.
OFFSET-based pagination sounds innocent until your table hits a million rows and your database starts full-scanning just to skip the first 50,000. Here's why cursor-based pagination is the fix your API deserves.
CQRS separates the commands that mutate state from the queries that read it — giving you independent scaling, specialized models, and saner codebases. Here's when it's worth the complexity and when it's overkill.
Hardcoded fixtures make your tests brittle and your seed files a nightmare to maintain. Factories generate realistic, varied test data on the fly — here's why your test suite needs to make the switch.
Your dashboard says 45ms average. Your users say the app feels sluggish. Both are telling the truth — your average is just hiding the tail. Here's how to measure, diagnose, and tame P99 latency before it chases users away.
Your API feels fine until it doesn't. The N+1 query problem is the most common database performance bug in ORM-heavy backends — and it hides in plain sight until your database is on fire.
Deleting a database row sounds trivial — until your boss asks why the customer record vanished and nobody knows. Here is how to pick the right deletion strategy before a production incident forces your hand.
OFFSET pagination feels intuitive until your database is scanning 500,000 rows to serve page 100. Cursor-based pagination fixes the performance cliff, ghost records, and duplicate entries in one shot.