System Design — Page 12 of 21
Browsing page 12 of 21 — 243 articles on system design.
Designing a Live Streaming Platform: Real-Time Video Ingest, Low-Latency Delivery, and Chat Synchronization at Scale
A system design deep dive into live streaming architecture: RTMP/SRT/WebRTC ingest, LL-HLS and CMAF transcoding pipelines, edge CDN delivery, adaptive bitrate ladders, chat synchronization, and failure modes at scale.
Designing a Tokenization Service: PCI Compliance, Format-Preserving Encryption, and Secure Data Vaults at Scale
A deep dive into the architecture of a PCI-compliant tokenization service: token vault patterns, random vs deterministic vs FPE tokens, envelope encryption with KMS/HSM, detokenization authorization, audit logging, and performance at scale.
Gossip Protocols in Distributed Systems: Membership, Failure Detection, and Anti-Entropy at Scale
A deep dive into epidemic protocols for cluster membership, failure detection, and state dissemination. Covers push/pull/push-pull variants, the SWIM protocol, anti-entropy with Merkle trees, and how Cassandra, Consul, and Redis Cluster use gossip in production.
Designing a Data Migration Pipeline: Schema Mapping, Incremental Sync, and Zero-Downtime Cutover
Moving data between systems at scale is not a copy operation. It is a multi-phase pipeline with schema transformation, CDC-based incremental sync, dual-write coordination, and a cutover sequence you can abort at any point. This article covers the full architecture.
Designing a Database Proxy: Connection Pooling, Query Routing, and Read/Write Splitting at Scale
Database proxies like PgBouncer, ProxySQL, and Vitess solve connection exhaustion, read scaling, and failover at the infrastructure layer so your application does not have to. Here is how they work under the hood and when each strategy makes sense.
Designing a Digital Wallet System: Double-Entry Ledgers, Transaction Atomicity, and Balance Consistency at Scale
How to architect a digital wallet from first principles: double-entry ledger schema, ACID atomicity for transfers, concurrent balance consistency, idempotency, reconciliation, and multi-currency support with TypeScript examples and honest tradeoffs.
Designing a Real-Time Event Processing System: Complex Event Processing, Windowed Aggregations, and Pattern Detection at Scale
A practical guide to building real-time event processing systems: CEP engines, tumbling and sliding window aggregations, event pattern matching, and honest tradeoffs between Kafka Streams, Apache Flink, and lighter-weight alternatives.
Designing a Status Page System: Health Aggregation, Incident Communication, and Subscriber Notifications at Scale
A deep dive into the architecture of a production status page system: health check aggregation, incident state machines, subscriber notification fan-out, and the operational challenge of keeping your status page up when everything else is down.
Designing a Distributed Cache: Eviction Policies, Cache Coherence, and Multi-Tier Caching at Scale
A system design deep dive on building a distributed caching layer. Covers LRU, LFU, and TTL eviction algorithms, cache coherence in multi-node setups, write-through vs write-behind patterns, multi-tier caching architectures, and production problems like thundering herd, cache stampede, and hot key mitigation with TypeScript and Redis examples.
Designing a DNS-Based Traffic Management System: Weighted Routing, Failover Policies, and Global Load Distribution
DNS is not just name resolution. At scale, it is the first layer of traffic management, handling weighted routing, latency-based decisions, geolocation policies, and health-driven failover before a single TCP connection is established. This guide covers how it works and how to build a routing decision engine in TypeScript.
Designing a Web Crawler: URL Frontier, Politeness Policies, and Distributed Scheduling at Scale
A deep dive into production web crawler architecture covering URL frontier management, politeness enforcement, content deduplication with SimHash, distributed worker coordination via consistent hashing, and DNS caching strategies.
Designing a Batch Processing System: Job Partitioning, Checkpoint Recovery, and Parallel Execution at Scale
A practical guide to batch processing system design covering job partitioning strategies, checkpoint recovery for fault tolerance, parallel execution models, and backpressure. Includes TypeScript examples and production considerations.