0 of 49 done
Start here01 — System Design Fundamentals

What software architecture is

Software architecture is planning how the parts of a large system fit together, so it can serve many users, keep working when something breaks, and keep its data correct.

A small app can run on one computer with one database. When millions of people use it, that stops working: one computer can’t handle the load, and if it fails, everything goes down. So big systems are spread across many machines, with pieces like load balancers (sharing requests between servers), caches (keeping popular answers ready), and message queues (passing work along to be done later). Architecture is choosing those pieces and how they connect, and understanding the trade-off each choice makes.

The course has two halves. System design is the practical skill of planning a system for a given number of users, speed and reliability; it’s also a standard interview for senior roles. Distributed systems is the theory underneath: why getting many machines to agree is genuinely hard, and the methods that make it work.

What you’ll be able to do

By the end you will be able to:

  • plan a system step by step: work out what it must do, estimate the load, sketch the design, and explain the trade-offs;
  • explain how systems grow to handle more users, and how they stay up when parts fail;
  • choose between building blocks such as caches, queues and different kinds of database;
  • choose between one big app and many small services;
  • explain why machines on a network struggle to agree on what happened and when, and how methods like Raft fix that;
  • answer system design interview questions.

Where to start

Before you start: you should know how a backend and a database work. Networking helps for section 02.

Read the sections in order. Sections 01–03 are system design; section 04 is the theory.

01. System design fundamentals

  1. How to Approach System Design: a step-by-step method for designing a system, which is also how to pass the interview.
  2. Scalability and Performance: making a system handle more by using bigger machines or more machines, and the difference between fast and able-to-handle-a-lot.
  3. Availability and Reliability: keeping a system up, measuring uptime, and having spares ready when something fails.
  4. CAP and Consistency: why, when a network breaks, a system must choose between always answering and always answering correctly.

02. Building blocks

  1. Load Balancing and Proxies: sharing requests across servers, and the servers that sit in front of yours.
  2. Caching: keeping copies of popular data close by, and the hard problem of knowing when a copy is out of date.
  3. Databases at Scale: choosing a database, copying it across machines, and splitting data when one machine isn’t enough.
  4. Messaging and Async: passing work through queues so slow jobs don’t hold up users.
  5. Communication: the different ways services talk to each other: REST, gRPC and GraphQL.

03. Architectural patterns

  1. Monolith, Microservices, Serverless: one big app, many small services, or code that runs only on demand, and when each fits.
  2. Resilience Patterns: designing for failure: retries, time limits, and stopping one broken part from bringing down the rest.
  3. Data and Integration Patterns: ways of keeping data consistent across services, and replacing an old system piece by piece.
  4. Microservices Patterns: how many small services find each other and work together.
  5. Transactional Outbox: saving data and sending a message about it, without ever doing one and not the other.

04. Distributed systems (the theory)

This is harder and more theoretical. It’s what you need for building your own databases or coordination systems.

  1. What Makes Distributed Systems Hard: machines fail partly, networks lose messages, and there’s no shared clock.
  2. Theoretical Limits: what’s been proven impossible, and what that means in practice.
  3. Time and Ordering: working out what happened first without a shared clock.
  4. Consistency Models: the different promises a system can make about how up to date your reads are.
  5. Replication: keeping copies of data on several machines.
  6. CRDTs and Conflict Resolution: data types that can be edited in several places at once and still merge correctly.
  7. Consensus and Paxos: getting machines to agree on one answer even when some fail.
  8. Raft in Depth: the most widely used method for reaching agreement, step by step.
  9. Coordination Services: tools like ZooKeeper and etcd that handle agreement for you.
  10. Distributed Transactions: making a change across several machines all-or-nothing.
  11. Modern Distributed Transactions: how today’s databases do this at scale.
  12. The Log and State Machines: the simple idea at the heart of many reliable systems: an ordered list of everything that happened.
  13. Partitioning: splitting data across machines evenly.
  14. Failure Detection and Membership: noticing when a machine is gone, and keeping track of who’s in the group.
  15. Testing Distributed Systems: how to find bugs that only appear when timing goes wrong.

05. Case studies

  1. Designing Real Systems: putting it all together on real examples.

For quick lookup

  • System design reference: a dense cheat sheet of everything you might draw in a design, for looking up rather than reading.

Practice

  • Projects: hands-on tasks, from easy (🟢) to hard (🔴), each with a clear “done when”.
  • Architecture interview prep: the system design round, and distributed systems in depth.
  • Build Your Own: build your own Redis, database or Raft, the best way to make section 04 real.

Key ideas to remember

  1. Every design choice is a trade-off. There’s no best architecture, only one that fits the needs you wrote down first. → How to Approach System Design
  2. Grow one machine before adding more. Many machines bring problems one machine never has. → Scalability
  3. When the network breaks, you choose between answering and being correct. → CAP
  4. Design for failure. In a large system, something is always broken. → Resilience Patterns
  5. Don’t start with microservices. Split a system only when you know where the natural boundaries are. → Monolith, Microservices, Serverless
  • Backend: one service, in depth.
  • Databases: the storage these systems are built on.
  • DevOps: running these systems for real.

About this course

  • Where it came from: sections 01–03 were checked against the roadmap.sh system design roadmap. There’s no roadmap for distributed systems, so section 04 comes from the standard sources: Designing Data-Intensive Applications (Kleppmann) and MIT’s 6.824 distributed systems course.
↑ Back to Kingsley's Knowledge Base