# Netflix Interview Guide 2026: Streaming Architecture, Recommendation Systems, and Engineering Excellence

Source: https://www.techinterview.org/post/3233460274/netflix-interview-guide-2026-streaming-architecture-recommendation-systems-and-engineering-excellence/
Updated: 2026-07-11 · techinterview.org

**TL;DR —** The Netflix engineering interview is a multi-round loop that tests system design at streaming scale, coding, and alignment with Netflix's "freedom and responsibility" culture, with senior candidates judged more on architectural judgment and ownership than on algorithm puzzles. Expect deep questions on distributed streaming systems—content delivery, adaptive bitrate, and microservices resilience—alongside recommendation systems built on collaborative filtering and large-scale A/B experimentation. Prepare by rehearsing real trade-off reasoning and decision-ownership stories, since Netflix hires people who operate with little process and make independent calls.

## Netflix Interview Guide 2026: Streaming Architecture, Recommendations, and Engineering Excellence

Netflix is legendary for its engineering culture of "freedom and responsibility." Their interviews reflect this: they hire senior engineers who can operate autonomously, make high-stakes decisions independently, and build globally distributed systems. This guide covers SWE interviews from E4 to E6.

## The Netflix Interview Process

- **Recruiter call** (30 min) — culture fit, experience, timeline

- **Technical screen** (1 hour) — coding + discussion of past projects

- **Virtual onsite** (4–5 rounds):

  2× coding / algorithms

  - 1× system design (streaming, recommendations, or personalization)

  - 1× architecture / technical leadership

  - 1× cultural fit / "Keeper Test" discussion

**The Keeper Test**: Netflix's famous cultural practice — interviewers ask themselves "Would I fight to keep this person?" Mediocre performance = generous severance. This creates high hiring bars but also high compensation.

## Algorithms: Recommendation Systems

Netflix's core technical domain is personalization. Expect problems around ranking, collaborative filtering, and content similarity.

### Collaborative Filtering with Matrix Factorization


```
import numpy as np
from typing import List, Tuple

class MatrixFactorization:
    """
    Simplified matrix factorization for collaborative filtering.
    Netflix Prize-era approach (SVD-based).
    Modern Netflix uses deep learning (two-tower models).

    Goal: decompose ratings matrix R (users x items) into
    user embeddings U and item embeddings V such that R ? U @ V.T
    """

    def __init__(self, n_factors: int = 50, lr: float = 0.01,
                 reg: float = 0.01, n_epochs: int = 20):
        self.n_factors = n_factors
        self.lr = lr
        self.reg = reg
        self.n_epochs = n_epochs

    def fit(self, ratings: List[Tuple[int, int, float]],
            n_users: int, n_items: int):
        """
        Train on (user_id, item_id, rating) tuples.
        Time: O(epochs * ratings * factors)
        Space: O((users + items) * factors)
        """
        self.U = np.random.normal(0, 0.1, (n_users, self.n_factors))
        self.V = np.random.normal(0, 0.1, (n_items, self.n_factors))
        self.user_bias = np.zeros(n_users)
        self.item_bias = np.zeros(n_items)
        self.global_mean = np.mean([r for _, _, r in ratings])

        for epoch in range(self.n_epochs):
            total_loss = 0
            for u, i, r in ratings:
                prediction = self._predict(u, i)
                error = r - prediction

                # Update biases
                self.user_bias[u] += self.lr * (error - self.reg * self.user_bias[u])
                self.item_bias[i] += self.lr * (error - self.reg * self.item_bias[i])

                # Update embeddings
                u_vec = self.U[u].copy()
                self.U[u] += self.lr * (error * self.V[i] - self.reg * self.U[u])
                self.V[i] += self.lr * (error * u_vec - self.reg * self.V[i])

                total_loss += error ** 2

            rmse = (total_loss / len(ratings)) ** 0.5
            if epoch % 5 == 0:
                print(f"Epoch {epoch}: RMSE = {rmse:.4f}")

    def _predict(self, user_id: int, item_id: int) -> float:
        return (self.global_mean
                + self.user_bias[user_id]
                + self.item_bias[item_id]
                + np.dot(self.U[user_id], self.V[item_id]))

    def recommend(self, user_id: int, n: int = 10,
                  exclude_seen: set = None) -> List[Tuple[int, float]]:
        """Get top-N recommendations for a user."""
        n_items = self.V.shape[0]
        scores = []
        for item_id in range(n_items):
            if exclude_seen and item_id in exclude_seen:
                continue
            score = self._predict(user_id, item_id)
            scores.append((item_id, score))

        scores.sort(key=lambda x: -x[1])
        return scores[:n]
```


