Netflix

Functional Requirements

Core Features

1. Browse Catalog — Users explore content by genre, category, trending, new releases, and "Top 10" lists
2. Search — Full-text search across titles, actors, directors, genres with autocomplete and typo tolerance
3. Stream Video — Play video content with adaptive quality, pause/resume, seek, and subtitle support
4. Multiple Profiles — Up to 5 profiles per account with personalized recommendations per profile
5. Watchlist — Users add/remove titles for later viewing across devices
6. Continue Watching — Resume playback from the exact position across any device
7. Download for Offline — Download select titles to mobile devices for offline viewing
8. Parental Controls — Content filtering by maturity rating per profile

Non-Functional Requirements

Requirement	Target
Availability	99.99% uptime (< 52 min downtime/year)
Latency	Video startup < 2 seconds globally
Throughput	15% of total global internet bandwidth during peak
Concurrency	200M+ active subscribers simultaneously
Scalability	Linear scaling with subscriber growth
Consistency	Eventually consistent for catalog; strong for user state

Key Constraints

• Video files are large (GBs per title for 4K)
• Global audience across 190+ countries
• Peak hours: 8PM-midnight local time in each region
• Must handle 100M+ hours of content viewed daily
• Device diversity: Smart TVs, phones, tablets, browsers, gaming consoles

---

Capacity Estimation

Assumptions:
- 200M subscribers, 80% active monthly
- Average viewing: 2 hours/day
- Average bitrate: 5 Mbps (1080p)
- Video chunks: 5 seconds each

Bandwidth per user: 5 Mbps = 0.625 MB/s
Peak concurrent: ~50M users
Peak bandwidth: 50M * 0.625 MB/s = 31.25 TB/hour

Storage per movie (2 hours, 1080p, H.264):
  - Bitrate: 5 Mbps
  - Size: 5 Mbps * 7200s = 4.5 GB per title per resolution
  - Average 5 resolutions per title: 22.5 GB per title
  - 15,000 titles: ~337 TB raw content storage

Cache hit target: 95%+ of requests served from CDN edge

Netflix Open Connect Architecture

Netflix built its own CDN called Open Connect — purpose-built for video streaming rather than using public CDNs like Akamai or CloudFront.

Open Connect Appliance (OCA)

Netflix deploys custom storage/serving appliances (OCAs) inside ISP networks:

┌─────────────────────────────────────────────────────────┐
│                    Netflix Origin (S3)                  │
│              (Video files, all resolutions)             │
└──────────────────────┬──────────────────────────────────┘
                       │
         ┌─────────────┼─────────────────┐
         ▼             ▼                 ▼
   ┌──────────┐  ┌──────────┐      ┌──────────┐
   │ Regional │  │ Regional │ ...  │ Regional │
   │ Pop #1   │  │ Pop #2   │      │ Pop #N   │
   │(LA)      │  │(London)  │      │(Tokyo)   │
   └────┬─────┘  └────┬─────┘      └────┬─────┘
        │              │                 │
   ┌────┴─────┐  ┌────┴─────┐      ┌────┴─────┐
   │ ISP Peer │  │ ISP Peer │      │ ISP Peer │
   │ OCA      │  │ OCA      │      │ OCA      │
   │(inside   │  │(inside   │      │(inside   │
   │ ISP DC)  │  │ ISP DC)  │      │ ISP DC)  │
   └──────────┘  └──────────┘      └──────────┘
        │              │                 │
   ┌────┴─────┐  ┌────┴─────┐      ┌────┴─────┐
   │ End      │  │ End      │      │ End      │
   │ Users    │  │ Users    │      │ Users    │
   └──────────┘  └──────────┘      └──────────┘

How Open Connect Works

1. Placement: Netflix negotiates with ISPs worldwide to place OCA servers inside their data centers (colocation)
2. Content Popularity Analysis: ML models predict which content will be popular in each region
3. Pre-positioning: Popular content is pushed to OCAs during off-peak hours (typically 2-6 AM)
4. Routing: Netflix's control plane directs users to the optimal OCA based on:
   • Geographic proximity
   • ISP routing efficiency
     n - Current load on each OCA
   • Content availability on that OCA

Multi-Tier CDN Hierarchy

Tier 1: Origin (S3) ─── All content, all resolutions
     │
