233 deep-dive architecture specs, consensus protocols, and scale blueprints.
This page turns engineering blogs into an ingestion map.
Use this guide to go beyond "SQL vs NoSQL" and build real judgment around data modeling, transactions, indexes, replication, partitioning, and correctness boundaries.
Use this guide for partial failure, coordination, consensus, clocks, membership, retries, and correctness under network ambiguity.
Use this guide for nearby search, geofencing, geohash, H3, S2, PostGIS, Redis GEO, GPS error, and privacy-aware location systems.
This is the control center for the system design archive.
Use this guide for metrics, logs, traces, percentiles, cardinality, alerting, dashboards, and debugging distributed request flows.
Use this guide for SLOs, error budgets, incidents, overload, retries, timeouts, disaster recovery, deployment safety, and operational ownership.
Use this guide for lexical retrieval, ranking, query understanding, relevance feedback, hybrid search, and index operations.
Use this guide for how bytes become durable, searchable, compacted, checksummed, and recovered.
This lesson frames System Design Archive Completion Audit as a practical architecture decision under real constraints.
Goal: build a compounding system design archive that turns the Arpit Bhayani course, existing Obsidian notes, engineering blogs, real-world systems, papers, tools, and implementation references into a durable Staff/Principal-level learning system.
This page maps archive concepts to real projects worth running, reading, or using as implementation references.
Use this workflow for turning lecture transcripts, engineering blog posts, papers, or implementation walkthroughs into archive-ready Obsidian notes.
This page converts scattered engineering links into a system-design learning map.
Use this guide for uploads, multipart transfer, transcoding, manifests, adaptive bitrate, CDN delivery, DRM, WebRTC, and live latency.
algorithmic-system-design workshop.
This reference note frames Algorithmic System Design II as a practical architecture decision under real constraints.
Covers why ID generation becomes a system design problem at scale: uniqueness, monotonicity, index size, clock skew, sharding, pagination, and coordination all collide in one deceptively small field.
Covers "distributed systems" from theory into design tools: partial failure, circuit breakers, load balancers, API gateways, observability, remote locks, distributed locks, Redis/Redlock, and why hands-on implementation matters.
Covers system design as turning product requirements into a working system made of heterogeneous components.
Covers the foundational building blocks from lecture 01: caching, scaling, delegation, concurrency, and communication.
Covers choosing non-relational databases for the access pattern, not for the label.
Covers "choose SQL" to how relational databases actually shape system design: schema normalization, ACID, indexes, locking, replication, sharding, and the design of a SQL-backed key-value store.
This reference note frames High Throughput Systems I as a practical architecture decision under real constraints.
This reference note frames High Throughput Systems II as a practical architecture decision under real constraints.
Covers a text search engine from first principles, then uses the same high-throughput patterns for recent searches and live reactions.
IR continuation, but the actual content is an ad-hoc system design workshop.
Covers Instagram as a familiar social-network case study.
This reference note frames Social Networks II as a practical architecture decision under real constraints.
Covers "design a distributed cache" as a storage-engine gateway.
This reference note frames Storage Engines II as a practical architecture decision under real constraints.
Amazon's Dynamo paper is a foundational case study in building an always-available key-value store for production services that can tolerate weaker consistency.
FoundationDB is a distributed transactional ordered key-value store designed as a lower-level substrate for higher-level database layers.
Bigtable is the classic distributed sorted-map paper for large structured data over commodity servers.
Spanner is the canonical source for globally distributed SQL with externally consistent transactions.
Google's SRE books are the core operating reference for SLOs, error budgets, incident response, toil, monitoring, overload, and production ownership.
Kafka's design docs are the primary source for understanding durable event logs, partitions, consumer groups, batching, and log retention.
LevelDB's implementation notes are a compact source for understanding real LSM-tree mechanics.
OpenTelemetry is the vendor-neutral instrumentation ecosystem for traces, metrics, logs, baggage, semantic conventions, SDKs, collectors, and exporters.
Prometheus is a metrics and alerting system centered on time series, labels, scraping, querying, and alert rules.
Raft is the practical consensus paper to read before discussing leader election, replicated logs, and metadata coordination.
The Stanford IR book is the canonical conceptual base for lexical retrieval, index construction, scoring, evaluation, relevance feedback, web crawling, and link analysis.
Vespa's hybrid search material is a practical source for combining lexical retrieval, vector retrieval, filtering, and ranking phases.
A chat system stores ordered conversations, delivers them in real time to every device a user owns, tracks what each device has seen, and keeps working when the recipient is offline for…
A collaborative editor lets many people type into one document at the same time, shows each keystroke to everyone within a few hundred milliseconds, and guarantees that when the typing stops every…
A product listing system answers "show me shoes, size 10, under 100 dollars, cheapest first, page 3" over millions of SKUs, with facet counts, images, and a price and stock badge that…
Nearby search answers "what relevant objects are near this point right now?"
Notification System Design A notification system turns product events into user-visible messages across email, push,
An observability system lets engineers answer production questions without redeploying code: is the system down, for whom, since when, and which change did it.
A payment system takes a checkout request, moves money through an external provider, and keeps a record that survives every retry, timeout, and replay along the way.
Rate limiting protects a shared system from overload, scraping, brute force, spam, runaway clients, and unfair tenant usage.
A recommendation system selects items a user is likely to value from a catalog far too large to score: posts, videos, products, jobs, people, or documents.
A social feed takes every post published by the accounts a person follows, mixes in recommendations and ads, ranks the result, and returns a page in one round trip.
This is a procedure as much as a system.
A load balancer distributes traffic across equivalent backends.
The terms "columnar" and "wide-column" are often mixed together, but they describe different ideas.
Concurrency is dealing with many tasks in overlapping time.
Document stores and key-value stores both organize data around keys, but they expose different semantics for the value.
Geospatial grid systems turn Earth into cells so location queries can use ordinary keys, ranges, and joins.
Vertical scaling makes one machine bigger.
REST-style HTTP APIs and gRPC both expose remote operations.
Long polling keeps HTTP request/response semantics while waiting for new data.
A monolith deploys one application unit.
Object storage stores large immutable-ish blobs cheaply.
Seen filtering prevents a discovery feed from showing the same item again.
Choose the communication pattern by update frequency, latency requirement, and idle connection cost.
Task queues and event streams both move work outside the request path, but they answer different questions.
TCP provides reliable ordered byte streams.
UUIDs, MongoDB ObjectIds, and Snowflake-style IDs solve different parts of the ID-generation problem.
Realtime transports differ in directionality, connection cost, infrastructure support, and failure behavior.
Adaptive Bitrate And CDN Decider Adaptive bitrate streaming lets the player switch between video variants based on ne
An API contract defines what clients may send, what they can expect back, and how the contract changes over time.
The storage layer behind object storage should be cheap, durable, and write-efficient.
Autocomplete suggests likely queries or entities while the user types.
Availability Durability Consistency And Cost Architecture tradeoffs often reduce to four questions: does it stay up,
A B-tree is a balanced search tree optimized for block/page-oriented storage.
Back-Of-The-Envelope Capacity Planning Capacity planning turns product requirements into rough load, storage, bandwid
Backpressure is how a system tells upstream producers to slow down when downstream capacity is saturated.
Backup strategy defines what data is copied, where it is stored, how long it is retained, and how restoration is proven.
Batching groups work to reduce per-item overhead.
Bitcask is a log-structured hash-table storage engine for fast key-value data.
Blocklist Versioned File Metadata A blocklist is the ordered list of block hashes that defines a file version. The m
A Bloom filter is a compact probabilistic data structure for membership checks.
BM25 is the practical production successor to vanilla TF-IDF for lexical search.
Boolean Tiered Search Boolean tiered search starts strict and relaxes only when needed. It is a practical way to pres
Time-window aggregation turns an infinite event stream into queryable windows.
Byte-Range Indexed Object Storage Byte-range reads let an application fetch only part of a large object. With a separ
A cache starts as a performance aid.
Caches still need concurrency control.
Eviction decides which key leaves when cache memory is full.
A cache is any stored answer that avoids an expensive operation.
CAP says that during a network partition, a distributed system must choose between availability and consistency.
Circuit breakers prevent a failing dependency from dragging the rest of the system down.
Clock Skew And ID Ordering Clock skew breaks the assumption that timestamps from different machines are directly comp
Distributed systems need ordering, but wall clocks on different machines are not a perfect global truth.
Compaction is the background process that merges immutable files, drops obsolete values, and controls the number of files a read must search.
Consensus lets a group of nodes agree on a sequence of decisions despite failures, as long as assumptions such as quorum and timing bounds are respected.
A consistency model defines what reads may observe after writes.
Consistent hashing determines which node owns a key while minimizing remapping when nodes are added or removed.
Consistent hashing can route keys to nodes while minimizing remapping when nodes join or leave.
Cost-aware architecture treats money as a design constraint alongside latency, correctness, and reliability.
Count-min sketch is a compact probabilistic data structure for approximate item frequencies in streams.
Counts are deceptively expensive because product pages make them look like ordinary fields.
A crawler/indexing pipeline discovers documents, fetches content, extracts structured data, builds indexes, and keeps results fresh.
A custom storage file should be self-describing enough for a reader to find the sections it needs without external state.
A DAG is a directed acyclic graph of tasks.
Data retention defines how long data is kept.
Database backup strategy combines snapshots, logical exports, and WAL/binlog archives so the system can restore to a known point.
An index is a data structure that speeds up reads by giving the database a shorter path to matching rows.
Isolation is the part of ACID that controls how concurrent transactions interact.
Database migration safety is about changing schema and data while old code, new code, workers, replicas, and backfills may all coexist.
Database Ticket Servers A database ticket server is a small dedicated database used only to issue unique IDs. ## Cor
A write-ahead log records changes before they are applied to main data structures.
Delegation means moving non-essential work out of the synchronous request path and into workers, queues, streams, or batch jobs.
Deployment safety is the discipline of changing production while preserving rollback, observability, and user trust.
Spell correction rewrites or suggests alternate queries when the original query is likely misspelled or poorly segmented.
Direct upload keeps large media bytes out of the application server.
Disaster recovery is the plan for restoring service after region loss, data corruption, catastrophic deploys, credential compromise, or operator error.
A distributed cache is a key-value store spread across machines.
A distributed hash table is a key-value lookup spread across many nodes.
Distributed ID generation is the problem of assigning unique identifiers without forcing every write through one database sequence.
Distributed locks coordinate work across multiple machines.
A distributed system is a system where components run on multiple machines and coordinate over a network while presenting one coherent product or service.
A distributed task scheduler runs one-time or recurring jobs across a fleet while meeting a scheduling SLA.
Replication protects against losing bytes.
A product event says, "this fact happened."
An event contract defines the meaning, schema, producer rules, and consumer expectations for a durable event.
Extensible data modeling means choosing a schema that survives the next obvious product change without pretending to solve every future problem.
Fanout sends one event, post, message, or update to many recipients or downstream consumers.
This concept lesson frames Feed Generation Push Pull Hybrid as a practical architecture decision under real constraints.
File-Backed Dictionary Storage Engine The exercise: build exact lookup for `word -> meaning` with no traditional data
Chunking turns a large file into smaller transfer units.
Flash sales are about atomic reservation under extreme contention.
Geofencing answers whether a user/device point lies inside a named region.
Geohash encodes latitude/longitude into a hierarchical string.
Gossip protocol spreads state by having nodes repeatedly exchange what they know with a few peers.
Graph databases are specialized tools for relationship traversal and graph algorithms.
A Gravatar-style service gives each user a stable URL that always renders the current active avatar.
Hashtags start as text parsing and become a read-model problem.
Hot/cold storage is the practice of keeping frequently accessed data in fast, expensive systems and moving rarely accessed data to slower, cheaper systems.
A hot partition is a shard, key range, tenant, cell, or queue partition receiving disproportionate load.
HyperLogLog estimates the number of distinct values in a stream using tiny bounded memory.
Image delivery is a bandwidth, latency, storage, and device-experience problem.
When an application keeps file offsets in memory, changing the underlying file in place can corrupt reads.
This concept lesson frames Impression Counting System Design as a practical architecture decision under real constraints.
Incident response is the operating model for restoring a degraded service and learning from failure.
Information retrieval systems answer vague human intent over a corpus.
An inverted index maps term -> documents containing that term.
Keyset pagination uses the last seen sort key instead of OFFSET.
Leader election chooses one node to coordinate work such as scheduling, partition ownership, replication, or metadata changes.
Live commentary, like Cricbuzz, is a read-amplification problem.
Live reactions are the "heart button" problem: many users tap rapidly, everyone should see motion quickly, and the business may still want durable analytics.
Video-on-demand is file serving.
A load balancer receives client traffic and distributes it across a pool of backends.
Load shedding intentionally rejects, delays, or degrades lower-value work so the system can preserve higher-value work during overload.
Log-structured storage writes new records by appending.
Logical System Design Logical system design is the structure of the application itself: where business rules live, wh
LSM writes are simple.
An LSM tree is a write-optimized storage structure that keeps recent writes in memory, records them durably in an append-only log, and periodically flushes sorted immutable files to disk.
Matching algorithms pair supply and demand: riders/drivers, jobs/candidates, buyers/products, users/content, or mentors/mentees.
An LSM engine is built from three core pieces: a WAL, a memtable, and SSTables.
Mergeable Sketches For Analytics A mergeable sketch is a compact summary that can be combined with other summaries wi
Object storage needs a database even when object bytes live in a custom storage layer.
Client-side routing needs every client to agree on the storage topology.
Multi-tenant systems serve many customers on shared infrastructure while preserving isolation, fairness, security, and cost control.
Multi-version concurrency control lets readers see a stable snapshot while writers create newer versions.
MySQL MEMORY Engine Cache The MySQL `MEMORY` engine lets you keep the SQL interface while changing the storage behavi
This concept lesson frames Nearby Geospatial Search System Design as a practical architecture decision under real constraints.
Newly-Unread Indicator A newly-unread badge is not the same as total unread messages. Example product behavior: - Y
Non-Functional Requirements Non-functional requirements define how the system must behave under real operating condit
NoSQL is a family of tradeoffs, not a single database behavior.
Object storage is trusted with customer data.
Observability is what lets you understand a distributed system from the outside when you cannot attach a debugger to "the system" as a whole.
Online indexing builds or changes indexes while the database continues serving traffic.
Parallel Monolith Read Drain When a legacy monolith sends too many reads to a master database, you do not always need
Partition Manager And Map Table Once storage is range-partitioned, the system needs a control plane that answers: ``
Photo Tagging Coordinate Model When users tag people in photos, store positions relative to the image, not as absolut
SELECT … FOR UPDATE SKIP LOCKED lets multiple workers safely claim disjoint rows from a table without an external broker.
Privacy and retention design controls what personal or sensitive data is collected, who can access it, where it is copied, and when it is deleted.
Query planning is how a database chooses an execution strategy: scan, index lookup, join order, sort, aggregate, and memory use.
Query understanding rewrites messy user text into a set of searches the engine can execute.
Queue lag measures how far background processing is behind incoming work.
Consistent hashing is good when random distribution is the goal.
Rate limiting is only useful if it is placed where it has the right identity and enough context.
Raw events are facts.
Ray casting determines whether a point lies inside a polygon by counting how many times a ray from the point crosses polygon edges.
Reactions look like a small product feature, but the table can grow toward users times posts.
Real-time database sync means clients subscribe to changes and receive updates without manually refreshing.
Requirement: when a user taps the search box, render the last five unique successful searches with single-digit millisecond latency.
Redis GEO is a pragmatic hot-path choice for "find nearby active things" when the data fits in memory and the geospatial needs are simple.
Redlock is Redis's distributed-lock algorithm using multiple independent Redis masters and quorum-based lock acquisition.
Related searches suggest adjacent queries that help users refine, broaden, or pivot intent.
Relational database design is the discipline of modeling facts, relationships, and constraints so the database can protect correctness while still serving the system's access patterns efficiently.
Relational database scaling should be sequential.
Remote file sync keeps local folders and cloud state converged without uploading or downloading entire files after small changes.
Replication keeps copies of data on multiple machines or regions for availability, durability, read scale, or locality.
The repository pattern creates a data-access boundary between business logic and persistence details.
Requirements Clarification Requirements clarification turns a vague prompt into a bounded design problem. It prevents
Reservoir sampling keeps a uniform random sample of fixed size from a stream of unknown length.
Retries recover from transient failures only when bounded by timeouts and protected by idempotency.
Rule Engine Trigger Framework A trigger framework lets product and operations define: **when this event happens, if t
Object storage stores blobs under bucket/key names and exposes operations like PUT, GET, DELETE, LIST, and HEAD.
Schema evolution is changing data contracts while old and new producers, consumers, databases, queues, and caches coexist.
Search evaluation measures whether results satisfy user intent, not only whether the system returned documents.
Search quality improves when the system learns from what users did after seeing results.
Search index sharding splits an index across machines so queries, indexing, and storage can scale.
Search index synchronization is the process of keeping a derived search system, such as Elasticsearch or OpenSearch, aligned with the primary database.
Security design protects data, users, and system integrity.
Service communication is how independent components coordinate work while preserving latency, correctness, and failure isolation.
Sharding splits data across multiple storage nodes so the system can scale horizontally.
CDNs are good at serving bytes.
A sliding-window limiter enforces a limit over the most recent moving window, not just a fixed calendar bucket.
An SLO is a reliability target for a user-visible behavior.
Snowflake-style IDs generate compact, mostly time-sortable IDs without calling a central ID service for every write.
Social Graph Follows And FlockDB Follow/follower storage looks like a graph problem, but not every graph-shaped probl
A social-network schema is not just users and posts.
Soft delete marks data as deleted without physically removing it immediately.
A SQL-backed key-value store uses a relational database table for key/value lookups, often as a simple durable starting point.
Stop Words And Champion Lists Stop words are terms that appear so often they carry little information. Common example
A storage engine is not just "write bytes somewhere."
Storage engines trade read amplification, write amplification, space amplification, recovery time, and operational tuning.
Streaming percentile analytics lets dashboards answer p50/p95/p99 over huge metric streams without sorting raw data at query time.
System Design Tradeoffs Every architecture choice buys one property by spending another: latency, correctness, availa
Tail latency is the slow end of request distribution: p95, p99, and beyond.
TDigest Quantile Sketch t-digest is a compact data structure for approximate quantiles such as p50, p95, p99, and p99
TF-IDF says: a term is important to a document when it appears often in that document and rarely across the corpus.
Top-K heavy hitter systems track the most frequent items in a stream: queries, users, products, IPs, errors, or keys.
TTL says how long a key may live.
Vector search retrieves items by embedding similarity.
Video platforms do not serve the raw upload directly.
Large video uploads should bypass the API server.
View counting is distributed aggregation: many client events become a smaller number of durable counter updates.
When Not To Add Infrastructure Senior system design is often about declining complexity. Infrastructure is justified