Blog
Technical Writings
Deep dives into distributed systems, software engineering architecture, and lessons from building at scale.
How A Message Gets From Your Phone To Your Friend's In Milliseconds
How messaging apps route a message to the one gateway server holding a recipient's live connection — the connection registry, pub-sub routing, and why push notifications and durable queues are two separate systems solving two different delivery problems.
The Bug That Cost Millions: How Distributed Locks Actually Work
Why a Redis TTL lock is a timer, not a liveness guarantee, how fencing tokens fix the double-write bug TTL-based locks can't prevent, and why ZooKeeper/etcd's consensus-backed tokens beat the contested Redlock algorithm when a duplicate write costs real money.
How Uber Handles Millions of Location Updates Every Second
How Uber's location-tracking system splits ownership (consistent hashing and gossip via Ringpop) from proximity search (H3 geospatial indexing) to handle millions of driver GPS updates per second — and the staleness trade-offs each piece carries.
How Your Bank Account Balance Is Never Wrong (Even During Outages)
Why bank balances are derived from an immutable, double-entry ledger rather than stored as a mutable number — and how that one architectural choice makes silent corruption structurally impossible, even during outages and network partitions.
How Netflix Decides What to Show You (And Why It's Not Just ML)
How Netflix's recommendation pipeline splits candidate generation, ranking, and real-time signals to personalize rows under a strict latency budget — and where each layer trades off staleness, cost, or accuracy.
What Actually Happens When You Click a Link on a Website
A deep dive into the full journey of a browser navigation: from your click to pixels on screen — DNS, TCP, TLS, HTTP, rendering, and the modern SPA twist.
Why Stripe Never Charges You Twice (Idempotency Keys)
A deep dive into how idempotency keys prevent double charges and handle network retries safely in distributed systems.
Feature Flags: How to Deploy Safely to Production at Big Tech Scale
From naive SQL queries on the hot path to deterministic evaluation engines backed by Redis and pub/sub invalidation — how feature flags actually work at 10,000 TPS.
Zero-Downtime Migration of Amazon Business Checkout to Microservices Using the Strangler Fig Pattern
How I migrated the high-traffic Amazon Business Checkout page from a Java monolith to a scalable microservices architecture with zero downtime, using the Strangler Fig pattern.
Zenoh vs Kafka: Choosing the Right Messaging Backbone for Your System
A deep dive into the architectural differences between Zenoh and Kafka, and when to choose each for your messaging backbone.
Building a Kafka Clone from Scratch in Go
An educational odyssey into the heart of bit-flipping, disk persistence, and network protocols by building Samsa: a lightweight Kafka clone in Go.
Evolving my Python Redis Clone: From Request-Response to Pub/Sub
How I shifted from a request-response paradigm to an async Pub/Sub architecture using inverted indices and asyncio in my custom Redis engine.
How I Built a Redis Server from Scratch in Python
A high-performance async Redis client built from scratch in Python.