Tier 2: Regional Points of Presence ─── Top 5000 titles per region
     │
Tier 3: Open Connect Appliances (inside ISPs) ─── Top 1000 titles per ISP cluster
     │
Tier 4: Client-side cache ─── Current session chunks

OCA Specifications

Spec	Detail
Storage	100-200 TB per appliance
Throughput	10+ Gbps per appliance
Form factor	Custom 2U-4U rack server
Content	~2000-5000 most popular titles per region
Lifecycle	3-4 year refresh cycle
Deployed	1000s of OCAs across 6000+ ISP locations globally

Request Flow for Video Playback

1. User clicks "Play" on title X
2. Client → Netflix API Gateway → Streaming Service
3. Streaming Service checks: Is this content cached on a nearby OCA?
4. If YES → Return OCA URL + manifest file → Client streams from OCA
5. If NO → Check Regional PoP → If there, stream from PoP
6. If still NO → Stream from Origin (rare, only for very long-tail content)
7. The client receives a redirect URL pointing to the optimal OCA
8. Client fetches video chunks from that OCA

Benefits of Open Connect

• Cost: Eliminates CDN fees by owning infrastructure (saves $100M+/year)
• Performance: Direct ISP peering reduces latency to < 10ms for most users
• Control: Custom hardware optimized specifically for video serving
• Scalability: New OCAs added proportionally to ISP subscriber growth
• Reliability: Multiple tiers ensure content availability even if OCAs fail

Adaptive Bitrate Streaming (ABR)

Netflix uses HTTP-based adaptive bitrate streaming. The core idea: split video into small chunks and let the client dynamically switch between quality levels based on network conditions.

Video Processing Pipeline

Raw Video Upload
     │
     ▼
┌─────────────────────────────────────┐
│         Transcoding Service          │
│  ┌─────────────────────────────────┐ │
│  │ 1. Decode source video          │ │
│  │ 2. Scale to multiple resolutions│ │
│  │ 3. Encode with multiple codecs  │ │
│  │ 4. Generate multiple bitrates   │ │
│  │ 5. Create manifest files        │ │
│  └─────────────────────────────────┘ │
└──────────────────┬──────────────────┘
                   ▼
┌─────────────────────────────────────┐
│           S3 Storage                │
│  video/title_id/                    │
│    ├── 1080p_6000k.mp4              │
│    ├── 720p_3000k.mp4               │
│    ├── 480p_1500k.mp4               │
│    ├── 360p_1000k.mp4               │
│    ├── manifest.mpd (DASH)          │
│    └── manifest.m3u8 (HLS)          │
└─────────────────────────────────────┘

Bitrate Ladder

Netflix defines a bitrate ladder — a set of resolution/bitrate combinations for each video:

Resolution	Video Bitrate	Audio Bitrate	Codec	Use Case
3840×2160 (4K UHD)	16 Mbps	192 kbps	H.265/HEVC	4K displays
1920×1080 (Full HD)	6 Mbps	192 kbps	H.264/H.265	Standard HD
1280×720 (HD)	3 Mbps	128 kbps	H.264	Mobile/tablet
854×480 (SD)	1.5 Mbps	128 kbps	H.264	Slow connections
640×360	750 kbps	64 kbps	H.264	Low bandwidth
426×240	400 kbps	64 kbps	H.264	Ultra-low bandwidth

Video Chunking

┌────────────────────────────────────────────────────┐
│              Full Movie (2 hours)                  │
│  Total: 120 minutes * 60 seconds = 7200 seconds   │
└────────────────────────────────────────────────────┘
                    │
                    ▼ Split into chunks
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │...│   │   │ 360│
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
 Each chunk: 2-10 seconds (Netflix typically uses 5 seconds)
 Each chunk exists at EVERY bitrate level

Manifest Files

DASH Manifest (MPD) — XML-based, describes all available representations:

