beat: system-design
articles: 27 · answers: 135
latest: September 1, 2026
---
System Design
Articles about system design.
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.
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.
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.
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.
The Google Cloud Outage That Started With One Missing Null Check
One unprotected code path in Google Cloud's Service Control took down Spotify, Discord, and Cloudflare auth in minutes. Here's the anatomy of the failure.
Why Google Maps Computes Shortcuts Offline
Contraction Hierarchies precomputes shortcut edges offline so routing queries skip neighbourhood streets and touch only 2,000 nodes in under 10 milliseconds.
CRDTs: Conflict-Free Collaboration at 60fps
Every user edits a local replica; operations merge automatically into an identical state regardless of arrival order, with no central locking.
Why Uber Tiles the Planet in Hexagons
Hexagons with equidistant neighbors replace lat/long trigonometry with O(1) table lookups for finding nearby drivers and calculating surge pricing.
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.
Count Billions in 12 Kilobytes
HyperLogLog estimates cardinality by reading leading zeros in hashed values, trading 1% error for fixed memory.
Merkle Trees: How Git Detects Changes in Milliseconds
Git hashes files into nested cryptographic trees to skip unchanged directories in one comparison, finding changes across millions of files faster than scanning.
Bloom Filters: The One-Way Membership Test
A probabilistic data structure: zero false negatives, tunable false positives. Check membership in RAM with bits instead of database queries.
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.
Optimistic UI: The Illusion of Instant
Apply mutations locally and reconcile in the background, collapsing perceived latency from 150 ms to instant. Rollback, idempotency keys, offline queues.
The Inverted Index
A sorted dictionary mapping terms to document IDs. Transform search from O(corpus size) to O(1) lookup, enabling full-text search at scale.
How Linux RCU Unlocks Read-Side Scaling
RCU lets millions of readers run lock-free while a single writer updates state by copying, mutating off-to-the-side, and atomically flipping a pointer.
When 87% of Your Cache Vanishes
Consistent hashing maps nodes and keys to a circle, so adding a server moves only 1/N of keys instead of almost all of them.
Copy-on-Write Snapshots
fork() shares parent memory, copying only written pages for non-blocking snapshots. Write-heavy loads can spike memory to 2x under load.
Why Raft Consensus Prevents Split-Brain
Raft ensures only one partition can reach quorum, making split-brain impossible. Writes commit to majorities. Powers etcd and CockroachDB.
Token Buckets: Bounding Rate Limits at the Edge
Fixed-window counters leak at boundaries. Token buckets refill steadily, absorb bursts, and bound the sustained rate strictly—the algorithm Stripe uses.
Time-Travel Fairness: How Servers Rewind for Lag Compensation
Why lag compensation rewinds the game world to when a shot was fired, and why victims experience the cost.
The CAP Theorem Is Not a Menu
Network partitions force a hard choice: refuse writes (CP) or accept and diverge (AP). Why the two-of-three myth is wrong, and what PACELC really tells us.
Why Raft Won: Consensus Built for Humans
Paxos is correct but hard to understand; Raft made consensus explicit. Same guarantees, different adoption. Why comprehensibility matters in algorithms.
Tries: Why Autocomplete Doesn't Scan Every Word
A trie finds all words with a prefix in O(p) time, independent of dictionary size. Radix compression and top-k heaps make autocomplete instant.
Skip Lists: The Shortcut Nobody Rotates
Balanced trees rebalance with rotations. Skip lists layer express lanes with random promotion—same O(log n) search, simpler locking.
Vector Clocks: Detecting Causality in Distributed Systems
Vector clocks solve distributed ordering: when wall-clock timestamps fail to detect concurrent writes, vector clocks reveal true causality and conflicts.
Operational Transforms vs CRDTs
Why Google Docs needs a server and Figma doesn't: how two competing approaches to concurrent editing resolve the same-string conflict, and when each wins.
Questions we answer on this beat
- Why does an index's internal data structure matter if it all ends up 'faster than a scan'?
- Why is disk I/O the thing index structures are actually optimizing for?
- Why can't a hash index handle range queries?
- What makes a bitmap index different from a B-tree, and when is it better?
- Why do B-trees stay balanced automatically as data is inserted?
- Why does a database need an index at all — why can't it just scan the table?
- When is a hash index better than a B-tree index?
- What is a composite index and why does column order matter?
- What's a covering index and why is it faster than a normal index?
- What's the real cost of adding an index, beyond disk space?
- Why do databases replicate data instead of just running on one powerful machine?
- What is replication lag and why does it matter?
Entities on this beat
Frequently asked questions
How many System Design articles has Crashtech published?
27 articles on this beat, the most recent published September 1, 2026 and the earliest July 30, 2026. 135 questions have a dedicated answer page with an authored direct answer.