Netflix
Backend System Design
7 hours, 17 minutes
CC
Course Description
Everything is a System! Grab your favorite diagramming tool and develop the system-thinking skills to solve complex backend design challenges related to scaling, data storage, reliability, and performance. Discover that every architecture decision comes with tradeoffs and approach your next complex distributed system design with confidence.
This course and others like it are available as part of our Frontend Masters video subscription.
Preview
What They're Saying
This is a solid course that covers the core concepts of backend system design.
Michał Mikołajewicz
Course Details
Published: December 19, 2025
Rating
Learn Straight from the Experts Who Shape the Modern Web
Your Path to Senior Developer and Beyond
- 250+ In-depth courses
- 24 Learning Paths
- Industry Leading Experts
- Live Interactive Workshops
Table of Contents
Introduction
Section Duration: 16 minutes
Jem Young introduces the course by discussing the importance of scoping in system design, sharing lessons from past interview failures. He also covers what makes a quality system, relevant metrics, and key aspects of scaling, including the CAP theorem and trade-offs in system design.
Jem introduces systems thinking, explaining how understanding component interactions helps with seeing the big picture. He stresses planning, designing for flexibility, and using diagramming to communicate and collaborate effectively.
Recognizing Systems
Section Duration: 43 minutes
Jem emphasizes the importance of recognizing the systems around us, using home remodeling and car components to show how uncovering hidden complexities can improve understanding and effectiveness.
Jem instructs students to design a pizza shop by outlining the ordering process and creating a flow diagram. He encourages comparing approaches, emphasizing breaking tasks into steps and the value of critical thinking in system design.
Jem explains that distributed systems involve parts located in different places to handle failure and scalability. He also walks through the core components of a system design, including clients, databases, servers, load balancers, and caches, emphasizing their roles and importance in building products or services.
Jem guides students through the visualizing flow of data exercise to map information flow between clients, servers, caches, and databases. He explores variations like mobile clients and specialized caches, emphasizing understanding components and boundaries for effective system design.
Requirements
Section Duration: 1 hour, 54 minutes
Jem explains 'how to build anything' by breaking systems into core components, using an example of a bathroom remodel. He stresses translating business requirements and demonstrates designing a to-do app by scoping, defining requirements, and considering user interactions.
Jem instructs students to scope a mobile banking app to a single account and define functional requirements. He emphasizes understanding the domain and encourages analyzing existing apps while considering transactions, security, and performance.
Jem guides students through designing a URL shortening service, focusing on functional and non-functional requirements. Consider security, capacity, user levels, and link expiration, and emphasize critical thinking, MVP features, and understanding the domain.
Jem guides students through CRUD apps, explaining create, read, update, and delete operations. Using a to-do app example, he covers functional requirements like viewing, creating, editing, deleting, and other features such as sorting and filtering.
Jem discusses the CAP theorem, explaining consistency vs. availability trade-offs in distributed systems. Using the example of his old car, he highlights reliability and covers key metrics like availability, resiliency, and consistency in system design.
Jem instructs students to consider trade-offs in system design, prioritizing properties like consistency and availability across applications such as banking apps, URL shorteners, and online stores. He emphasizes weighing decisions carefully, understanding requirements, and acknowledging inevitable failures in distributed systems.
Jem introduces system quality, emphasizing reliability, observability, security, scalability, adaptability, and performance. He discusses trade-offs and the importance of considering user behavior, seasonality, and cost when meeting non-functional requirements.
Jem introduces non-functional requirements, emphasizing their role in ensuring system quality. He also explains how to define them by considering system performance, security measures, scalability, expected user load, request rates, and data protection needs.
Jem instructs students to consider non-functional requirements for a banking app, focusing on system quality beyond user functions. He guides them to address security, performance, observability, encryption, audit trails, availability, and compliance.
Jem instructs students to consider non-functional requirements for URL shorteners, covering response time, latency, and URL length. He also discusses setting parameters like maximum URL length and expiration, highlighting impacts on database choices and system efficiency.
High-Level Design
Section Duration: 19 minutes
Jem discusses data modeling, emphasizing understanding requirements and creating clear specifications. He also covers entity modeling and API design, including defining system actions and determining entities, properties, and relationships.
Jem discusses HTTP protocols, its stateless nature, and the role of context and metadata. He also covers WebSockets for bi-directional communication and compares protocols like gRPC, REST, and GraphQL.
Jem walks students through protocol scenarios, comparing WebSockets and HTTP for real-time updates and trade-offs like battery use. He discusses which protocols suit each case, using examples such as REST for banking APIs and gRPC for microservices and video processing.
Jem demonstrates API design by translating business requirements into code, emphasizing listing endpoints for simplicity and efficiency. He notes that after defining entities and APIs, the next step is addressing data flow and scaling.
Scaling
Section Duration: 12 minutes
Jem introduces system scaling, explaining the differences between vertical scaling (adding power to one server) versus horizontal scaling (adding servers). He also discusses trade-offs, including complexity in horizontal scaling and potential bottlenecks and costs in vertical scaling.
Jem discusses the role of load balancers in horizontal scaling to manage multiple servers efficiently. He explains their importance for system stability and scalability and discusses considerations like refactoring code and preventing bottlenecks during scaling.
Jem demonstrates adding a load balancer to a todo app, showing its placement and function. He also demonstrates how to sketch a cluster setup, explains scaling with multiple servers, and briefly discusses using a cache to handle high user loads efficiently.
Data Storage
Section Duration: 2 hours, 16 minutes
Jem introduces common system design components, stressing domain understanding over structure. He covers scoping problems (and stating what’s out of scope in interviews) and explains when to choose relational vs. non-relational databases, emphasizing simple solutions based on data and storage needs.
Jem explains the differences between relational and non-relational databases, including data consistency, schema flexibility, migration costs, and scaling. He emphasizes choosing the right database early to avoid expensive changes and to scale effectively.
Jem introduces non-relational (NoSQL) databases and outlines four main families, including document stores, key value stores, and column databases. He highlights common examples like MongoDB, Redis, DynamoDB, Cassandra, and HBase, explaining their strengths in flexibility, speed, caching, and handling less structured data.
Jem explains how relational databases scale using partitioning and sharding, outlining how each improves performance. He emphasizes understanding data distribution and choosing the right shard key to scale effectively while preserving transactions.
Jem explains database availability, focusing on uptime, replication, and preventing data loss. He covers replication approaches and trade-offs, and emphasizes combining strategies to ensure resiliency and performance.
Jem introduces caching as storing frequently used data close to where it is needed to reduce latency and load. He covers common caching strategies and their trade-offs between performance, consistency, and complexity.
Jem explains cache as a secondary data store, focusing on the balance between performance and freshness. He covers cache invalidation, eviction strategies, and how to choose the right approach for a given use case.
Jem introduces estimations as a way to understand system scale and bottlenecks using reasonable assumptions. He demonstrates this with an example estimating database storage for 100,000 users.
Jem explains how to scale a system for higher traffic by reviewing core technologies, adding caching, and applying vertical scaling and partitioning. He also covers using read replicas to handle heavy load efficiently.
Jem introduces autosave for to-dos, covering trade-offs like save frequency, read write ratios, and cross-device syncing. He also highlights added complexity around permissions, metadata, and collaborative editing.
Security
Section Duration: 18 minutes
Jem explains how HTTPS termination works, where encrypted traffic should be decrypted, and the performance trade-offs involved. He compares terminating at the load balancer versus keeping traffic encrypted end-to-end for sensitive or compliant systems, highlighting the security risks of internal services and logging.
Jem explains the difference between authentication and authorization, and why each matters in secure, scalable systems. He compares sessions, JWTs, and other auth strategies, highlighting trade-offs between stateful and stateless approaches in distributed and microservice architectures.
Asynchronous Workflows
Section Duration: 1 hour, 12 minutes
Jem introduces asynchronous workflows, explaining how tasks can be queued and processed without blocking the main system, improving responsiveness and scalability. He covers components like message brokers, queues, and worker pools, and emphasizes the importance of notifications, back pressure, and careful use to avoid added complexity.
Jem outlines a video upload service, covering formats, resolution, file size, thumbnails, and audio handling. He emphasizes simplifying assumptions and realistic user load to plan the workflow before building the system.
Jem defines key entities for a video upload system and outlines a workflow where users upload videos, the system stores and processes them into multiple resolutions, and users are notified when processing is complete.
Jem outlines a video upload system with a web server, source video storage, a notification service, a processing service, and a metadata database, emphasizing asynchronous workflows and clear separation of responsibilities.
Jem diagrams a video upload system, showing the server, storage, processing services, worker pools, and a notification service, emphasizing stateless, asynchronous workflows and data flow between components.
Wrapping Up
Section Duration: 2 minutes
Jem wraps up the course by emphasizing the importance of building high-level architecture first, reasoning through assumptions step by step, and understanding trade-offs in system design. He highlights key lessons on async workflows, message brokers, databases, and making practical design decisions.
Learn Straight from the Experts Who Shape the Modern Web
- 250+In-depth Courses
- Industry Leading Experts
- 24Learning Paths
- Live Interactive Workshops