How I Would Learn System Design

Ever so often, I get this question from mentees: “How can I master system design?” Knowing how to design systems at scale is a highly sought‑after skill, especially if you're preparing for interviews. Designing systems at scale is what separates seniors from juniors or mid‑level engineers.

My personal journey learning how to design applications at scale was rough and extremely fragmented. I learned a bit of everything from everywhere. I firmly believe that approach will not suffice now; a methodical, step‑by‑step approach is required to get a firm grip of system design concepts quickly. I'll lay out a structured way of mastering system design here. It might feel overwhelming at first, but once you take each concept in isolation and try to understand all its trade‑offs, it will all come together in no time.

Below, I have outlined the structure I would recommend:

  1. Watch mock interviews of senior engineers. Watching mock interviews of highly skilled engineers will give you a fair idea of the building blocks of efficient, scalable systems. In these interviews, engineers explain their thought process and the trade‑offs they're making. I personally found them quite insightful. For example, I learned how companies like X use change data capture (CDC) through a mock interview on Hello Interview. We learn by watching others do what we desire to be. You'll find some of these interviews on Hello Interview and I Got An Offer.

  2. Learn core concepts. Build a foundation in system design by understanding key principles:

    • Latency vs. throughput: Latency measures speed (how long it takes a single request to complete), while throughput measures capacity (how many requests a system can handle per unit time).
    • Fault tolerance: Know how a system continues working in spite of failures, e.g., through graceful degradation and redundancy.
    • Synchronous vs. asynchronous communication: Be clear on when to use each.
    • Writing to disk vs. writing to RAM: Understand how storage choices affect performance. For example, Kafka relies on sequential disk writes and the operating system’s page cache to achieve high throughput.

  3. The building blocks.

    • API gateways and load balancing: Learn load‑balancing algorithms like round‑robin and least connections, and the advantages of each. Study API gateways and how they handle routing and rate limiting.
    • Content delivery networks (CDNs): See how CDNs cache content close to users to reduce round‑trips.
    • Message queues: Essential for event‑driven designs; they handle asynchronous tasks.
    • Caching: Caching is critical for reducing latency.
    • Circuit breakers: Prevent cascading failures and improve fault tolerance.
    • Stateful vs. stateless design: Stateless systems do not retain session data and therefore scale more easily; they enable parallel code execution and high scalability. Explore why and when to use each approach.

  4. Databases.

    • SQL, NoSQL, Graph Databases, Key-Value Store, Vector Databases, Timeseries Databases, Wide Column Databases: Understand their trade‑offs.
    • OLTP vs. OLAP: Know the distinction between transactional (OLTP) and analytical (OLAP) workloads.
    • Full‑text search: Traditional SQL queries (e.g., LIKE) are inefficient for large‑scale text searches. Tools such as Elasticsearch or Algolia provide specialized indexing and search capabilities.
    • Indexes: Learn why and when to apply indexes.
    • Debugging slow queries: Practice analyzing and optimizing queries in production.
    • Sharding: Explore strategies for distributing data across multiple nodes.
    • Consistent hashing: An algorithm that evenly distributes data across a cluster and minimizes data movement when nodes are added or removed.
    • Replication: Understand how data is replicated for high availability.
    • ACID transactions: ACID stands for atomicity, consistency, isolation and durability. Each property ensures data integrity.
    • Partitioning: Learn how partitioning improves database performance.
    • Strong vs. eventual consistency: Know when each consistency model is appropriate.

  5. APIs.

    • Authentication and authorization: Authentication answers “Who are you?” and authorization answers “What can you do?” Explore role‑based permissions, attribute‑based control and OAuth.
    • Pagination: Understand offset‑based versus cursor‑based pagination.

  6. Big data.

    • Batching vs. streaming: Recognize when streaming is more suitable for event‑driven architectures.

  7. Learn from real‑world systems and courses. Read engineering blog posts from companies like Shopify, Netflix, Facebook and Google Drive to see how they solve challenges at scale. Courses such as Alex Xu’s ByteByteGo and the System Design School are great resources.

  8. Architectural patterns. Use patterns as blueprints:

    • Client–server architecture: Understand the basic two‑tier model and its limitations.
    • Microservices architecture: Learn how to break monolithic applications into independently deployable services.
    • Serverless architecture: Explore functions‑as‑a‑service offerings like AWS Lambda or Azure Functions.
    • Event‑driven architecture: Learn how events orchestrate workflows in systems like e‑commerce and IoT.
    • Peer‑to‑peer architecture: Study decentralized systems such as torrents or blockchains.

  9. Practice. Design systems you use every day: your blog, your social media apps, etc. Practice consistently, do mock interviews, and seek feedback.