Topic
Core engineering principles, debugging workflows, observability, performance basics, reviews, and practical operating habits.
Good entry points for this topic before browsing the full archive.
How CPU, GPU, and TPU architectures differ in ways that matter for databases and AI workloads — and which compute class to reach for when adding vector search, embedding generation, or GPU-accelerated analytics.
A DBA-friendly explanation of SIMD and SIMT using query execution, vectorized processing, and GPU mental models instead of hardware jargon.
How multi-version concurrency control lets readers and writers run without blocking each other — and why misunderstanding it causes table bloat, undo log growth, and stalled vacuums.
L2 and L3 posts with architecture, reliability, and tradeoff detail.
How to expand monitoring beyond uptime by building dashboards that expose underutilized RDS instances, EBS io2 waste, and backup retention drift.
Acknowledging a write before the system knows where the next read will land turns a clean product experience into a staleness bug that looks like data loss — how read-after-write consistency works and where it breaks under replica lag.
Rate limiting fails when the platform enforces one behavior while the product promised another to clients. The technical mechanism matters less than treating rate limits as a documented contract with defined scope, limits, and error semantics.
Consistent hashing is a damage-control mechanism for cluster membership change, not a general scalability strategy — what it limits during node additions and removals, and the tradeoffs that make it unsuitable as a universal sharding approach.
The most reliable distributed systems depend on an unimpressive table with a unique constraint and a saved response — how idempotency keys prevent double charges, duplicate events, and retry amplification at the database layer.
A cache is not a shield around the database — it is a second traffic control system whose failure mode is a synchronized stampede back to the database. How to design the miss path so cache failures don't become database incidents.
How to build an AI FinOps dashboard and choose between proxy-based and instrumentation-based observability.
A dashboard is not observability, and an alert without a specific action is just operational debt masquerading as monitoring.
How to expand monitoring beyond uptime by building dashboards that expose underutilized RDS instances, EBS io2 waste, and backup retention drift.
The difference between read committed, repeatable read, and serializable isolation in operational terms — and why most applications are running with weaker guarantees than engineers assume.
A DBA-friendly explanation of SIMD and SIMT using query execution, vectorized processing, and GPU mental models instead of hardware jargon.
How CPU, GPU, and TPU architectures differ in ways that matter for databases and AI workloads — and which compute class to reach for when adding vector search, embedding generation, or GPU-accelerated analytics.
How to build an AI FinOps dashboard and choose between proxy-based and instrumentation-based observability.
A dashboard is not observability, and an alert without a specific action is just operational debt masquerading as monitoring.
How to expand monitoring beyond uptime by building dashboards that expose underutilized RDS instances, EBS io2 waste, and backup retention drift.
The difference between read committed, repeatable read, and serializable isolation in operational terms — and why most applications are running with weaker guarantees than engineers assume.
A DBA-friendly explanation of SIMD and SIMT using query execution, vectorized processing, and GPU mental models instead of hardware jargon.
How CPU, GPU, and TPU architectures differ in ways that matter for databases and AI workloads — and which compute class to reach for when adding vector search, embedding generation, or GPU-accelerated analytics.
What CAP theorem actually says about distributed database tradeoffs, why the CP vs AP framing is more useful than the theory, and what it means for your system when the network fails.
The decision framework for choosing between a cache, a queue, and a database — including the failure modes that appear when engineers use the wrong one for the job.
How PostgreSQL estimates row counts, why those estimates are wrong for correlated columns and skewed distributions, and what engineers can do when the planner picks a bad plan.
Why a low-cardinality index is often worse than no index, how the query planner uses selectivity estimates, and when to build a partial index instead.
How to read PostgreSQL EXPLAIN output, what seq scan vs index scan actually means in practice, and the three numbers that matter most in any query plan.
Why PostgreSQL connections are expensive, what a connection pool actually does, and the difference between session mode, transaction mode, and statement mode in PgBouncer.
What replication lag actually measures in PostgreSQL, the three distinct lag components that most monitoring tools conflate, and which one matters for your RPO.
What a checkpoint actually does in PostgreSQL, why dirty page flush matters for recovery time, and what engineers should monitor to avoid checkpoint pressure.
The two mechanisms databases use to survive crashes — redo brings committed changes forward, undo rolls back uncommitted ones — and why the distinction matters operationally.
Why PostgreSQL and MySQL use B-trees while Cassandra and RocksDB use LSM trees — the read/write tradeoff that determines which storage engine fits your workload.
Acknowledging a write before the system knows where the next read will land turns a clean product experience into a staleness bug that looks like data loss — how read-after-write consistency works and where it breaks under replica lag.
Rate limiting fails when the platform enforces one behavior while the product promised another to clients. The technical mechanism matters less than treating rate limits as a documented contract with defined scope, limits, and error semantics.
Consistent hashing is a damage-control mechanism for cluster membership change, not a general scalability strategy — what it limits during node additions and removals, and the tradeoffs that make it unsuitable as a universal sharding approach.
What write-ahead logging is, why every ACID database uses it, and what engineers need to know about LSN ordering, crash recovery, and replication lag.
The most reliable distributed systems depend on an unimpressive table with a unique constraint and a saved response — how idempotency keys prevent double charges, duplicate events, and retry amplification at the database layer.
How multi-version concurrency control lets readers and writers run without blocking each other — and why misunderstanding it causes table bloat, undo log growth, and stalled vacuums.
A cache is not a shield around the database — it is a second traffic control system whose failure mode is a synchronized stampede back to the database. How to design the miss path so cache failures don't become database incidents.
A load balancer is not a pipe — it is a distributed state machine making routing and health decisions on stale, partial evidence. Its configuration choices propagate directly into application availability and failure modes.