System Design — Page 7 of 21
Browsing page 7 of 21 — 243 articles on system design.
How Nginx Works: Event-Driven Architecture, Request Processing, and Reverse Proxy Mechanics
A deep dive into Nginx internals for senior engineers. Covers the master-worker process model, epoll/kqueue event loops, the request processing pipeline, reverse proxy upstream management with keepalive pools, load balancing algorithms, SSL termination, sendfile for static assets, and connection draining during graceful reload. Includes a tradeoffs table comparing Nginx, Caddy, HAProxy, and Envoy.
How Redis Works: Single-Threaded Execution, Data Structures, and Persistence Mechanics From Command to Disk
A deep dive into Redis internals covering the single-threaded event loop, core data structure implementations (SDS, skip lists, radix trees), RDB and AOF persistence, replication, pub/sub, and memory eviction policies with TypeScript client examples.
How DNS Works: Resolution, Caching, and Traffic Routing From Query to Response
A deep dive into DNS resolution covering the full recursive chain, record types and their production uses, TTL mechanics and negative caching, DNS-based traffic management strategies, DNSSEC, and practical guidance for startup engineering teams.
How TLS Works: Certificates, Handshakes, and the Trust Chain Behind Every Secure Connection
A deep dive into TLS 1.3: certificate chain validation, ECDHE key exchange, session resumption with PSK and 0-RTT, certificate transparency, and production considerations for rotation, pinning, and mTLS.
How Git Works Internally: Objects, References, and the DAG Behind Every Commit
A deep dive into Git's content-addressable object store, how branches are just files, how the DAG enables branching and merging, three-way merge and rebase mechanics, packfile delta compression, and what all of this means for reflog, garbage collection, and recovering lost work.
How Kubernetes Works Internally: The Control Loop, API Server, and Scheduler Behind Container Orchestration
Most engineers use Kubernetes daily without knowing what actually happens between kubectl apply and a running pod. This article covers the internals: how the API server processes requests, how etcd stores cluster state, how the scheduler assigns pods, and how controllers and the kubelet drive actual state toward desired state.
Designing a Database-as-a-Service Platform: Tenant Provisioning, Compute-Storage Separation, and Connection Routing at Scale
A deep technical walkthrough of how modern DBaaS platforms work under the hood: tenant provisioning and lifecycle management, compute-storage separation as the foundation for serverless databases, connection routing and pooling across thousands of tenants, backup orchestration with point-in-time recovery, noisy neighbor prevention, and the tradeoffs between shared-nothing, shared-compute, and serverless deployment models.
How a Database Executes a Query: Parsing, Planning, and Optimization from SQL String to Result Set
A deep technical walkthrough of how PostgreSQL transforms a SQL string into result rows, covering lexing, parsing, semantic analysis, cost-based optimization, join algorithm selection, scan type decisions, and the Volcano execution model.
The Strangler Fig Pattern: Incrementally Replacing Legacy Systems Without Stopping Feature Development
A practical guide to migrating legacy systems using the strangler fig pattern: routing proxies, anti-corruption layers, dual-write data strategies, CDC with Debezium, and a TypeScript implementation of an incremental traffic-shifting proxy.
Vector Clocks and Causal Ordering: How Distributed Systems Track What Happened Before What
A production-oriented explanation of why physical clocks fail in distributed systems, how Lamport timestamps and vector clocks solve causal ordering, and how version vectors and dotted version vectors handle conflict detection in replicated stores.
Designing a Distributed Counter: Sharded Writes, Approximate Reads, and Consistency Trade-offs at Scale
A deep technical walkthrough of distributed counter system design: why single atomic counters collapse under load, sharded write paths with rollup aggregation, CRDT-based G-Counters and PN-Counters, probabilistic structures like Count-Min Sketch and HyperLogLog, read-your-writes consistency, hot-key mitigation, and a tradeoffs table across accuracy, throughput, latency, and storage cost dimensions.
Designing a Presence System: Heartbeat Protocols, Distributed Session Tracking, and Scalable Online Status for Collaborative Applications
A deep technical walkthrough of production presence system design: heartbeat protocol tuning, Redis-backed distributed session tracking, pub/sub fanout across server instances, multi-device merging, last-seen computation, privacy controls, client-side batching to avoid render storms, and sharding to millions of concurrent users.