📡 Level 1 — Foundations (Introduction)

Welcome to System Design Mastery! 🚀
This is where every journey in this project begins. Before you design Netflix, Uber, or a billion-user notification system, you need to understand how the internet and distributed systems actually work — DNS, HTTP, load balancers, CDNs, proxies, and fault tolerance.
Everything in this project builds on Level 1. Master these foundations first, then every later module will make sense.

📚 Table of Contents

Project Overview — Why Foundations Matter
How Foundations Build the Full Curriculum
The Foundation Stack — Layers Explained
Real Example: What Happens When You Open a Website
How the Web Works
Load Balancing
DNS — Domain Name System
CDN — Content Delivery Network
Proxies: Forward vs Reverse
Design Patterns in System Design
Server Crashes & Fault Tolerance
Clustering Fundamentals
Native Mobile Stacks
Practice Exercise
Checklist & Deep Dives

1.1 Project Overview — Why Foundations Matter

System Design Mastery (SDM) is a free, structured learning platform that teaches you how to design large-scale distributed systems — the same kind of architectures used at Google, Netflix, Uber, Amazon, and Meta.

What This Project Teaches

Goal	How SDM Helps
Interview preparation	Step-by-step frameworks for system design interviews
Production engineering	Real-world architectures with trade-offs and capacity math
Career growth	Progressive path from beginner to senior architect
Community learning	Open-source docs with diagrams, code, and case studies

Mission in One Sentence

Democratize system design knowledge — make advanced architectural concepts accessible through structured learning, visual diagrams, and real-world examples.

Why Level 1 Comes First

Every advanced topic in this project — scaling, databases, caching, microservices, Kafka, Netflix architecture — assumes you already understand:

How a browser reaches a server (DNS, TCP, HTTP)
How traffic is distributed (load balancers, proxies)
How content is delivered fast globally (CDN)
What happens when a server crashes (fault tolerance, clustering)

text

Without foundations → you memorize patterns but cannot explain WHY they exist.
With foundations     → you design systems with confidence and clear reasoning.

TIP

New to the project? Read the full curriculum map: Complete Guide Life Flow.

1.2 How Foundations Build the Full Curriculum

SDM is organized into 12 progressive levels. Level 1 is the base layer — every other level stacks on top of it.

How Each Foundation Topic Powers Later Levels

Foundation (Level 1)	Used Later In	Real Example
DNS	All levels	Resolving `api.netflix.com` to the right region
Load Balancing	Scalability, Microservices	Distributing 1M req/sec across API servers
CDN	Caching, Real-World Systems	Serving Instagram images from Tokyo edge node
Reverse Proxy	Microservices, API Gateway	Nginx routing `/orders` to Order Service
HTTP / Protocols	APIs, gRPC, Messaging	REST endpoints, WebSocket chat
Fault Tolerance	Design Patterns, Monitoring	Circuit breaker when Payment Service is down
Clustering	Scalability, Databases	Horizontal scaling of stateless web servers
Architecture Layers	Case Studies, Interview Prep	Client → LB → API → Cache → DB diagram

INFO

The homepage Get Started button links directly here — because every learner must start with foundations before jumping to Netflix or Uber case studies.

1.3 The Foundation Stack — Layers Explained

Every modern web application follows the same layered pattern. Level 1 teaches you each layer so you can draw this diagram in any interview.

Layer Responsibilities

Layer	Job	Analogy
DNS	Translate `google.com` → IP address	Phone book for the internet
CDN	Serve images/CSS/JS from servers near the user	Local warehouse instead of shipping from HQ
Load Balancer	Spread requests across multiple servers	Traffic cop at a busy intersection
API Servers	Run business logic (login, post, pay)	The brain of the application
Cache	Store hot data in memory for speed	Sticky notes on your desk for frequent lookups
Database	Permanent storage — source of truth	Filing cabinet with all records
Object Storage	Store large files (images, videos)	Cloud photo album (S3, GCS)

TIP

Full breakdown with code: High-Level System Architecture

1.4 Real Example: What Happens When You Open a Website

This is the classic interview question and the best way to see all Level 1 concepts working together. When you type https://google.com in your browser:

Step-by-Step (Plain English)