### Content-Based Similarity (for Cold Start)


```
from collections import Counter
import math

def cosine_similarity(vec_a: dict, vec_b: dict) -> float:
    """
    Compute cosine similarity between sparse feature vectors.
    Used for content-based filtering when user history is thin.

    Time: O(min(|A|, |B|))
    """
    intersection = set(vec_a.keys()) & set(vec_b.keys())
    dot_product = sum(vec_a[k] * vec_b[k] for k in intersection)

    mag_a = math.sqrt(sum(v**2 for v in vec_a.values()))
    mag_b = math.sqrt(sum(v**2 for v in vec_b.values()))

    if mag_a == 0 or mag_b == 0:
        return 0.0
    return dot_product / (mag_a * mag_b)


class ContentRecommender:
    """
    TF-IDF based content similarity for cold-start recommendations.
    Uses genre, cast, director, and keywords as features.
    """

    def __init__(self):
        self.item_vectors = {}  # item_id -> TF-IDF vector
        self.idf = {}

    def index_items(self, items: List[dict]):
        """
        items: [{'id': 1, 'genres': ['Action'], 'cast': ['Actor A'], ...}]
        """
        # Compute term frequencies
        all_terms = Counter()
        for item in items:
            terms = self._extract_terms(item)
            all_terms.update(set(terms))  # IDF: count docs containing term

        n_docs = len(items)
        self.idf = {term: math.log(n_docs / count)
                   for term, count in all_terms.items()}

        for item in items:
            terms = self._extract_terms(item)
            tf = Counter(terms)
            total = sum(tf.values())
            tfidf = {t: (c / total) * self.idf.get(t, 0)
                    for t, c in tf.items()}
            self.item_vectors[item['id']] = tfidf

    def _extract_terms(self, item: dict) -> List[str]:
        terms = []
        terms.extend(item.get('genres', []))
        terms.extend(item.get('cast', [])[:5])  # top 5 cast members
        terms.extend([item.get('director', '')])
        terms.extend(item.get('keywords', []))
        return [t.lower().replace(' ', '_') for t in terms if t]

    def find_similar(self, item_id: int, n: int = 10) -> List[Tuple[int, float]]:
        if item_id not in self.item_vectors:
            return []

        target = self.item_vectors[item_id]
        similarities = []
        for other_id, other_vec in self.item_vectors.items():
            if other_id == item_id:
                continue
            sim = cosine_similarity(target, other_vec)
            similarities.append((other_id, sim))

        similarities.sort(key=lambda x: -x[1])
        return similarities[:n]
```


## System Design: Netflix Video Streaming

Common design question: *"Design Netflix's video streaming infrastructure."*

### Key Numbers

- 260M+ subscribers globally

- ~15% of global internet bandwidth during peak

- 15,000+ content titles, each encoded in 120+ bitrate/resolution variants

- Netflix Open Connect CDN: 17,000+ servers in 1,000+ locations

### Architecture


```
Client
  |
[Netflix CDN (Open Connect)] ? video files, encrypted
  |
  ? cache miss
  |
[Origin Servers] (AWS S3)
  |
[Encoding Pipeline]
  |
[Raw Video Upload]

Control Plane (on AWS):
Client ? [API Gateway]
          ? [Auth Service]
          ? [Playback Service] ? selects CDN node, generates signed URL
          ? [Recommendation Service]
          ? [Billing Service]
```


### Adaptive Bitrate Streaming (ABR)

Netflix uses **VMAF** (Video Multimethod Assessment Fusion) scores and per-title encoding — each show gets custom encoding profiles based on visual complexity.


