---
tag: databases
articles: 26 · beats: 5
latest: November 17, 2026
---

Databases

26 Crashtech articles on Databases, spanning System Design & Architecture, Databases, Architecture, Database Engineering and Development Best Practices, published between March 2026 and November 2026. Every piece is full-text HTML with sources, structured data and an authored FAQ.

They span System Design & Architecture (17), Databases (4), Architecture (2), Database Engineering (2), Development Best Practices (1). System Design & Architecture Databases Architecture Database Engineering Development Best Practices

System Design & Architecture4 min

Database Performance is a Trade-Off Ledger: The Hidden Costs of Indexing, Caching, and Sharding

Why every database optimization creates a new liability: the hidden write costs of B-tree indexes, caching stale reads, and sharding operational taxes.

System Design & Architecture5 min

Eventual Consistency in Distributed Databases: Replication Lag, Conflict Resolution, and Tuning

Why modern distributed databases trade immediate sync for availability: replication lag, conflict resolution algorithms, PACELC theorem, and monotonic reads.

Architecture3 min

Event Sourcing in Practice: Immutable Logs, Temporal State Replay, and CQRS Projections

Why systems should remember how they got here, not just where they are: exploring Event Sourcing, append-only logs, snapshots, and CQRS projections.

System Design & Architecture4 min

The Scaling Ladder: How Nextdoor Evolved PostgreSQL Through Pooling, Replication, and Sharding

How Nextdoor scaled PostgreSQL from a single server to a multi-tiered architecture: PgBouncer connection pooling, read replicas, and horizontal sharding.

Databases5 min

Relational Database Design Guide: Keys, Relationships, Normalization, and Joins

A comprehensive guide to relational schema design, primary and surrogate keys, normal forms (1NF to BCNF), and indexing join performance trade-offs.

System Design & Architecture4 min

Strong Consistency in Distributed Databases: Linearizability, Raft Consensus, and Coordination Latency

What strong consistency actually costs in distributed systems: linearizability, Raft quorum consensus, physical latency floors, and failover boundaries.

System Design & Architecture5 min

Database Sharding: What It Actually Costs When You Split the Database

Sharding scales a database past one machine's limits, but it changes joins, transactions, and query patterns. Here's what each strategy trades away.

Technical diagram comparing B-Tree in-place page updates with LSM Tree MemTable, SSTables, and background compaction layers
Databases5 min

B-Trees vs LSM Trees: Storage Engine Trade-Offs and Compaction Mechanics

Compare B-Tree in-place updates against LSM Tree append-only storage engines: write amplification, Bloom filters, and compaction strategies.

Archivists route records from a divided city map to separate shelves, illustrating shard keys and data placement.
System Design & Architecture2 min

Database Sharding Guide: Horizontal Partitioning, Shard Keys, and Cross-Shard Joins

Why databases resist horizontal scaling: deep dive into database sharding, range vs hash vs directory strategies, cross-shard joins, and resharding.

Polyglot database architecture visualization with relational tables and vector point clouds
System Design & Architecture4 min

Database Types Guide: Storage Models, Access Patterns, and Polyglot Persistence

A practical guide to modern database types: relational, columnar, key-value, document, time-series, graph, and vector engines matching storage to workloads.

Colored keys on a physical ring shift only across a neighboring segment as a storage node is added.
System Design & Architecture5 min

Consistent Hashing: What Moves When a Node Joins or Fails?

Understand hash rings, virtual nodes, data movement and operational caveats through Dynamo, Cassandra and Redis Cluster's contrasting slot design.

Three separate server islands remain linked while engineers replace one storage node, illustrating Airbnb’s multi-cluster database design.
Development Best Practices4 min

Airbnb’s Database-on-Kubernetes Design: Availability Through Safer Replacement

Airbnb’s engineering team explains why it runs one database across three Kubernetes clusters and serializes node replacement to protect quorum.

An operator studies a MySQL failover board as a red-lit primary is switched to a healthy replica.
System Design & Architecture5 min

Inside Flipkart Altair’s MySQL Failover: Detection, Fencing, and Discovery

Flipkart’s Altair account shows why MySQL failover depends on false-positive checks, replica lag, fencing, and client rediscovery.

