System Design — Page 5 of 21
Browsing page 5 of 21 — 243 articles on system design.
How Prometheus Works Internally: TSDB Storage, PromQL Execution, and the Pull-Based Architecture Behind Modern Monitoring
A deep dive into Prometheus internals covering the pull-based scrape model, TSDB head and persistent block architecture, WAL crash recovery, PromQL query execution pipeline, compaction, and the tradeoffs between Prometheus, Mimir, Thanos, VictoriaMetrics, Datadog, and InfluxDB.
How RabbitMQ Works Internally: AMQP Protocol, Exchange Routing, and the Quorum Queue Engine Behind Reliable Messaging
A deep dive into RabbitMQ internals covering the AMQP 0-9-1 channel model, exchange types and binding routing mechanics, classic queue vs quorum queue storage engines with Raft-based replication, credit-based flow control, consumer acknowledgment semantics and prefetch tuning, clustering and network partition handling, and a tradeoffs comparison table across RabbitMQ, Kafka, NATS, Amazon SQS, and Redis Streams.
How etcd Works Internally: Raft Consensus, MVCC Storage, and the Watch API Behind Kubernetes State Management
A deep dive into etcd's internals: how Raft achieves consensus through leader election and log replication, how the MVCC storage engine uses bbolt with revision-based versioning, how the Watch API delivers change notifications without polling, and what linearizability actually costs you in production.
How PostgreSQL Works: Storage Engine, MVCC, and the Query Planner Behind Every Production Database
A deep internals article covering how PostgreSQL stores data on disk, how MVCC enables concurrent transactions without locks, how the WAL enables crash recovery, how VACUUM reclaims dead tuples, and how the query planner picks execution strategies. With SQL examples and production tuning guidance.
How SQLite Works Internally: The B-Tree Storage Engine, WAL, and Why It Powers More Devices Than Any Other Database
A deep dive into SQLite internals covering the single-file architecture, the pager and VFS stack, table and index B-trees, WAL vs rollback journal concurrency, the VDBE bytecode virtual machine, and practical production patterns for edge deployments and Litestream replication.
How Cassandra Works: Wide-Column Storage, Gossip Protocol, and Tunable Consistency From Write Path to Compaction
A deep dive into Apache Cassandra internals: the wide-column data model, write and read paths, compaction strategies, gossip protocol, consistent hashing with vnodes, tunable consistency, replication, hinted handoff, and anti-entropy repair. With TypeScript examples and a tradeoffs table.
How MySQL Works Internally: InnoDB Storage, Buffer Pool, and the Redo Log Behind the World's Most Popular Open-Source Database
A deep dive into MySQL/InnoDB internals: the clustered index B+ tree storage engine, the buffer pool and adaptive hash index, undo log-based MVCC, the redo log and doublewrite buffer for crash recovery, the query optimizer, and GTID-based replication.
How ClickHouse Works: Columnar Storage, Vectorized Execution, and the MergeTree Engine Behind Real-Time Analytics
A deep-dive into ClickHouse internals for senior engineers: columnar storage mechanics, the MergeTree engine family, vectorized query execution with SIMD, materialized views, replication via ClickHouse Keeper, and when ClickHouse is the right choice versus alternatives.
How PostgreSQL Works Internally: Storage, MVCC, Query Planning, and the WAL
A deep dive into PostgreSQL internals: heap-based storage with page layout and TOAST, MVCC tuple versioning and vacuum mechanics, the query planner's cost model, and the write-ahead log for crash recovery.
Event-Driven Architecture in Practice: Message Brokers, Event Sourcing, and the Trade-offs Nobody Warns You About
A deep dive into event-driven architecture covering message broker mechanics for Kafka, RabbitMQ, and SQS/SNS, event sourcing with event store design and projection rebuilds, CQRS, saga patterns for distributed transactions, delivery semantics, dead letter queues, idempotency, backpressure, and concrete anti-patterns where EDA is the wrong choice.
Designing a Reservation and Booking System: Inventory Holds, Double-Booking Prevention, and Concurrency Control for Time-Slotted Resources
A deep dive into time-slot data modeling, double-booking prevention with optimistic and pessimistic locking, hold-then-confirm two-phase flows, waitlist management, timezone handling, and overbooking compensation logic for production booking systems.
How gRPC Works: Protocol Buffers, HTTP/2 Framing, and Bidirectional Streaming From Service Definition to Wire Format
A deep dive into gRPC internals: Protocol Buffer varint encoding and field tags, HTTP/2 frame structure and multiplexing, all four RPC communication patterns with TypeScript, deadline propagation, load balancing strategies, interceptor chains, and production considerations for health checking, reflection, and debugging with grpcurl.