```
class ABRController:
    """
    Adaptive Bitrate controller running on client.
    Selects video quality based on measured bandwidth.
    Netflix uses a proprietary ML-based ABR algorithm.
    """

    QUALITY_LEVELS = [
        (240, 500_000),    # 240p, 500kbps
        (480, 1_500_000),  # 480p, 1.5Mbps
        (720, 3_000_000),  # 720p, 3Mbps
        (1080, 8_000_000), # 1080p, 8Mbps
        (2160, 20_000_000),# 4K, 20Mbps
    ]

    def __init__(self, buffer_target_s: float = 30.0):
        self.buffer_level = 0.0  # seconds of buffered video
        self.buffer_target = buffer_target_s
        self.bandwidth_estimate = 5_000_000  # 5Mbps initial estimate
        self.segment_duration = 4.0  # seconds per segment

    def select_quality(self) -> tuple:
        """
        Choose quality level based on:
        1. Estimated available bandwidth
        2. Current buffer level (buffer-based rate adaptation)

        Returns (resolution, bitrate) tuple.
        """
        # Buffer-based adjustment
        if self.buffer_level < 10.0:  # low buffer -> be conservative
            safety_factor = 0.5
        elif self.buffer_level > 25.0:  # high buffer -> be aggressive
            safety_factor = 0.9
        else:
            safety_factor = 0.7

        available = self.bandwidth_estimate * safety_factor

        # Select highest quality that fits
        selected = self.QUALITY_LEVELS[0]
        for res, bitrate in self.QUALITY_LEVELS:
            if bitrate <= available:
                selected = (res, bitrate)

        return selected

    def update_bandwidth(self, bytes_received: int, elapsed_ms: float):
        """Exponential moving average bandwidth estimation."""
        measured = (bytes_received * 8) / (elapsed_ms / 1000)
        alpha = 0.3
        self.bandwidth_estimate = (alpha * measured +
                                   (1 - alpha) * self.bandwidth_estimate)
```


## Chaos Engineering

Netflix invented **Chaos Monkey** (now Simian Army). Interviewers may ask about fault tolerance design.

- **Graceful degradation**: If recommendation service is down, fall back to trending/popular lists

- **Circuit breakers**: Hystrix pattern; fail fast rather than cascading failures

- **Bulkheads**: Isolate critical paths (playback) from non-critical (social features)

- **Redundancy**: Multi-region active-active; no single region is primary

## Netflix Engineering Culture

Read the Netflix Culture Deck before interviewing. Key principles:

- **Context, not control**: Leaders set context, engineers make decisions

- **Highly aligned, loosely coupled**: Teams align on goals, choose their own implementation

- **The Keeper Test**: Would your manager fight to keep you if you tried to leave?

In behavioral rounds, give examples of times you made high-stakes decisions independently, disagreed with a direction and changed it, or simplified a complex system.

## Compensation (E4–E6, US, 2025 data)

| Level | Title | All-in Cash | Note |
| --- | --- | --- | --- |
| E4 | SWE | $300–400K | No RSUs; all salary + bonus |
| E5 | Senior SWE | $400–600K | Stock option available |
| E6 | Staff SWE | $600–900K+ | Negotiable equity allocation |

Netflix's unique model: they pay top-of-market in cash and let employees choose how much stock vs. cash they want. No traditional RSU vesting cliffs.

## Interview Tips

- **Know distributed systems deeply**: CAP theorem, eventual consistency, saga pattern

- **Microservices expertise**: Netflix pioneered the pattern; know service mesh, circuit breakers, service discovery

- **Data-driven mindset**: Netflix runs thousands of A/B tests; show statistical thinking

- **Practice with scale**: Every system design answer should address 260M users, global scale, 99.99% uptime

- **LeetCode targets**: Hard difficulty for senior roles; focus on DP, graph algorithms, and string manipulation

*Practice problems: LeetCode 146 (LRU Cache), 380 (RandomizedSet), 460 (LFU Cache), 362 (Design Hit Counter).*

## Related System Design Interview Questions

Practice these system design problems that appear in Netflix  interviews:

