4 min read
Designing Chat Presence: Online, Away, and the Lie of Instant Status
Heartbeat vs subscriptions, fan-out of presence, privacy, and why a boolean online flag does not survive a million concurrent sockets.
Tag
System Design
Scalable system design notes: storage, queues, consistency, and the trade-offs that show up in interviews and production.
86 articles
5 min read
Consistency Models Beyond CAP: Linearizability, Causal, and Session Guarantees
'Strong vs eventual' is a cartoon. The real spectrum — linearizable, sequential, causal, session guarantees — and how to pick per operation, not per system.
5 min read
Designing an API Gateway: The Front Door as a System
Authentication, routing, rate limits, transformations, and a plugin chain — in a tier that must add ~1ms and never be the outage. Envoy/Kong architecture from scratch.
5 min read
Designing a CDC Pipeline: Change Data Capture from Binlog to Downstream
Dual writes are a lie; the database's own log is the truth. Log-based CDC, the snapshot-plus-stream handoff, schema evolution, and ordering guarantees that survive resharding.
5 min read
Designing a Content Moderation Pipeline: Trust and Safety at Platform Scale
A billion uploads a day, a legal requirement to act in hours, and irreversible mistakes in both directions: hash matching, classifier tiers, human review queues, and appeals.
5 min read
Designing a Distributed Rate Limiter: Local Buckets, Global Truth
One user, twenty gateway nodes, one limit of 100 req/s. Where does the counter live? Redis+Lua atomicity, the local-cache compromise, and failing open vs closed.
5 min read
Designing a Durable Workflow Engine: How Temporal Makes Code Survive Crashes
Event-sourced workflow state, deterministic replay, task queues with sticky caches, and why 'just write normal code' is the hardest API promise in infrastructure.
5 min read
Designing an Experimentation Platform: Assignment, Exposure, and the Stats Engine
A/B testing at company scale is a systems problem: deterministic bucketing, exposure logging as the source of truth, overlapping layers, and guardrails that auto-stop bad launches.
5 min read
Designing Facebook TAO: A Read-Optimized Store for the Social Graph
A billion reads per second over friends-of-friends: why Facebook put a graph API on MySQL shards, two cache tiers, and chose 'read your own writes' over strong consistency.
5 min read
Designing a Feature Store and Model Serving Platform
The gap between a trained model and a production one is plumbing: online/offline feature parity, point-in-time training data, low-latency serving, and safe model rollouts.
5 min read
Designing an LSM Storage Engine: Memtables, SSTables, and Compaction
Why RocksDB, Cassandra, and half of modern databases buffer writes in memory and merge files forever: the LSM tree, read/write/space amplification, and compaction strategy.
5 min read
Designing a Metrics System: Time-Series Storage from Gorilla to Downsampling
Ten million series, one datapoint each per 10 seconds, queried by tags: delta-of-delta compression, the inverted index over labels, and why high cardinality kills TSDBs.
5 min read
Designing Petabyte Log Search: Index Everything vs Grep Smarter
Logs are 100x your metrics volume and queried 0.001% as often. The Splunk-style full index, the Loki-style label-only bet, and bloom-filtered brute force in between.
5 min read
Designing Real-Time Fraud Detection: Scoring Inside the Payment Path
80 milliseconds to decide if a transaction is stolen money: streaming features, rules plus models, the decision ladder, and feedback loops with week-late labels.
5 min read
Designing a Real-Time Leaderboard: Sorted Sets, Sharded Top-K, and Rank Queries
Top-10 is easy; 'what's my rank among 300 million players' is not. Redis sorted sets, the skip list underneath, sharded merges, and approximate ranks at scale.
5 min read
Designing a Real-Time OLAP System: Segments, Ingestion, and the Druid/Pinot Shape
Sub-second aggregations over billions of fresh events: the segment lifecycle from stream to deep storage, scatter-gather brokers, and pre-aggregation trades.
5 min read
Designing Recommendation Infrastructure: Candidates, Ranking, and the 100ms Funnel
You cannot score a billion items per request. The retrieval-ranking funnel, two-tower models with ANN indexes, feature freshness, and the feedback loop that eats itself.
5 min read
Designing a Secrets Manager: Sealing, Dynamic Credentials, and the Root of Trust
Where does the key that encrypts the keys live? Vault-style seal/unseal, short-lived dynamic secrets, encryption-as-a-service, and surviving your own compromise.
5 min read
Designing Typeahead Autocomplete: Sharded Tries and Precomputed Top-K
Every keystroke is a query with a 100ms deadline. Why autocomplete precomputes its answers, how to shard a trie, and keeping suggestions fresh without rebuilding the world.
5 min read
Designing a Web Crawler: The Frontier, Politeness, and Dedup at Billions of Pages
A crawler is a BFS where the graph fights back: URL frontier design, per-host politeness, content fingerprinting, and the traps that ensnare naive crawlers.
5 min read
Designing a WebSocket Gateway: 100 Million Persistent Connections
Request-response scaling wisdom fails when connections never close. Connection registries, deploys that don't disconnect the world, and the reconnect stampede.
5 min read
Designing YouTube: Upload, Transcoding Pipelines, and Adaptive Bitrate
500 hours of video uploaded per minute, played back on everything from fiber to 3G: DAG-based transcoding, segment-level parallelism, and how ABR actually works.
5 min read
Designing a Distributed Lock Service: ZooKeeper and Chubby from the Inside
Everyone uses the lock service; few could build it. Sessions and ephemeral nodes, watches without thundering herds, the sequencer trick, and why coarse locks won.
5 min read
Distributed Snapshots: How Flink Checkpoints a Moving Stream
You can't pause a pipeline to photograph it. Chandy-Lamport's marker trick, aligned barriers, and how a consistent snapshot of an always-running system actually gets taken.
4 min read
Lakehouse Table Formats: How Iceberg and Delta Put ACID on Object Storage
S3 doesn't do transactions, yet Iceberg tables commit atomically. Snapshot trees, manifest pruning, optimistic concurrency on a pointer swap, and why Hive-style directories died.
5 min read
Load Balancing Deep Dive: L4 vs L7, Power of Two Choices, and Subsetting
Round-robin is where load balancing starts, not ends: consistent-hash LBs, P2C beating least-connections, deterministic subsetting, and the cold-start herd.
5 min read
Multi-Region Active-Active: Patterns for Serving Writes from Everywhere
Active-passive wastes a region and fails over badly; active-active must answer 'who owns this write?' Region pinning, conflict surfaces, and the failover you actually rehearse.
5 min read
Multiplayer Game Networking: Authoritative Servers, Prediction, and Lag Compensation
Sixty ticks a second, 80ms apart, and everyone must agree who shot first: client prediction with rollback, snapshot deltas, interest management, and the favor-the-shooter bargain.
5 min read
Percolator: Distributed Transactions Without a Transaction Server
Google needed multi-row transactions on Bigtable and refused to build a coordinator service. Percolator's answer — locks as data, a primary row as the commit point — powers TiDB today.
5 min read
Probabilistic Sketches: HyperLogLog, Count-Min, and t-Digest in Production
Count a billion distinct users in 12KB, find heavy hitters in a stream you can't store, and merge p99s across shards — the three sketches every large system quietly runs on.
5 min read
SWIM, Gossip, and Phi-Accrual: How Clusters Know Who's Alive
Failure detection is the problem under every other distributed problem. Heartbeats that don't scale, SWIM's indirect probes, phi-accrual suspicion, and lifeguard refinements.
5 min read
Designing Ad Click Aggregation: Exactly-Once Counting at Scale
Billions of clicks, billed to the cent: streaming aggregation with watermarks, dedupe, idempotent sinks, and lambda-style reconciliation.
5 min read
Designing a CDN: Cache Hierarchy, Invalidation, and Request Routing
How a CDN actually works: edge PoPs, origin shields, consistent-hash cache keys, purge fan-out, and the anycast vs DNS routing decision.
5 min read
Designing a Distributed Cache Service: Redis Cluster Internals and Hot Keys
Build the cache, not just use it: slot-based sharding, gossip and failover, eviction under memory pressure, and the hot-key problem that shards can't solve.
5 min read
Designing Dropbox: File Sync with Chunking, Delta Sync, and Conflicts
Content-addressed chunks, delta sync, metadata vs block servers, and why 'last writer wins' is the wrong answer for file conflicts.
5 min read
Designing Google Docs: Real-Time Collaborative Editing with OT and CRDTs
How do 50 people type into the same document without corrupting it? Operational transformation, CRDTs, and the server architecture that makes co-editing work.
5 min read
Designing Kafka Itself: The Distributed Log, ISR Replication, and Compaction
Not how to use Kafka — how to build it: partitioned append-only logs, in-sync replica sets, high-watermarks, zero-copy reads, and log compaction.
5 min read
Designing Nearby Friends: Real-Time Location Sharing at Scale
Millions of users broadcasting location every 30 seconds, each visible only to friends: pub/sub fan-out, ephemeral state with TTLs, and the privacy-first data model.
5 min read
Designing an Online Judge: Sandboxed Code Execution at LeetCode Scale
Run a million strangers' untrusted programs a day without letting one of them own your fleet: sandbox layers, judge workers, resource limits, and contest-spike architecture.
5 min read
Designing an S3-Style Object Store: Erasure Coding and the Metadata Layer
Eleven nines of durability, exabyte scale: separating the metadata plane from immutable data blobs, erasure coding vs replication, and repair as a first-class workload.
4 min read
Designing a Stock Exchange: The Low-Latency Matching Engine
Order books, price-time priority, single-threaded matching, and deterministic replay — how exchanges match millions of orders with microsecond latency.
5 min read
Designing Ticketmaster: Booking, Inventory Holds, and Write Contention
Taylor Swift goes on sale and 500K people want the same 500 seats. Seat holds with TTLs, contention control, virtual queues, and never selling seat 14B twice.
5 min read
Designing Uber: Ride Matching, Live Location, and Surge Pricing
A million drivers moving every 4 seconds, matched to riders in under 10: geosharded in-memory indexes, dispatch as a distributed transaction, and surge as a control loop.
5 min read
Designing a Distributed Tracing Backend: Dapper-Style Sampling and Storage
Tracing every request would need a system bigger than the one being traced. Head vs tail sampling, span ingestion pipelines, and storage laid out for trace reads.
5 min read
Designing a Dynamo-Style KV Store: Quorums, Hinted Handoff, and Vector Clocks
The always-writable database: sloppy quorums, R+W tuning, vector clocks vs LWW, read repair, anti-entropy with Merkle trees — the machinery behind Cassandra and Riak.
5 min read
Designing Google Maps Routing: Contraction Hierarchies, Tiles, and ETA
Dijkstra on a planet-sized graph would take seconds per query. Precomputed hierarchies answer it in milliseconds — plus map tiles and the live-traffic ETA loop.
4 min read
Designing a Spanner-Style Global Database: TrueTime and External Consistency
How Google Spanner gives serializable transactions across continents: TrueTime's bounded clock uncertainty, commit-wait, Paxos groups, and 2PC on top.
6 min read
Database Replication: Leader-Follower, Quorums, and the Lag Nobody Budgets For
Sync vs async replication, why failover loses writes, and how quorum systems skip the leader entirely. The trade-offs that set your durability story.
5 min read
Sharding a Database: Partition Strategies That Survive Growth
Hash vs range partitioning, choosing a shard key you won't regret, the hot-partition problem, and why cross-shard queries are the real cost of sharding.
5 min read
Designing a Distributed Job Scheduler That Doesn't Fire Twice (Usually)
Delayed jobs, cron at scale, and work claiming with SKIP LOCKED. Why every scheduler promises at-least-once and what that forces on your handlers.
5 min read
Designing a News Feed: Fan-Out on Write vs Fan-Out on Read
Precompute every follower's timeline or assemble it per request? The celebrity edge case that breaks the pretty answer, and the hybrid everyone ships.
5 min read
Designing a Payment System: Double-Entry Ledgers and Idempotent Money
Why 'UPDATE balance' is a bug, how double-entry bookkeeping becomes a schema, and the idempotency and reconciliation machinery that keeps money honest.
5 min read
Distributed ID Generation: Snowflake, ULID, and the Clock-Skew Problem
Why auto-increment dies when you shard, why random UUIDs wreck index locality, and how time-ordered IDs like Snowflake and UUIDv7 thread the needle.
5 min read
Distributed Locks: Leases, Fencing Tokens, and Why Redlock Is Controversial
A lock with a TTL can expire while its holder still thinks it owns it. Fencing tokens fix what timeouts break — and most lock problems have better answers.
5 min read
Geospatial Indexing: How 'Drivers Near Me' Actually Works
B-trees can't answer 2D questions. Geohash, quadtrees, and hex grids turn 'within 2km' into a prefix scan — plus the boundary problem that trips everyone.
5 min read
Load Shedding and Graceful Degradation: Failing the Right Requests First
Overloaded systems don't slow down gracefully — goodput collapses. Admission control, criticality tiers, and retry budgets decide what breaks and what survives.
6 min read
Raft in Plain English: How Clusters Agree When Nodes Keep Dying
Leader election, log replication, and the quorum-overlap trick that makes Raft safe. What etcd, Consul, and Kafka KRaft are actually doing under the hood.
10 min read
Columnar Storage: How Analytical Databases Work Under the Hood
Why column-oriented databases run analytical queries 100x faster than row-oriented ones — covering physical layout, compression algorithms, vectorized execution, and predicate pushdown with concrete examples.
9 min read
Kafka Consumer Groups, Partitions, and Offset Management Explained
A deep dive into how Kafka distributes work across consumers, why rebalancing stalls your pipeline, and how to choose an offset commit strategy that matches your delivery guarantee requirements.
10 min read
PostgreSQL Connection Pooling with PgBouncer
Why PostgreSQL's connection model breaks under load, how PgBouncer fixes it, and how to configure transaction-mode pooling without getting bitten by prepared statements or advisory locks.
4 min read
The Transactional Outbox Pattern: Publishing Events Without Losing Them
Why dual writes lose events, how the transactional outbox pattern fixes it, and the relay, ordering, and cleanup decisions that make it production-ready.
4 min read
Designing Webhook Delivery That Survives Flaky Consumers
Signing, retries, ordering, and dead-lettering: the design decisions that separate reliable webhook delivery from silent event loss.
7 min read
Backpressure: What Happens When Your System Can't Keep Up
A fast producer and a slow consumer is a recipe for an out-of-memory crash. Backpressure is the discipline of letting the slow part tell the fast part to wait. Here is how to design it in.
6 min read
Database Connection Pooling: The Bottleneck You Forgot to Tune
More connections is not more throughput. Past a point, adding connections makes your database slower. Here is how pools actually work and how to size one without guessing.
7 min read
Write-Ahead Logging: The Unsung Hero of Database Durability
How does a database survive a power cut mid-write without corrupting your data? The answer is a deceptively simple rule: log the change before you apply it. Here is why WAL is everywhere.
6 min read
Bloom Filters: Saving Gigabytes When 'Probably Not' Is Good Enough
A Bloom filter answers 'have I seen this?' using a tiny fraction of the memory a real set would need. The price is false positives — and understanding that trade is the whole skill.
6 min read
The Saga Pattern: Transactions That Span Services You Can't Roll Back
A single ACID transaction can't span order, payment, and inventory services. Sagas chain local transactions with compensating actions to keep distributed state consistent — eventually.
6 min read
Circuit Breakers: Stopping a Cascading Failure Before It Spreads
When a downstream service slows down, naive retries turn one sick dependency into a system-wide outage. A circuit breaker fails fast, sheds load, and gives the dependency room to recover.
6 min read
The Transactional Outbox: Reliable Messaging Without Distributed Transactions
You wrote to the database and then published an event — and the publish failed. Now your systems disagree. The outbox pattern makes the write and the event atomic without a two-phase commit.
7 min read
Consistent Hashing: How Distributed Systems Avoid the Great Reshuffle
When you add a node to a sharded cache, naive hashing remaps almost every key. Consistent hashing moves only a fraction. Here is the mechanism, the virtual-node fix, and the traps.
8 min read
Event-Driven System Design: The Decisions That Bite You Later
A practical guide to the design decisions that determine whether an event-driven system stays maintainable or quietly rots — delivery guarantees, ordering, idempotency, schema evolution, and the outbox.
7 min read
Designing a Scalable Search Engine: From Inverted Index to Hybrid Vector Search
Walk through the architecture of a production search system — inverted indexes, BM25 ranking, vector embeddings, and hybrid retrieval for 50M documents at 10K QPS.
11 min read
Designing a Scalable Notification System
A system design deep dive into building a notification platform that handles push, email, SMS, and in-app notifications at scale — covering architecture, priority queues, fan-out strategies, rate limiting, and delivery tracking.
8 min read
Designing a Production-Ready RAG System: What Actually Matters
Retrieval-augmented generation demos look great. Production RAG is a different engineering problem — chunking, hybrid retrieval, reranking, evaluation, and the failure modes nobody mentions at conferences.
10 min read
API Design Best Practices: REST, GraphQL, and gRPC Compared
A deep dive into the three dominant API paradigms — REST, GraphQL, and gRPC — covering design principles, pagination strategies, versioning, authentication patterns, and practical guidance on choosing the right one for your system.
13 min read
Event-Driven Architecture: Patterns, Pitfalls, and Practical Guidance
A comprehensive guide to event-driven architecture — covering pub/sub, event sourcing, CQRS, saga patterns, message broker trade-offs, and the hard lessons teams learn in production.
8 min read
Vector Databases Compared: pgvector, Qdrant, Pinecone, and When You Don't Need Any
A practical comparison of the vector databases people actually deploy in 2026 — and an honest look at when a vector database is the wrong tool for the job.
13 min read
Caching Strategies for High-Performance Systems
A deep dive into caching patterns that power the world's fastest systems — from cache-aside and write-through to multi-level architectures, stampede prevention, and real-world eviction strategies at scale.
8 min read
Idempotency Keys: The Pattern That Saves Your Payment System
Idempotency keys are what separate a payment system that double-charges during a retry from one that doesn't. The mechanism looks simple and has five subtle failure modes you need to know about.
15 min read
Microservices vs Monolith: Making the Right Architectural Choice
Cut through the hype and understand when a monolith, modular monolith, or microservices architecture is the right fit. Covers service boundaries, data ownership, communication patterns, and practical migration strategies.
15 min read
Database Indexing and Query Optimization: A Deep Dive
Understand how database indexes work under the hood, from B+ tree internals to composite index design. Learn to read EXPLAIN plans, avoid common anti-patterns, and make informed trade-offs between read performance and write amplification.
8 min read
Event-Driven Architecture for LLM Pipelines: Queues, Retries, and the Cost of Synchronous Chains
LLM-powered pipelines break in the same ways old monoliths did — when you stack synchronous calls. Queues, events, and the patterns that make a six-step AI pipeline survive a partial outage.
16 min read
Designing a Real-Time Chat System Like WhatsApp
A complete system design walkthrough for building real-time chat at scale — covering WebSocket management, message delivery guarantees, presence systems, group chat fan-out, and end-to-end encryption.
13 min read
CAP Theorem Explained: Trade-offs with Real-World Examples
A deep dive into the CAP theorem — what it really means for distributed systems, why you can only pick two guarantees, and how real databases like Cassandra, MongoDB, and DynamoDB make their trade-offs.
8 min read
Multi-Tenant Data Isolation: Row-Level, Schema-Level, Database-Level, and How to Choose
Three patterns for multi-tenant data isolation in SaaS, the trade-offs between cost, blast radius, and compliance, and a migration path from one to another when you outgrow your first choice.
11 min read
Designing a URL Shortener: System Design from Scratch
A complete walkthrough of designing a URL shortener service — covering hashing strategies, database schema, caching, analytics, and scaling to billions of redirects.