Design Netflix: System Design Interview Guide

Designing Netflix is a classic system design interview question that tests your ability to architect a large-scale, distributed, and highly available video streaming service. Netflix serves over 200 million subscribers, streaming billions of hours of content monthly. The system must handle massive concurrent users, provide low-latency video playback, and offer personalized recommendations. In this guide, we'll walk through a structured approach to design Netflix, covering requirements, high-level architecture, data models, key components like CDN and adaptive bitrate streaming, and scaling strategies. We'll also discuss common pitfalls and how to ace the interview by communicating your thought process clearly. By the end, you'll be ready to tackle this question with confidence.

1. Requirements Gathering

Start by clarifying functional and non-functional requirements. Functional: user registration/login, browse/search movies, stream video, rate content, get recommendations. Non-functional: high availability (99.99% uptime), low latency (<200ms for metadata, <2s for video start), scalability to millions of concurrent users, durability of user data, and cost efficiency. Also consider geo-distribution for global audience.

2. High-Level Architecture

Design a layered architecture: Client (apps on various devices) -> CDN (for video) -> Load Balancer -> API Gateway -> Microservices (User, Video Metadata, Recommendation, Encoding, etc.) -> Databases (SQL for metadata, NoSQL for user activity) -> Cache (Redis) -> Message Queue (Kafka) for async tasks. Video files are stored in a distributed file system (like S3) and served via CDN. Use adaptive bitrate streaming (HLS or DASH) to adjust quality based on network.

Client (TV, Mobile, Web)
  |
CDN (Akamai, CloudFront)
  |
Load Balancer (ELB)
  |
API Gateway
  |
Microservices: User, Video Metadata, Recommendation, Encoding, Search
  |
Databases: SQL (MySQL sharded), NoSQL (Cassandra for user activity)
  |
Cache: Redis (session, metadata)
  |
Message Queue: Kafka (encoding jobs, analytics)
  |
Object Store: S3 (video files)

3. Data Models

Design schemas for key entities. User: userId (PK), name, email, subscription plan, etc. Video: videoId (PK), title, description, duration, genre, release year, etc. WatchHistory: userId, videoId, timestamp, progress. Ratings: userId, videoId, rating. Use SQL for transactional data (users, videos) with sharding by userId or videoId. Use NoSQL (Cassandra) for high-write user activity (watch history, ratings) with partition key userId and clustering key timestamp.

-- Users table (sharded by user_id)
CREATE TABLE users (
    user_id BIGINT PRIMARY KEY,
    name VARCHAR(255),
    email VARCHAR(255) UNIQUE,
    subscription_plan VARCHAR(50),
    created_at TIMESTAMP
);

-- Videos table (sharded by video_id)
CREATE TABLE videos (
    video_id BIGINT PRIMARY KEY,
    title VARCHAR(255),
    description TEXT,
    duration INT,
    genre VARCHAR(100),
    release_year INT
);

-- Watch history (Cassandra-like)
CREATE TABLE watch_history (
    user_id BIGINT,
    video_id BIGINT,
    timestamp TIMESTAMP,
    progress_seconds INT,
    PRIMARY KEY (user_id, timestamp)
) WITH CLUSTERING ORDER BY (timestamp DESC);

4. Video Streaming and CDN

Video files are large (GBs). Store original videos in S3 and encode into multiple bitrates (240p, 480p, 720p, 1080p, 4K). Use adaptive bitrate streaming: client requests manifest file listing available bitrates, then fetches segments (2-10s chunks) from CDN. CDN caches popular content at edge servers. For less popular content, CDN fetches from origin. Use DNS-based routing to direct user to nearest edge. Implement pre-fetching for next likely video based on recommendations.

#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=1280000,RESOLUTION=720x480
low.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=2560000,RESOLUTION=1280x720
mid.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=7680000,RESOLUTION=1920x1080
high.m3u8

5. Recommendation System

Recommendations are crucial for user engagement. Use a hybrid approach: collaborative filtering (users with similar tastes) and content-based filtering (similar genres, actors). Offline batch processing (Spark) generates recommendations periodically. Online real-time component uses recent user activity to adjust. Store precomputed recommendations in a key-value store (Redis) keyed by userId. For new users, use popularity-based recommendations.

# Simplified recommendation pipeline
from pyspark.ml.recommendation import ALS
from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("NetflixRecs").getOrCreate()
ratings = spark.read.csv("ratings.csv", header=True, inferSchema=True)
# Train ALS model
algo = ALS(userCol="userId", itemCol="videoId", ratingCol="rating")
model = algo.fit(ratings)
# Generate top 10 recommendations for each user
userRecs = model.recommendForAllUsers(10)
userRecs.write.parquet("recommendations.parquet")

6. Scaling and Fault Tolerance

Scale horizontally: add more microservice instances, shard databases, add CDN nodes. Use load balancers (ELB) to distribute traffic. For fault tolerance, implement circuit breakers (Hystrix), retries with exponential backoff, and bulkheads. Use health checks and auto-scaling groups. For data durability, replicate across AZs and regions. Use leader election for critical services (e.g., encoding job scheduler).

7. Search and Browse

Implement search using Elasticsearch for full-text search on video titles, descriptions, and actors. Index videos and update as new content added. For browse, use a combination of precomputed lists (e.g., 'Trending Now', 'New Releases') stored in Redis. Use pagination with cursor-based to avoid offset issues. For autocomplete, use a trie or Elasticsearch's completion suggester.

from elasticsearch import Elasticsearch

es = Elasticsearch()
# Index a video
doc = {
    'title': 'Stranger Things',
    'description': 'A group of kids uncover a dark secret.',
    'actors': ['Winona Ryder', 'David Harbour']
}
es.index(index='videos', id=1, body=doc)
# Search
res = es.search(index='videos', body={'query': {'match': {'title': 'Stranger'}}})

8. Monitoring and Analytics

Collect metrics: CDN latency, video start time, buffering ratio, error rates, database query latency. Use a time-series database (InfluxDB) and visualization (Grafana). Set up alerts for anomalies. For analytics, stream user events (play, pause, search) to Kafka, then process with Spark Streaming for real-time dashboards and batch for business intelligence.