<?xml version="1.0" encoding="UTF-8"?>
<MPD mediaPresentationDuration="PT7200S">
  <Period>
    <AdaptationSet mimeType="video/mp4">
      <Representation id="1080p" bandwidth="6000000" width="1920" height="1080">
        <SegmentTemplate timescale="1" media="1080p_$Number$.m4s" duration="5"/>
      </Representation>
      <Representation id="720p" bandwidth="3000000" width="1280" height="720">
        <SegmentTemplate timescale="1" media="720p_$Number$.m4s" duration="5"/>
      </Representation>
      <Representation id="480p" bandwidth="1500000" width="854" height="480">
        <SegmentTemplate timescale="1" media="480p_$Number$.m4s" duration="5"/>
      </Representation>
    </AdaptationSet>
  </Period>
</MPD>

HLS Manifest (M3U8) — Apple's format, widely supported:

#EXTM3U
#EXT-X-VERSION:6
#EXT-X-TARGETDURATION:5
#EXT-X-MEDIA-SEQUENCE:0
#EXTINF:5.0,
1080p_0.m4s
#EXTINF:5.0,
1080p_1.m4s
#EXTINF:5.0,
1080p_2.m4s

ABR Algorithm (Netflix's BBA - Buffer-Based Approach)

The client uses a buffer-based algorithm to decide which bitrate to request:

Buffer Level
    │
    │  ┌─────────────────────────────────────────┐
    │  │         Safe Zone (switch UP allowed)    │
    │  │  High bitrate: buffer > 60% full         │
    │  └─────────────────────────────────────────┘
    │
    │  ┌─────────────────────────────────────────┐
    │  │         Normal Zone (maintain current)    │
    │  │  Buffer 20%-60% full                     │
    │  └─────────────────────────────────────────┘
    │
    │  ┌─────────────────────────────────────────┐
    │  │         Danger Zone (switch DOWN)        │
    │  │  Buffer < 20% full                       │
    │  └─────────────────────────────────────────┘
    │
    └────────────────────────────────────────── Time

ABR Decision Logic:

def select_bitrate(buffer_level, available_bitrates, current_bitrate):
    buffer_percentage = buffer_level / MAX_BUFFER * 100
    
    if buffer_percentage < 10:
        # Emergency: drop to lowest available bitrate
        return min(available_bitrates)
    elif buffer_percentage < 30:
        # Conservative: stay or go lower
        return min(available_bitrates)
    elif buffer_percentage > 70:
        # Aggressive: try highest available
        return max(available_bitrates)
    else:
        # Moderate: maintain current or incrementally increase
        return current_bitrate

Startup Latency Optimization

Netflix targets < 2 second startup time:

1. Pre-fetching: While browsing, prefetch manifests and first few chunks of likely-to-play titles
2. Manifest caching: Cache manifest files at CDN edge
3. Short first chunk: First chunk can be smaller (2-3 seconds) for faster start
4. Parallel fetching: Download audio and video segments simultaneously
5. TCP warmup: Maintain persistent connections to OCAs

Netflix Recommendation System

Netflix's recommendation engine drives 80% of content watched on the platform. It's their most critical competitive advantage.

Recommendation System Architecture

┌─────────────────────────────────────────────────────────┐
│                    Data Sources                         │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐  │
│  │ Viewing  │ │ Search   │ │ Ratings  │ │ Device   │  │
│  │ History  │ │ Queries  │ │ (thumbs) │ │ Context  │  │
│  └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘  │
└───────┼─────────────┼────────────┼─────────────┼────────┘
        │             │            │             │
        ▼             ▼            ▼             ▼
┌─────────────────────────────────────────────────────────┐
│              Feature Engineering Pipeline               │
│  ┌─────────────────────────────────────────────────┐    │
│  │ - User genre preferences (weighted by recency)  │    │
│  │ - Viewing time patterns (weekday/weekend)       │    │
│  │ - Device preferences (TV vs mobile)             │    │
│  │ - Time of day patterns                          │    │
│  │ - Completion rates per title                    │    │
│  │ - Skip/replay patterns                          │    │
│  └─────────────────────────────────────────────────┘    │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│              ML Model Ensemble                          │
│  ┌──────────────┐ ┌──────────────┐ ┌──────────────┐    │
│  │ Collaborative│ │Content-Based │ │ Deep Learning │    │
│  │ Filtering    │ │ Filtering    │ │ (Neural Net)  │    │
│  └──────┬───────┘ └──────┬───────┘ └──────┬───────┘    │
│         └────────────────┼────────────────┘             │
│                          │                              │
│                    ┌─────┴─────┐                        │
│                    │  Blending  │                        │
│                    │  Layer     │                        │
│                    └─────┬─────┘                        │
└──────────────────────────┼──────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│              Personalized Results                       │
│  Row 1: "Top Picks for [User]"                         │
│  Row 2: "Because you watched [Title]"                   │
│  Row 3: "Trending Now" (personalized order)             │
│  Row 4: "New Releases" (personalized selection)         │
│  Row 5: "Watch It Again"                               │
│  Row 6: Genre-specific rows (personalized)              │
└─────────────────────────────────────────────────────────┘

Collaborative Filtering

User-User Collaborative Filtering:

• Find users similar to you (based on viewing history)
• Recommend content they watched that you haven't

Item-Item Collaborative Filtering:

• Find content similar to what you've watched
• Based on what other users with similar taste also watched

User-Item Matrix (implicit feedback - viewing hours):

              Title A  Title B  Title C  Title D  Title E
User 1           10       0        8        0        3
User 2            0       5        0        7        0
User 3            9       0        7        0        2
User 4            0       6        0        8        0

→ User 1 similar to User 3 (both watch A & C)
→ Recommend Title D to User 1 (User 3's pattern)

Content-Based Filtering

Uses metadata and content features:

Feature	Example
Genre	Sci-Fi, Thriller, Drama
Sub-genre	Cyberpunk, Psychological, Period Drama
Cast	Actor X, Director Y
Visual features	Dark tones, Fast-paced scenes
Audio features	Orchestral soundtrack, Minimal score
Metadata	Year, Country, Language
NLP on synopsis	Keywords extracted from description

Deep Learning Model (Neural Collaborative Filtering)

Netflix uses a combination of:

┌─────────────────────────────────────────────┐
│         Neural Collaborative Filtering       │
│                                             │
│  Input: User embedding + Item embedding     │
│      │              │                       │
│      ▼              ▼                       │
│  ┌────────┐    ┌────────┐                   │
│  │ User   │    │ Item   │                   │
│  │ Vector │    │ Vector │                   │
│  │(128-d) │    │(128-d) │                   │
│  └───┬────┘    └───┬────┘                   │
│      │             │                        │
│      ▼             ▼                        │
│  ┌─────────────────────┐                    │
│  │   Concatenation     │                    │
│  │   (256-d vector)    │                    │
│  └──────────┬──────────┘                    │
│             │                               │
│  ┌──────────▼──────────┐                    │
│  │  Dense Layer (128)  │                    │
│  │  + ReLU             │                    │
│  └──────────┬──────────┘                    │
│             │                               │
│  ┌──────────▼──────────┐                    │
│  │  Dense Layer (64)   │                    │
│  │  + ReLU             │                    │
│  └──────────┬──────────┘                    │
│             │                               │
│  ┌──────────▼──────────┐                    │
│  │  Output (1)         │                    │
│  │  Watch probability  │                    │
│  └─────────────────────┘                    │
└─────────────────────────────────────────────┘

Homepage Personalization

Netflix personalizes every element:

1. Row generation: Which rows appear (genre, mood, cast-based)
2. Row ordering: Which rows are higher priority
3. Title ordering: Which titles appear first in each row
4. Artwork selection: Personalized thumbnail art per title per user
   • User who watches romance → sees romantic scene thumbnail
   • User who watches action → sees action scene thumbnail for same title

ML Pipeline

┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
│ Real-time │───▶│ Feature  │───▶│ Model    │───▶│ Serving  │
│ Event     │    │ Store    │    │ Training │    │ Layer    │
│ Stream    │    │ (Redis)  │    │ (GPU)    │    │ (API)    │
└──────────┘    └──────────┘    └──────────┘    └──────────┘
    Kafka        Cassandra        SageMaker       EVCache

Retraining frequency: Daily (batch) + hourly (online learning)
A/B testing: Every model change tested on small user segment first

Metrics & Evaluation

Metric	Definition
Play rate	% of impressions that result in a play
Completion rate	% of viewers who finish the title
Discovery rate	% of plays from non-search (browse/recommend)
Retention	Monthly subscriber retention rate
Diversity	Variety of genres/content in recommendations
Novelty	How much content is "discovered" vs. already known
Surprise	Content outside user's typical patterns that they enjoy