DNS — Browser asks "where is google.com?" and gets an IP address
TCP + TLS — Secure connection is established (HTTPS)
CDN — Static assets (images, CSS) served from a nearby edge server
Load Balancer — Dynamic requests routed to one of many web servers
Web Server — Processes the request, talks to database if needed
Response — HTML or JSON sent back to your browser

TIP

Full deep dive with caching layers: What Happens When You Type Google.com

1.5 How the Web Works

When you type a URL in your browser, a complex sequence of events is triggered to resolve the name and fetch the content.

System Architecture Flow

HTTP Request-Response Cycle

💻 JS Example: Basic Fetch

Most web interactions start with a fetch request in JavaScript.

javascript

async function getPageData() {
  try {
    const response = await fetch("https://api.example.com/data");
    if (!response.ok) throw new Error("Network response was not ok");
    const data = await response.json();
    console.log("Success:", data);
  } catch (error) {
    console.error("Error fetching data:", error);
  }
}

TIP

Protocols deep dive: Protocols & Communication · Networking Fundamentals

1.6 Load Balancing

A Load Balancer distributes incoming traffic across multiple servers so no single server is overwhelmed. It is the foundation of horizontal scaling.

Types of Load Balancing

Type	Description	Use Case
Round Robin	Each server gets requests in turn	Equal server capacity
Least Connections	Sends to least busy server	Varying request lengths
IP Hash	Same client → same server	Session persistence
Weighted	Powerful servers get more traffic	Mixed hardware

Visualizing Load Distribution

💻 JS Example: Simplified Round Robin

javascript

class LoadBalancer {
  constructor(servers) {
    this.servers = servers;
    this.currentIndex = 0;
  }