- [System Design: YouTube / Video Streaming Platform](https://www.techinterview.org/post/3233461351/system-design-video-streaming-platform/)

- [Design a CDN (Content Delivery Network)](https://www.techinterview.org/post/3233460054/design-a-cdn-content-delivery-network/)

- [Design a Recommendation Engine (Netflix-style)](https://www.techinterview.org/post/3233460078/design-a-recommendation-engine-netflix-style/)

- [System Design: Search Autocomplete (Google Typeahead)](https://www.techinterview.org/post/3233460549/system-design-search-autocomplete/)

## Related Company Interview Guides

- [Netflix Interview Guide 2026: Streaming Architecture, Recommendation Systems, and Engineering Excellence](/post/3233460274/netflix-interview-guide-2026-streaming-architecture-recommendation-systems-and-engineering-excellence/)

- [Stripe Interview Guide 2026: Process, Bug Bash Round, and Payment Systems](https://www.techinterview.org/post/3233460268/stripe-interview-guide-2026-process-bug-bash-round-and-payment-systems/)

- [Twitch Interview Guide](https://www.techinterview.org/post/3233459925/twitch-interview/)

- [Coinbase Interview Guide](https://www.techinterview.org/post/3233459920/coinbase-interview/)

- [Robinhood Interview Guide](https://www.techinterview.org/post/3233459922/robinhood-interview/)

- [Scale AI Interview Guide 2026: Data Infrastructure, RLHF Pipelines, and ML Engineering](https://www.techinterview.org/post/3233460275/scale-ai-interview-guide-2026-data-infrastructure-rlhf-pipelines-and-ml-engineering/)

- [System Design: Analytics Platform (ClickHouse / Snowflake Scale)](/post/3233460607/system-design-analytics-platform/)

- [System Design: Distributed Lock Manager (Redis / Zookeeper)](/post/3233460635/system-design-distributed-lock/)

- [System Design: Monitoring and Observability Platform (Datadog)](/post/3233460647/system-design-monitoring-observability/)

- [System Design: Data Pipeline and ETL System (Airflow / Spark)](/post/3233460662/system-design-data-pipeline/)

- [System Design: IoT Data Platform (AWS IoT / Azure IoT Hub)](/post/3233460535/system-design-iot-platform/)

- [System Design: SRE and DevOps Platform (PagerDuty / Backstage)](/post/3233460536/sre-devops-interview-questions/)

- [System Design: Content Delivery Network (Cloudflare / Fastly)](/post/3233460559/system-design-cdn/)

- [System Design: Content Moderation Platform (PhotoDNA / AWS Rekognition)](/post/3233460623/system-design-content-moderation/)

- [System Design: Microservices Architecture Patterns](/post/3233460664/system-design-microservices-patterns/)

- [System Design: Music Streaming Service (Spotify)](/post/3233460805/system-design-music-streaming/)

- [System Design: Video Conferencing (Zoom / Google Meet)](/post/3233460400/system-design-video-conferencing/)

- [System Design: Kubernetes Autoscaling](/post/3233460937/system-design-kubernetes-autoscaling/)

- [System Design: Multi-Region Active-Active Architecture](/post/3233460952/system-design-multi-region-active-active/)

- [System Design: Log Aggregation and Observability Pipeline](/post/3233460968/system-design-log-aggregation/)

- [System Design: Distributed Cache (Redis Deep Dive)](/post/3233460434/system-design-distributed-cache/)

- [System Design: WebRTC and Real-Time Video Architecture](/post/3233461050/system-design-webrtc-video/)

*Explore all our [company interview guides](https://www.techinterview.org/category/company-guides/) covering FAANG, startups, and high-growth tech companies.*

Related system design: [System Design Interview: API Rate Limiter Deep Dive (All Algorithms)](https://techinterview.org/api-rate-limiter-system-design-deep-dive/)

Related system design: [System Design Interview: Design a Distributed File System (HDFS/GFS)](https://techinterview.org/system-design-distributed-file-system-hdfs/)

Related system design: [System Design Interview: Design a Distributed Messaging System (Kafka)](https://techinterview.org/system-design-distributed-messaging-kafka/)

See also: [System Design Fundamentals: CAP Theorem, Consistency, and Replication](https://techinterview.org/system-design-fundamentals-cap-theorem/)

See also: [System Design Interview: Design a Feature Flag System](https://techinterview.org/system-design-feature-flag-system/)

- [System Design Interview: Design a Metrics and Monitoring System (Prometheus)](https://techinterview.org/system-design-metrics-monitoring-prometheus/)

- [System Design Interview: Design a Distributed File System (HDFS / GFS)](https://techinterview.org/system-design-distributed-file-system-hdfs-gfs/)

- [System Design Interview: Design an Object Storage System (Amazon S3)](https://techinterview.org/system-design-object-storage-s3/)

- [System Design Interview: Design a Key-Value Store (Redis / DynamoDB)](https://techinterview.org/system-design-key-value-store-redis-dynamodb/)

- [System Design Interview: Design a Stock Exchange / Trading System](https://techinterview.org/system-design-stock-exchange-trading-system/)

- [System Design Interview: Design a Content Delivery Network (CDN)](https://techinterview.org/system-design-content-delivery-network-cdn/)

- [System Design Interview: Microservices and Service Mesh (Envoy, Istio, mTLS)](https://techinterview.org/system-design-microservices-service-mesh/)

- [System Design Interview: Design an API Gateway](https://techinterview.org/system-design-api-gateway/)

- [System Design Interview: Design a Video Streaming Platform (YouTube/Netflix)](https://techinterview.org/system-design-video-streaming-platform-youtube/)

- [System Design Interview: Design a Content Moderation System](https://techinterview.org/system-design-content-moderation-system/)

- [System Design Interview: Design a Subscription Billing System](https://techinterview.org/system-design-subscription-billing-system/)

- [System Design Interview: Design a Real-Time Gaming Leaderboard](https://techinterview.org/system-design-gaming-leaderboard/)

- [System Design Interview: Design a Real-Time Bidding (RTB) Ad System](https://techinterview.org/system-design-real-time-bidding/)

- [System Design Interview: Design a Real-Time Collaborative Whiteboard (Miro/Figma)](https://techinterview.org/system-design-collaborative-whiteboard/)

- [System Design Interview: Design a Distributed Lock and Leader Election System](https://techinterview.org/system-design-distributed-lock-leader-election/)

- [System Design Interview: Design a Live Sports Score System](https://techinterview.org/system-design-live-sports-scores/)

- [System Design Interview: Design a Cloud File Storage System (Dropbox/Google Drive)](https://techinterview.org/system-design-file-storage-dropbox/)

- [System Design Interview: Design a Multi-Region Database System](https://techinterview.org/system-design-multi-region-database/)

- [System Design Interview: Design a Streaming Data Pipeline (Kafka + Flink)](https://techinterview.org/system-design-streaming-data-pipeline/)

- [System Design Interview: Design a Real-Time Collaborative Editor (Google Docs)](https://techinterview.org/system-design-collaborative-editor/)

- [System Design Interview: Design a Live Video Streaming Platform (Twitch)](https://techinterview.org/system-design-live-video-streaming/)

- [System Design Interview: Design a Recommendation System (Netflix/Spotify/Amazon)](https://techinterview.org/system-design-recommendation-system/)

- [System Design Interview: Design a Distributed Key-Value Store (DynamoDB/Cassandra)](https://techinterview.org/system-design-distributed-key-value-store/)

- [System Design Interview: Design a Social Media Feed (Twitter/Instagram)](https://techinterview.org/system-design-social-media-feed/)

- [System Design Interview: Design a Distributed Task Queue (Celery/SQS)](https://techinterview.org/system-design-task-queue/)

- [System Design Interview: Design a Web Crawler](https://techinterview.org/system-design-web-crawler/)

- [System Design Interview: Design a Key-Value Store (Redis/DynamoDB)](https://techinterview.org/system-design-key-value-store/)

- [System Design Interview: Design a Video Streaming Platform (YouTube/Netflix)](https://techinterview.org/system-design-video-streaming/)

- [System Design Interview: Design a Load Balancer](https://techinterview.org/system-design-load-balancer/)

- [System Design: Multi-Region Architecture and Global Replication](https://techinterview.org/system-design-global-replication/)

- [System Design: Time Series Database (Prometheus / InfluxDB)](https://techinterview.org/system-design-time-series-database/)

- [System Design: Object Storage (Amazon S3)](https://techinterview.org/system-design-object-storage/)

- [System Design: Real-Time Analytics Dashboard (ClickHouse / Druid)](https://techinterview.org/system-design-real-time-analytics/)

- [System Design: Distributed Message Queue (Kafka / SQS)](https://techinterview.org/system-design-message-queue/)

- [System Design: Twitter / Social Media Feed Architecture](https://techinterview.org/system-design-twitter-social-media-feed/)

- [System Design: Video Streaming Platform (Netflix/YouTube)](https://techinterview.org/system-design-video-streaming-platform/)

- [System Design: Machine Learning Platform and MLOps](https://techinterview.org/system-design-ml-platform-mlops/)

- [System Design: API Gateway and Service Mesh](https://techinterview.org/system-design-api-gateway-service-mesh/)

- [System Design: Kubernetes and Container Orchestration](https://techinterview.org/system-design-kubernetes-container-orchestration/)

- [System Design: DNS and Global Load Balancing](https://techinterview.org/system-design-dns-global-load-balancing/)

- [System Design: Event Sourcing and CQRS](https://techinterview.org/system-design-event-sourcing-cqrs/)

- [System Design: Recommendation Engine at Scale](https://techinterview.org/system-design-recommendation-engine/)

## Related System Design Topics

- [System Design: Distributed File System (GFS/HDFS/S3)](https://techinterview.org/system-design-distributed-file-system/)

📌 Related: [System Design Interview: Design Instagram / Photo Sharing Platform](https://techinterview.org/system-design-instagram-photo-sharing/)

📌 Related: [System Design Interview: Design YouTube / Video Streaming Platform](https://techinterview.org/system-design-youtube-video-streaming/)

📌 Related: [System Design Interview: Design Twitter / X Timeline](https://techinterview.org/system-design-twitter-timeline/)

📌 Related: [System Design Interview: Design a Notification System](https://techinterview.org/system-design-notification-system/)

📌 Related: [System Design Interview: Design a Rate Limiter](https://techinterview.org/system-design-rate-limiter/)

📌 Related: [System Design Interview: Design a Distributed Message Queue (Kafka)](https://techinterview.org/system-design-message-queue-kafka/)

📌 Related: [System Design Interview: Design a Leaderboard / Top-K System](https://techinterview.org/system-design-leaderboard-top-k/)

Related system design: [System Design: Consistent Hashing Explained with Virtual Nodes](https://techinterview.org/system-design-consistent-hashing/)

Related system design: [System Design: Distributed Tracing System (Jaeger/Zipkin/OpenTelemetry)](https://techinterview.org/system-design-distributed-tracing/)

Related system design: [System Design: Sharding and Data Partitioning Explained](https://techinterview.org/system-design-sharding-data-partitioning/)

Related system design: [System Design: Content Delivery Network (CDN) — Cache, Routing, Edge](https://techinterview.org/system-design-cdn-content-delivery-network/)

Related system design: [System Design: Database Replication, Read Scaling, and Failover](https://techinterview.org/system-design-database-replication/)

Related system design: [System Design: Apache Kafka — Architecture, Partitions, and Stream Processing](https://techinterview.org/system-design-kafka-architecture/)

Related system design: [System Design: Distributed Task Queue and Job Scheduler (Celery, SQS, Redis)](https://techinterview.org/system-design-distributed-task-queue/)

Related system design: [System Design: Distributed Counters, Leaderboards, and Real-Time Analytics](https://techinterview.org/system-design-distributed-counters-analytics/)

Related system design: [System Design: Video Processing Pipeline (YouTube/Netflix) -- Transcoding, HLS, and Scaling](https://techinterview.org/system-design-video-processing-pipeline/)

Related system design: [System Design: Event-Driven Architecture -- Kafka, Event Sourcing, CQRS, and Saga Pattern](https://techinterview.org/system-design-event-driven-architecture/)

Related system design: [System Design: Configuration Management Service -- Feature Flags, Dynamic Config, and Safe Rollouts](https://techinterview.org/system-design-config-management/)

Related system design: [System Design: Distributed Transactions -- Two-Phase Commit, Saga, and Eventual Consistency](https://techinterview.org/system-design-distributed-transaction/)

Related system design: [System Design: Distributed Locking -- Redis Redlock, ZooKeeper, and Database Locks](https://techinterview.org/system-design-distributed-locking/)

Related system design: [System Design: Service Mesh — Sidecar Proxy, Traffic Management, mTLS, and Observability](https://techinterview.org/system-design-service-mesh/)

Related system design: [System Design: Log Aggregation and Observability Platform — ELK Stack, Metrics, Tracing, and Alerting](https://techinterview.org/system-design-log-aggregation-observability/)

Related system design: [System Design: Consensus Algorithms — Raft, Paxos, Leader Election, and Distributed Agreement](https://techinterview.org/system-design-consensus-algorithms-raft-paxos/)

Related system design: [System Design: Database Sharding — Horizontal Partitioning, Shard Keys, Hotspots, and Resharding](https://techinterview.org/system-design-database-sharding/)

Related system design: [System Design: Social Network News Feed — Fan-out on Write vs Read, Ranking, and Feed Generation](https://techinterview.org/system-design-social-network-feed/)

Related system design: [System Design: Multiplayer Game Backend — Game Sessions, Real-time State, Matchmaking, and Leaderboards](https://techinterview.org/system-design-multiplayer-game-backend/)

Related system design: [System Design: WebRTC and Video Calling -- Signaling, ICE, STUN/TURN, and SFU Architecture](https://techinterview.org/system-design-webrtc-video-calling/)

Related system design: [System Design: ML Feature Store -- Feature Computation, Storage, Serving, and Point-in-Time Correctness](https://techinterview.org/system-design-ml-feature-store/)

Related system design: [System Design: Distributed Message Queue -- Kafka Architecture, Partitions, Consumer Groups, and Delivery Guarantees](https://techinterview.org/system-design-distributed-message-queue/)

Related system design: [Low-Level Design: Analytics Dashboard — Metrics Aggregation, Time-Series Storage, and Real-Time Charting](https://techinterview.org/lld-analytics-dashboard/)

Related system design: [System Design: Observability Platform — Logs, Metrics, Distributed Tracing, and Alerting](https://techinterview.org/system-design-observability-platform/)

Related system design: [Low-Level Design: Subscription Billing — Recurring Charges, Proration, and Dunning Management](https://techinterview.org/lld-subscription-billing/)

Related system design: [System Design: Circuit Breaker, Retry, and Bulkhead — Resilience Patterns for Microservices](https://techinterview.org/system-design-circuit-breaker/)

Related system design: [System Design: Analytics Pipeline — Ingestion, Stream Processing, and OLAP Query Layer](https://techinterview.org/system-design-analytics-pipeline/)

Related system design: [System Design: Document Store — Schema-Flexible Storage, Indexing, and Consistency Trade-offs](https://techinterview.org/system-design-document-store/)

Related system design: [System Design: Live Comments — Real-Time Delivery, Moderation, and Spam Prevention at Scale](https://techinterview.org/system-design-live-comments/)

Related system design: [System Design: File Sharing Platform (Google Drive/Dropbox) — Storage, Sync, and Permissions](https://techinterview.org/system-design-file-sharing/)

See also: [System Design: Media Storage and Delivery](https://techinterview.org/system-design-media-storage/)

See also: [System Design: Multi-Region Architecture](https://techinterview.org/system-design-multi-region/)

See also: [System Design: Content Delivery Network (CDN)](https://techinterview.org/system-design-content-delivery/)

See also: [Low-Level Design: Subscription Service](https://techinterview.org/lld-subscription-service/)

See also: [System Design: A/B Testing Platform](https://techinterview.org/system-design-ab-testing/)

See also: [System Design: ML Training and Serving Pipeline](https://techinterview.org/system-design-ml-pipeline/)

See also: [System Design: Data Lake](https://techinterview.org/system-design-data-lake/)

See also: [System Design: Observability Platform](https://techinterview.org/system-design-observability/)

See also: [System Design: Distributed Cache](https://techinterview.org/system-design-cache/)

Netflix is the canonical video streaming system design topic. Review the full platform design in [Video Processing Platform System Design](https://www.techinterview.org/post/3233464658/system-design-video-processing-pipeline/).

See also: [Low-Level Design: Digital Library System - Catalog, Borrowing, Reservations, and DRM (2025)](https://www.techinterview.org/post/3233466748/lld-digital-library/)

Netflix uses caching for streaming at scale. Review LRU, write-through, and thundering herd prevention in [Distributed Cache System Low-Level Design](https://www.techinterview.org/post/3233466853/lld-distributed-cache/).

Netflix uses Kafka for event streaming. Review message queue design with exactly-once and DLQ patterns in [Message Queue System Low-Level Design](https://www.techinterview.org/post/3233466901/lld-message-queue/).

Netflix uses CDN for streaming. Review edge caching, origin shield, and cache hierarchy design in [Content Delivery Network (CDN) System Design](https://www.techinterview.org/post/3233466923/lld-cdn/).

Netflix is built on recommendations. Review two-tower model, candidate generation, ranking, and A/B testing in [Recommendation System Low-Level Design](https://www.techinterview.org/post/3233466949/lld-recommendation-system/).

Netflix uses streaming infrastructure. Review live ingest, transcoding pipeline, and CDN delivery in [Live Video Streaming System Low-Level Design](https://www.techinterview.org/post/3233466997/lld-live-streaming/).

Google interviews cover search autocomplete at scale. Review the full typeahead LLD in [Typeahead Search (Autocomplete) System Low-Level Design](https://www.techinterview.org/post/3233472980/lld-search-typeahead/).

Google Drive system design is a core interview topic. Review chunked upload and sync design in [File Storage System (Google Drive / Dropbox) Low-Level Design](https://www.techinterview.org/post/3233467091/lld-file-storage/).

Google coding interviews test prefix sum and range queries. Review the full pattern guide in [Prefix Sum Interview Patterns](https://www.techinterview.org/post/3233467116/prefix-sum-patterns/).

YouTube system design covers video upload and streaming at scale. Review the full LLD in [Video Streaming Platform (YouTube/Netflix) Low-Level Design](https://www.techinterview.org/post/3233467117/lld-video-streaming/).

Google coding interviews test number theory patterns. Review GCD, sieve, and modular arithmetic in [Number Theory Interview Patterns](https://www.techinterview.org/post/3233467138/number-theory-patterns/).

Google coding interviews test divide and conquer. Review the master theorem and key patterns in [Divide and Conquer Interview Patterns](https://www.techinterview.org/post/3233461565/divide-and-conquer-interview-patterns/).

Google coding interviews test topological sort. Review alien dictionary and course schedule patterns in [Topological Sort Interview Patterns](https://www.techinterview.org/post/3233461698/topological-sort-interview-patterns/).

Google coding interviews test bit operations. Review bitmask patterns and XOR tricks in [Bit Manipulation Interview Patterns](https://www.techinterview.org/post/3233460816/bit-manipulation-interview-patterns/).

Google coding interviews test two pointers. Review the full advanced pattern guide in [Two Pointers Advanced Interview Patterns](https://www.techinterview.org/post/3233460663/two-pointers-interview-patterns/).

Google coding interviews test string hashing. Review Rabin-Karp, rolling hash, and duplicate substring patterns in [String Hashing Interview Patterns](https://www.techinterview.org/post/3233465584/string-hashing-interview-patterns/).

Google system design covers access control. Review the full permission system LLD in [Permission and Authorization System Low-Level Design](https://www.techinterview.org/post/3233467283/lld-permission-system/).

Google coding interviews test ordered data structures. Review TreeMap and SortedList patterns in [Ordered Map (TreeMap / SortedList) Interview Patterns](https://www.techinterview.org/post/3233467305/ordered-map-patterns/).

Google system design interviews cover search autocomplete. Review the full trie and Redis design in [Search Suggestions (Autocomplete) System Low-Level Design](https://www.techinterview.org/post/3233467329/lld-search-suggestions/).

Google coding interviews test greedy algorithms. Review interval scheduling, jump game, and task scheduler patterns in [Greedy Algorithm Interview Patterns](/post/3233466876/greedy-patterns/).

Google coding interviews test matrix grid problems. Review BFS, DFS, and DP patterns in [Matrix Traversal Interview Patterns](https://www.techinterview.org/post/3233467378/matrix-traversal-patterns/).

Google coding interviews test heap data structures. Review the two-heap median pattern in [Two Heaps Interview Pattern](https://www.techinterview.org/post/3233467401/two-heaps-pattern/).

Google system design covers build and CI/CD systems. Review the pipeline DAG and runner design in [CI/CD Pipeline System Low-Level Design](https://www.techinterview.org/post/3233467426/lld-ci-cd-pipeline/).

Google system design covers authentication and session management. Review the full session LLD in [Session Management System Low-Level Design](https://www.techinterview.org/post/3233467449/lld-session-management/).

Google system design covers DNS and distributed naming. Review the DNS resolution hierarchy and GeoDNS design in [DNS Resolver and DNS System Design](https://www.techinterview.org/post/3233467497/lld-dns-resolver/).

Google system design covers search indexing. Review the inverted index and BM25 ranking LLD in [Search Indexing System Low-Level Design](https://www.techinterview.org/post/3233467522/lld-search-indexing/).

Redis-based leaderboard design is covered in our [Leaderboard System Low-Level Design](https://www.techinterview.org/post/3233472975/lld-leaderboard-system/).

Experimentation and feature flagging systems are covered in our [A/B Testing Platform Low-Level Design](/post/3233467235/lld-ab-testing/).

Media upload service and CDN serving design is covered in our [Media Upload Service Low-Level Design](https://www.techinterview.org/post/3233467546/lld-media-upload/).

OAuth 2.0 social login system design is covered in our [Social Login System Low-Level Design](https://www.techinterview.org/post/3233467568/lld-social-login/).

BFS, DFS, Dijkstra, and Union-Find patterns are covered in our [Graph Algorithm Patterns for Coding Interviews](https://www.techinterview.org/post/3233467617/graph-algorithm-patterns/).

RBAC and Google Drive-style permission system design is in our [Access Control System Low-Level Design](/post/3233466780/lld-access-control-system/).

Sliding window and string algorithm patterns are covered in our [String Algorithm Patterns for Coding Interviews](https://www.techinterview.org/post/3233467640/string-algorithm-patterns/).

Interval merge and scheduling patterns are covered in our [Interval Algorithm Patterns for Coding Interviews](https://www.techinterview.org/post/3233467664/interval-merge-patterns/).

Price tracking and alert system design is covered in our [Price Alert System Low-Level Design](https://www.techinterview.org/post/3233467686/lld-price-alert/).

Search history system design is covered in our [Search History System Low-Level Design](https://www.techinterview.org/post/3233467708/lld-search-history/).

Two-factor authentication and TOTP system design is covered in our [Two-Factor Authentication System Low-Level Design](https://www.techinterview.org/post/3233467732/lld-two-factor-auth/).

GDPR consent management system design is covered in our [Consent Management System Low-Level Design](https://www.techinterview.org/post/3233467757/lld-consent-management/).

Contact management and sync system design is covered in our [Address Book System Low-Level Design](https://www.techinterview.org/post/3233467758/lld-address-book/).

Storage quota and resource limit system design is covered in our [Storage Quota System Low-Level Design](https://www.techinterview.org/post/3233467805/lld-storage-quota/).