Free lesson · System Design Fundamentals

Course Introduction

Easy4 min readsystem-designhlddistributed-systems

Lesson 1.1 - Course Introduction

The first lesson of the entire course.

My name is Brandon Carter. I'm a Principal Software Engineer at Amazon Web Services, where I work on S3 - the storage system that holds hundreds of exabytes of the world's data. Before Amazon, I spent 6 years at Stripe building payment infrastructure that processed over 100 million transactions per day. Before Stripe, I was at IBM writing enterprise Java. Before IBM, I was a first-generation college student at Georgia Tech who graduated into the 2008 financial crisis and didn't know what a Binary Search Tree was.

I failed Google's interview twice before I passed Amazon's. The first time, I didn't have the knowledge. The second time, I had the knowledge but couldn't communicate it under pressure. This course exists so you can build the knowledge faster than I did - and the companion courses exist so you can communicate it better than I did on attempt two.

What This Course Is

Interactive animation: System design is the layer above code: four questions, asked every time.

System Design Fundamentals is a comprehensive course covering the full landscape of modern system design - from networking protocols to distributed databases, from caching strategies to container orchestration, from reliability patterns to observability. It's the knowledge layer: what systems are made of, how the pieces fit together, and why engineers make the choices they make.

The course covers 30 modules and 176 lessons, grouped into seven stretches. That's a lot. It's intentionally comprehensive - a learner who finishes this course can read, contribute to, and lead any system design conversation. The breadth is the point.

What this course will give you:

A mental model for how production systems work - from a single server to a globally distributed platform
The vocabulary to discuss trade-offs (consistency vs availability, latency vs throughput, simplicity vs flexibility)
Deep understanding of specific technologies (PostgreSQL, Redis, Kafka, S3, Kubernetes, and more)
The reliability instinct - the habit of asking "what happens when this fails?"
Production stories from engineers at Google, Amazon, Meta, Netflix, and Apple

What this course will NOT give you:

Interview performance. Knowing system design and performing in a system design interview are different skills. That's what the Interviews course is for.
Hands-on lab exercises. This course teaches concepts and trade-offs, not step-by-step tutorials.
Coding practice. DSA and coding interviews are separate domains.

The Trilogy

This course is the first of three:

flowchart LR
    F["System Design<br/>Fundamentals<br/>(this course)<br/>30 modules · 176 lessons"]
    A["System Design<br/>Advanced<br/>~20 modules"]
    I["System Design<br/>Interviews<br/>~8 modules"]
    
    F -->|"knowledge"| A
    F -->|"performance"| I
    A -->|"depth"| I

    style F fill:#fbbf24,stroke:#f59e0b,color:#000
    style A fill:#a78bfa,stroke:#8b5cf6,color:#000
    style I fill:#34d399,stroke:#10b981,color:#000

A diagram showing the three-course trilogy. System Design Fundamentals is the first course - thirty modules and a hundred and seventy-six lessons covering the full knowledge landscape. It feeds into two paths. The first path leads to System Design Advanced - approximately 20 modules covering genuinely advanced topics like Multi-Paxos, Byzantine fault tolerance, ML systems design, edge computing, and zero-trust security. The second path leads to System Design Interviews - approximately 8 modules teaching 20 reusable interview patterns and the structured approach for performing under pressure. You can take Advanced or Interviews in either order after Fundamentals. Advanced deepens your knowledge; Interviews teaches you to deploy that knowledge in a 45-minute interview. Most learners preparing for interviews take Fundamentals then Interviews. Engineers seeking production depth take Fundamentals then Advanced.

Fundamentals gives you the knowledge. Advanced gives you depth beyond what any competitor covers. Interviews teaches you to perform under the time pressure and communication demands of a real system design interview.

You don't need all three. Fundamentals alone is a complete education in system design. Advanced is for engineers who want production-level depth. Interviews is for engineers actively preparing for FAANG-level interviews. Take what you need.

Who Built This

This course is primarily authored by me (Brandon), but it's not a solo effort. AlgoInsight was built by seven engineers who have collectively been rejected by FAANG companies 58 times before eventually receiving offers. Today we work at Google, Meta, Amazon, Microsoft, Apple, and Netflix.

Throughout this course, you'll hear from:

Nikhil Joshi (Google, Distributed Systems) - on Spanner, replication, and consensus
Emeka Okafor (Netflix, Data Infrastructure) - on Kafka, streaming, and data pipelines at 8 billion events per day
Deepika Nair (Meta, AI Infrastructure) - on Kubernetes for distributed ML training and vector databases

Their voices appear as guest lessons in their domains of expertise - a different perspective, a different career story, a different set of production experiences. The course is richer for having multiple engineers who've lived the material.

How to Use This Course

Interactive animation: The rhythm that finishes: watch, read, practise, repeat.

Read in order, at least the first time. The modules build on each other - caching references databases, distributed systems reference networking, reliability patterns reference everything. Jumping to Module 30 without the foundation will feel like reading the middle of a novel.

Pace yourself. At one lesson a day, you'll finish in about six months. Modules vary from two lessons to twelve, so lessons are the steadier unit to plan around. Some learners go faster; some go slower. There's no deadline.

Use the AI summaries. Every lesson has an AI-generated summary - a compressed version for review and recall. Read the full lesson first; use the summary when you're revisiting.

Do the exercises. Every lesson ends with three exercises (Warmup, Core, Stretch). At minimum, do the Warmup - it takes 10-15 minutes and reinforces the core concept. The Stretch exercises are for learners who want depth.

Take notes in your own words. The act of rephrasing forces understanding. If you can't explain a concept in your own words, you don't understand it yet.

What's Next

Lesson 1.2 maps the full course - all seven stretches, all 30 modules, all 176 lessons, with pacing guidance and milestones so you know where you are in the journey.

Back to System Design Fundamentals