  getNextServer() {
    const server = this.servers[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.servers.length;
    return server;
  }
}

const lb = new LoadBalancer(["Server-A", "Server-B", "Server-C"]);
console.log(lb.getNextServer()); // Server-A
console.log(lb.getNextServer()); // Server-B

TIP

Deep dive: Load Balancing Algorithms

1.7 DNS — Domain Name System

DNS translates human-readable domain names (like example.com) to IP addresses computers understand.

DNS Resolution Flow

TIP

Deep dive: DNS Lookup & Resolution

1.8 CDN — Content Delivery Network

CDNs cache static content (images, CSS, JS) at servers close to users globally to reduce latency. Used by Netflix, Instagram, and every major website.

CDN Flow Diagram

INFO

CDN optimization is covered in depth at Level 4 — CDN Optimization.

1.9 Proxies: Forward vs Reverse

NOTE

Forward Proxy: Protects/hides the client (e.g., corporate firewall). Reverse Proxy: Protects/optimizes the server (e.g., Nginx in front of API servers).

Visual Comparison

💻 JS Example: Reverse Proxy Logic (Node.js style)

javascript

const http = require("http");
const httpProxy = require("http-proxy");

const proxy = httpProxy.createProxyServer({});

http
  .createServer((req, res) => {
    const target = "http://localhost:8080";
    console.log(`Forwarding request to: ${target}`);
    proxy.web(req, res, { target });
  })
  .listen(3000);

1.10 Design Patterns in System Design

Understanding how design patterns (micro level) fit into system design (macro level) is crucial for this project.

Level	Scope	Example
Code patterns	Single application	Singleton, Factory, Observer
System patterns	Distributed architecture	Circuit Breaker, Saga, Event Sourcing

Dedicated guides in this module:

GoF Design Patterns — micro level / code structure
System Design Interview Patterns — macro level / architecture

INFO

Advanced patterns live at Level 9 — Design Patterns.

1.11 Server Crashes & Fault Tolerance

In distributed systems, we assume servers will crash. Health checks, redundancy, and stateless servers keep the system alive.

Redundancy & Re-routing

TIP

Deep dive: What Happens When Servers Crash?

1.12 Clustering Fundamentals

A cluster is a group of servers (nodes) that work together as one system. Clusters are the foundation for horizontal scaling and high availability.

The Cluster Model

TIP

Deep dive: Clustering Fundamentals

1.13 Native Mobile Stacks

Choosing how to build native mobile apps affects team skills, release process, and OS integration. Compare React Native, Flutter, and Kotlin (Android native) — and when Kotlin Multiplatform fits.

TIP

Deep dive: Native Mobile Stacks — React Native vs Flutter vs Kotlin

🧪 Practice Exercise

Design the networking layer for a simple blog — this exercise ties every Level 1 concept together:

1 million monthly readers
Static images + dynamic posts
Global audience

Think through: DNS → CDN → Load Balancer → Web Servers → Database

👉 View the Full Solution

✅ Checklist Before Moving On

[ ] I understand why Level 1 is the base of the entire SDM project
[ ] I can draw the foundation stack (Client → DNS → CDN → LB → API → Cache → DB)
[ ] I can explain what happens when you type a URL in the browser
[ ] I understand how DNS resolves a domain name
[ ] I can explain what a load balancer does and name 2 algorithms
[ ] I know the difference between forward and reverse proxy
[ ] I understand what a CDN is used for
[ ] I know why fault tolerance and clustering matter
[ ] I completed the simple blog practice exercise

📖 All Deep Dives in This Module

Topic	Page
Complete curriculum map	Guide Life Flow
Type google.com — full breakdown	What Happens When You Type Google
High-level architecture layers	High-Level Architecture
Networking fundamentals	Networking
Protocols (HTTP, TCP, WebSocket)	Protocols & Communication
DNS resolution & caching	DNS Lookup
Load balancing algorithms	Load Balancing Algorithms
Fault tolerance & crashes	Fault Tolerance & Crashes
Clustering & HA	Clustering Fundamentals
GoF design patterns	Design Patterns
System design patterns	System Design Patterns
Mobile stack comparison	Native Mobile Stacks
Simple blog practice	Practice: Simple Blog
Personal learning journey	How I Learned System Design

➡️ Next: Level 2 — Scalability

📡 Level 1 — Foundations (Introduction) ​

📚 Table of Contents ​

1.1 Project Overview — Why Foundations Matter ​

What This Project Teaches ​

Mission in One Sentence ​

Why Level 1 Comes First ​

1.2 How Foundations Build the Full Curriculum ​

How Each Foundation Topic Powers Later Levels ​

1.3 The Foundation Stack — Layers Explained ​

Layer Responsibilities ​

1.4 Real Example: What Happens When You Open a Website ​

Step-by-Step (Plain English) ​

1.5 How the Web Works ​

System Architecture Flow ​

HTTP Request-Response Cycle ​

💻 JS Example: Basic Fetch ​

1.6 Load Balancing ​

Types of Load Balancing ​

Visualizing Load Distribution ​

💻 JS Example: Simplified Round Robin ​

1.7 DNS — Domain Name System ​

DNS Resolution Flow ​

1.8 CDN — Content Delivery Network ​

CDN Flow Diagram ​

1.9 Proxies: Forward vs Reverse ​

Visual Comparison ​

💻 JS Example: Reverse Proxy Logic (Node.js style) ​

1.10 Design Patterns in System Design ​

1.11 Server Crashes & Fault Tolerance ​

Redundancy & Re-routing ​

1.12 Clustering Fundamentals ​

The Cluster Model ​

1.13 Native Mobile Stacks ​

🧪 Practice Exercise ​

✅ Checklist Before Moving On ​

📖 All Deep Dives in This Module ​

📡 Level 1 — Foundations (Introduction)

📚 Table of Contents

1.1 Project Overview — Why Foundations Matter

What This Project Teaches

Mission in One Sentence

Why Level 1 Comes First

1.2 How Foundations Build the Full Curriculum

How Each Foundation Topic Powers Later Levels

1.3 The Foundation Stack — Layers Explained

Layer Responsibilities

1.4 Real Example: What Happens When You Open a Website

Step-by-Step (Plain English)

1.5 How the Web Works

System Architecture Flow

HTTP Request-Response Cycle

💻 JS Example: Basic Fetch

1.6 Load Balancing

Types of Load Balancing

Visualizing Load Distribution

💻 JS Example: Simplified Round Robin

1.7 DNS — Domain Name System

DNS Resolution Flow

1.8 CDN — Content Delivery Network

CDN Flow Diagram

1.9 Proxies: Forward vs Reverse

Visual Comparison

💻 JS Example: Reverse Proxy Logic (Node.js style)

1.10 Design Patterns in System Design

1.11 Server Crashes & Fault Tolerance

Redundancy & Re-routing

1.12 Clustering Fundamentals

The Cluster Model

1.13 Native Mobile Stacks

🧪 Practice Exercise

✅ Checklist Before Moving On

📖 All Deep Dives in This Module