Archprimer

Full Mastery

Every concept, pattern, tradeoff, and architecture on Archprimer — for daily practice and reference, not just interview cramming.

47 topics·~314 min total
  1. 1
    Concept

    Load Balancer

    A component that distributes incoming traffic across multiple servers using health checks and balancing algorithms, operating at L4 (transport) or L7 (application).

    6 min
  2. 2
    Concept

    DNS

    The internet's naming system that resolves human-readable domains to IP addresses via recursive and authoritative resolvers, records, and TTL-based caching.

    6 min
  3. 3
    Concept

    CDN

    A globally distributed network of edge servers that caches static content near users to cut latency and offload the origin, using origin pull and TTL-based freshness.

    6 min
  4. 4
    Concept

    Caching

    Storing hot data in a faster, closer layer to cut latency and load, governed by hit ratio, eviction policies like LRU, and the hard problem of invalidation.

    7 min
  5. 5
    Concept

    Redis

    An in-memory data store used as a cache, session store, rate limiter, and message broker — microsecond reads.

    4 min
  6. 6
    Concept

    Replication

    Copying data across multiple nodes for read scaling and high availability, using leader-follower or multi-leader topologies with synchronous or asynchronous propagation.

    7 min
  7. 7
    Concept

    Sharding

    Horizontal partitioning that spreads rows of one logical dataset across many independent nodes, using a shard key to route each request to the node that owns the data.

    8 min
  8. 8
    Concept

    Partitioning

    Splitting a large table or dataset into smaller pieces — horizontally by rows or vertically by columns — to improve manageability and performance, often within a single system.

    7 min
  9. 9
    Concept

    Consistent Hashing

    A hashing scheme that maps keys and nodes onto a ring so that adding or removing a node remaps only a small fraction of keys, avoiding the mass reshuffle of modulo hashing.

    8 min
  10. 10
    Concept

    Bloom Filter

    A space-efficient probabilistic data structure that answers set-membership queries with no false negatives and a tunable false-positive rate, used to skip expensive lookups.

    7 min
  11. 11
    Concept

    CAP Theorem

    In a distributed system, a network partition forces a choice between consistency and availability — you cannot have both while partitioned; PACELC adds the latency-vs-consistency tradeoff in normal operation.

    7 min
  12. 12
    Concept

    Quorum

    A voting rule for replicated systems: requiring read and write sets to overlap (R + W > N) guarantees reads see the latest write, giving tunable consistency in Dynamo-style stores.

    7 min
  13. 13
    Concept

    Leader Election

    The process by which distributed nodes agree on a single coordinator to serialize decisions, using consensus (Raft, Paxos, ZooKeeper) and safeguards against split-brain and failover gaps.

    8 min
  14. 14
    Concept

    Kafka

    A distributed, append-only commit log that streams high-throughput events across partitions with durable, replayable storage and consumer-group scaling.

    7 min
  15. 15
    Concept

    RabbitMQ

    A traditional message broker that routes messages through exchanges to queues using bindings, with acknowledgements and flexible work-queue patterns.

    7 min
  16. 16
    Pattern

    Cache-Aside

    The app checks the cache first and loads from the database only on a miss — the default caching strategy.

    3 min
  17. 17
    Pattern

    CQRS

    Command Query Responsibility Segregation splits the write model from the read model, letting each be optimized independently and often synced via events.

    7 min
  18. 18
    Pattern

    Saga

    A saga coordinates a distributed transaction as a sequence of local transactions, each with a compensating action to undo work on failure — via choreography or orchestration.

    8 min
  19. 19
    Pattern

    Circuit Breaker

    Wrap calls to a failing dependency in a breaker that trips open after repeated failures, fails fast, and probes for recovery — preventing cascading failure.

    6 min
  20. 20
    Pattern

    Bulkhead

    Isolate resources like thread pools and connection pools into partitions so a failure or overload in one area cannot sink the entire system.

    6 min
  21. 21
    Pattern

    Pub/Sub

    Publishers emit events to a topic and subscribers consume them independently, decoupled through a broker so producers and consumers never know each other.

    6 min
  22. 22
    Pattern

    Event Sourcing

    Persist state as an append-only log of immutable events; current state is derived by replaying events, giving a full audit history and time-travel.

    8 min
  23. 23
    Pattern

    Retry Pattern

    Automatically retry transient failures using exponential backoff with jitter, bounded attempts, and idempotent operations to avoid duplicate side effects.

    6 min
  24. 24
    Pattern

    Outbox Pattern

    Write the business change and an outbox row in one local transaction, then relay outbox rows to the broker — solving the dual-write problem reliably.

    7 min
  25. 25
    Pattern

    Write-Through Cache

    Every write updates both the cache and the database synchronously, keeping the cache always fresh at the cost of higher write latency.

    5 min
  26. 26
    Pattern

    Write-Back Cache

    Writes go to the cache and are acknowledged immediately, then flushed to the database asynchronously — fast writes at the risk of loss on crash.

    6 min
  27. 27
    Tradeoff

    SQL vs NoSQL

    Structured, relational, ACID databases versus flexible, horizontally-scalable non-relational stores.

    4 min
  28. 28
    Tradeoff

    Redis vs Memcached

    Redis is a rich data-structure server with persistence and replication; Memcached is a lean, multithreaded string cache. Pick by feature needs vs raw simplicity.

    7 min
  29. 29
    Tradeoff

    Kafka vs RabbitMQ

    Kafka is a durable, replayable distributed log for streaming; RabbitMQ is a flexible message broker with rich routing and per-message acks. Log vs broker.

    8 min
  30. 30
    Tradeoff

    REST vs GraphQL

    REST exposes fixed resource endpoints prone to over/under-fetching; GraphQL offers one flexible query endpoint at the cost of caching and N+1 complexity.

    8 min
  31. 31
    Tradeoff

    Polling vs WebSockets

    Polling repeatedly asks the server for updates over stateless HTTP; WebSockets hold one persistent bidirectional connection for real-time push. Simplicity vs latency.

    7 min
  32. 32
    Tradeoff

    Replication vs Sharding

    Replication copies data for high availability and read scaling; sharding splits data across nodes for write scaling. They solve different problems and are often combined.

    8 min
  33. 33
    Tradeoff

    Vertical vs Horizontal Scaling

    Vertical scaling adds power to one machine; horizontal scaling adds more machines. Simplicity and a hard ceiling versus complexity and near-limitless growth.

    7 min
  34. 34
    Tradeoff

    Monolith vs Microservices

    A monolith is one deployable unit that is simple to build and operate; microservices split it into independently deployable services that scale teams at a cost of distributed complexity.

    9 min
  35. 35
    Architecture

    URL Shortener

    Turn long URLs into short, unique links and redirect billions of reads with sub-100ms latency.

    5 min
  36. 36
    Architecture

    Search Engine / Typeahead

    Design a web-scale search engine with an inverted index, distributed crawling and indexing, relevance ranking, and low-latency autocomplete backed by tries.

    8 min
  37. 37
    Architecture

    Notification Service

    Design a multi-channel notification platform delivering push, email, and SMS at scale using queue-based fanout, per-user rate limiting, retries with backoff, and deduplication.

    7 min
  38. 38
    Architecture

    Payment Gateway

    Design a payment gateway with idempotent APIs, a double-entry ledger, exactly-once processing, PSP integration, and reconciliation under strong consistency.

    8 min
  39. 39
    Architecture

    Rate Limiter

    Design a distributed rate limiter using token bucket and sliding window algorithms with Redis-backed counters to enforce per-user and per-API request limits.

    7 min
  40. 40
    Architecture

    News Feed

    Design a social news feed covering feed generation, fanout-on-write vs fanout-on-read, ranking, and caching of hot feeds for millions of users.

    8 min
  41. 41
    Architecture

    Food Delivery

    Design a three-sided food delivery platform: customer ordering, restaurant order management, geospatial courier matching, order lifecycle, and live tracking.

    8 min
  42. 42
    Architecture

    WhatsApp / Chat

    A real-time messaging system built on persistent WebSocket connections, with message fanout, delivery/read receipts, and online presence at billions-of-messages-per-day scale.

    6 min
  43. 43
    Architecture

    Instagram Feed

    A photo-sharing service with a personalized timeline, balancing fanout-on-write and fanout-on-read to generate feeds cheaply, and a CDN to serve media globally.

    5 min
  44. 44
    Architecture

    YouTube

    A video platform covering the async upload/transcode pipeline, adaptive-bitrate streaming, global CDN delivery, and metadata storage for search and playback.

    6 min
  45. 45
    Architecture

    Netflix

    Video streaming at global scale using pre-positioned content on Open Connect appliances, adaptive-bitrate playback, a microservices control plane, and personalized recommendations.

    6 min
  46. 46
    Architecture

    Uber / Ride Matching

    A real-time ride-hailing system: ingesting driver locations, indexing them geospatially (geohash/H3), matching nearby drivers to riders, and computing surge pricing.

    6 min
  47. 47
    Architecture

    Dropbox / File Sync

    A file sync and storage service using content-defined chunking, block-level deduplication, a metadata service, and sync with conflict resolution across devices.

    6 min