Technical essays, architectural deep-dives, and practical guides at the intersection of code and design.
Page 5 of 28
A comprehensive guide to Redis — covering its single-threaded architecture, data structures (strings, hashes, sorted sets, streams), persistence (RDB/AOF), replication, clustering with hash slots, pub/sub, Lua scripting, caching patterns, rate limiting, distributed locks, and production best practices for running Redis at scale.
A comprehensive guide to Apache Kafka for system design interviews — covering its distributed commit log architecture, partitioning and replication, producer and consumer internals, consumer groups, exactly-once semantics, compacted topics, schema evolution, Connect and Streams APIs, and production patterns for building event-driven systems at scale.
A comprehensive guide to Elasticsearch for system design interviews — covering inverted indexes, cluster architecture (master/data/coordinating nodes), sharding and replication, the write path (translog, refresh, flush, merge), the read path (scatter-gather, BM25 scoring), mappings, analyzers, aggregations, scaling strategies, and production best practices for building search-heavy systems.
A comprehensive guide to API Gateways for system design interviews — covering request lifecycle, authentication and authorization, rate limiting algorithms (token bucket, sliding window), routing and load balancing, circuit breakers, response caching, request aggregation, TLS termination, protocol translation, and production patterns with Kong, NGINX, AWS API Gateway, and Envoy.
A comprehensive guide to designing production-grade REST APIs — covering resource naming, HTTP methods, pagination strategies, versioning approaches, error handling, rate limiting, and the communication problems REST solves.
A hands-on guide to data modelling — from entity-relationship design to normalization tradeoffs, indexing strategies, access-pattern-driven schemas, and safe schema evolution. Covers SQL and NoSQL with real-world examples.
A comprehensive guide to caching in distributed systems — covering caching layers (browser, CDN, application, database), invalidation strategies (cache-aside, write-through, write-behind), eviction policies (LRU, LFU, TTL), consistency pitfalls (thundering herd, hot keys, cache penetration), and production patterns with Redis.
A practical guide to scaling write-heavy systems — covering sharding strategies, write-ahead logs, async queues, event sourcing, LSM trees, and batching with architecture diagrams and production code.
How to build real-time systems that handle millions of concurrent connections — covering WebSockets, SSE, pub/sub fan-out, presence tracking, backpressure, and reconnection strategies with production code examples.
How to design systems that efficiently upload, store, process, and serve large binary objects (images, videos, documents) at scale -- covering presigned URLs, chunked uploads, content pipelines, storage tiering, CDN delivery, and deduplication strategies.
How to design systems that reliably execute tasks taking seconds to hours -- covering async job queues, progress tracking, retry strategies, sagas, checkpointing, dead letter queues, idempotency, and distributed task orchestration with production code examples.
A deep dive into the SAGA pattern for managing distributed transactions — covering orchestration vs choreography, compensation flows, state machines, and production-ready code examples in Node.js and Python.