An on-call engineer traces how a regional service failure can reach a job queue and database pool.
System Design & Architecture4 min

GitHub’s October Outages Show Why Regional Failover Needs Isolation

GitHub’s October reliability report describes runner queues and a saturated database pool. Teams can turn those incidents into practical dependency tests.

System Design & Architecture3 min

What Actually Happens Between You Hitting Enter and Rows Coming Back

A SQL query passes through five stages before you see a row: connection, parsing, planning, execution, storage. What each does and where it breaks.

A maintainer studies a database storage module, schematic manual, and blank upgrade checklist before a major-version change
Databases3 min

PostgreSQL 19 Is Still an RC. Start the Upgrade Rehearsal

PostgreSQL 19 RC1 is not a production release. Review its maintenance and replication changes, then rehearse compatibility and rollback before the planned GA.

Database systems diagram contrasting Two-Phase Locking table locks with Multi-Version Concurrency Control undo log version pointers
Database Engineering4 min

Concurrency Control in Databases: Lost Updates, Locking, and Isolation Levels Explained

How concurrent transactions corrupt state: dirty reads, non-repeatable reads, phantom reads, pessimistic locks, and MVCC snapshot isolation.

System Design & Architecture5 min

What Actually Happens Inside a Database Index: The Data Structures

An index trades disk I/O for lookup speed. Here's how B-trees, hash tables, and bitmap indexes each make that trade differently.

System Design & Architecture6 min

Database Indexing Explained: Which Index Type Actually Fits Your Query

B-tree, hash, composite, and covering indexes each solve a different query shape. Pick the wrong one and you pay index overhead without the speedup.

System Design & Architecture6 min

Database Replication Explained: Single-Leader, Multi-Leader, and Leaderless

What replication lag actually breaks, and how single-leader, multi-leader, and leaderless models trade off consistency for availability.

System Design & Architecture7 min

Database Transactions Explained: ACID, Isolation Levels, and Concurrency Control

What ACID actually guarantees, and how pessimistic vs optimistic concurrency control decide whether your app locks or retries under load.

Step-by-step architectural migration diagram showing five-phase Expand and Contract pattern across live databases and mixed application versions
Database Engineering4 min

Schema Evolution Without Outages: Expand and Contract Migrations for Systems Running Mixed Versions

Why multiple schema versions run concurrently in production, and how five-phase expand-contract migrations prevent downtime.

System Design & Architecture7 min

LSM-Trees vs B-Trees: Why Cassandra Chose Sequential Writes

B-trees seek random disk positions. LSM-trees buffer in memory and flush sequentially, converting random I/O into sequential writes for millions of ops/sec.

System Design & Architecture6 min

Columnar Storage: Why Column Stores Beat Row Stores for Analytics

Columnar storage reads only needed columns, skipping the rest. Dictionary encoding shrinks data 50–100×. Analytics queries go from minutes to milliseconds.

Technical schematic comparing multi-tenant database isolation models: silo, shared schema, and cell-based architecture
Architecture2 min

Multi-Tenancy in Production SaaS: Shared Infrastructure vs Blast Radius

Master multi-tenancy design: compare separate databases, shared schema tenant IDs, and cell-based architectures to balance cost against blast radius.

Internal database query pipeline from SQL parser and optimizer to buffer pool and write-ahead log
Databases5 min

The Hidden Work Behind Every Database Request

What happens inside a relational database engine between issuing a SQL query and receiving rows: parsing, optimization, locks, and WAL logging.

Questions we answer about Databases

Frequently asked questions

What does Crashtech publish about Databases?

26 articles tagged Databases, the most recent published November 17, 2026. They span System Design & Architecture (17), Databases (4), Architecture (2), Database Engineering (2), Development Best Practices (1). Each carries numbered sources, an authored FAQ and full structured data.

What questions about Databases does Crashtech answer directly?

10 questions have a dedicated answer page under this tag, including “Why is sharding necessary when you could just scale up the database server?”. Each answer is authored prose from the article it belongs to, not a generated summary.

Can AI assistants read Crashtech's Databases coverage?

Yes. Crashtech serves full static HTML to every crawler, allows all major AI user agents in robots.txt, and publishes an llms.txt manifest plus a full-text corpus, so assistants can retrieve and cite these articles directly.