The Augmented Dev · Archive

All articles

Dynamics 365, Power Platform, AI, system design, and web development — filter by theme or search across every post.

85 of 225 articles tagged system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design devops

Jul 15, 20265 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.

system-design devops

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20264 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 15, 20265 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.

system-design

Jul 13, 20265 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.

system-design

Jul 13, 20265 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.

system-design

Jul 13, 20265 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.

system-design

Jul 13, 20265 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.

system-design

Jul 13, 20265 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.

system-design

Jul 13, 20265 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.

system-design

Jul 13, 20265 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.

system-design

Jul 13, 20265 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.

system-design

Jul 13, 20265 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.

system-design

Jul 13, 20264 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.

system-design

Jul 13, 20265 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.

system-design

Jul 13, 20265 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.

system-design

Jul 13, 20265 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.

system-design devops

Jul 13, 20265 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.

system-design

Jul 13, 20265 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.

system-design

Jul 13, 20264 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.

system-design

Jul 10, 20266 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.

system-design tutorial

Jul 10, 20265 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.

system-design tutorial

Jul 10, 20265 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.

system-design tutorial

Jul 10, 20265 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.

system-design tutorial

Jul 10, 20265 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.

system-design tutorial

Jul 10, 20265 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.

system-design tutorial

Jul 10, 20265 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.

system-design tutorial

Jul 10, 20265 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.

system-design tutorial

Jul 10, 20265 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.

system-design tutorial

Jul 10, 20266 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.

system-design tutorial

Jul 5, 202610 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.

system-design data-engineering

Jul 5, 20269 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.

system-design

Jul 5, 202610 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.

system-design

Jul 2, 20264 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.

system-design tutorial

Jul 2, 20264 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.

system-design web-dev

Jun 20, 20267 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.

system-design tutorial

Jun 18, 20266 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.

system-design tutorial

Jun 17, 20267 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.

system-design tutorial

Jun 15, 20266 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.

system-design tutorial

Jun 14, 20266 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.

system-design tutorial

Jun 12, 20266 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.

system-design tutorial

Jun 11, 20266 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.

system-design tutorial

Jun 9, 20267 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.

system-design tutorial

Apr 25, 20268 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.

system-design tutorial

Apr 24, 20267 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.

system-design

Apr 11, 202611 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.

system-design

Apr 9, 20268 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.

system-design ai llm

Apr 8, 202610 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.

system-design

Apr 5, 202613 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.

system-design

Apr 4, 20268 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.

system-design ai tutorial

Apr 2, 202613 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.

system-design

Mar 30, 20268 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.

system-design tutorial

Mar 30, 202615 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.

system-design

Mar 27, 202615 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.

system-design

Mar 25, 20268 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.

system-design ai llm

Mar 24, 202616 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.

system-design

Mar 21, 202613 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.

system-design

Mar 20, 20268 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.

system-design tutorial

Mar 15, 202611 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.

system-design

Newsletter

New posts, straight to your inbox

One email per post. No spam, no tracking pixels, unsubscribe anytime.