Recommendation Engines: How Netflix Knows What You Will Watch Next

The Netflix Prize: $1 Million for 10% Better Recommendations

In 2006, Netflix offered $1 million to anyone who could improve their recommendation engines by 10%. Over 40,000 teams from 186 countries competed for 3 years. The winning team (BellKor's Pragmatic Chaos) achieved exactly 10.06% improvement using an ensemble of matrix factorization models.Here's the part most people miss: predicting what to recommend is only step one. Actually fetching that data for millions of users in real time is its own engineering challenge-one that comes down to smart indexing and query optimization. Netflix credits recommendations for 80% of content watched on the platform - meaning 4 out of 5 shows you watch were suggested by the algorithm, not found by browsing. Amazon attributes 35% of revenue to recommendations. YouTube says 70% of watch time comes from recommended videos. Spotify's Discover Weekly generates 40% of new artist discoveries. Getting recommendations right is not just a nice feature - it IS the product.

Three Fundamental Approaches

Recommendation Algorithm Family Tree:

  1. COLLABORATIVE FILTERING (CF)
     'Users who liked what you liked, also liked THIS'

     User-Item Rating Matrix:
                Movie A  Movie B  Movie C  Movie D
     User 1:      5        3        ?        4
     User 2:      4        ?        5        ?
     User 3:      ?        3        4        5
     User 4:      5        4        ?        ?  <-- predict these

     User-based CF:
     User 4 is similar to User 1 (both rated A:5, B:3-4)
     User 1 liked Movie D (4) -> recommend D to User 4

     Item-based CF:
     Movie A and Movie D are similar (liked by same users)
     User 4 liked Movie A -> recommend Movie D

     Pros: no content analysis needed, discovers surprising connections
     Cons: cold start (new users/items have no data), popularity bias

  2. CONTENT-BASED FILTERING
     'You liked sci-fi action movies, here are more sci-fi action movies'

     Item features: genre, actors, director, length, mood
     User profile: vector of preferred features
     Score = similarity(user_profile, item_features)

     Pros: works for new items, no need for other users' data
     Cons: never recommends outside user's bubble, requires good metadata

  3. HYBRID (what everyone uses in production)
     Combine CF + content-based + contextual signals

Matrix Factorization

How Matrix Factorization Work:

  The user-item matrix is HUGE and SPARSE:
  100M users x 50K items = 5 trillion cells
  Only 0.01% are filled (users rate very few items)

  Factor into two smaller matrices:

  R(100M x 50K) ~ U(100M x 50) * V(50 x 50K)

  U = user matrix (100M users, 50 latent factors each)
  V = item matrix (50K items, 50 latent factors each)

  Latent factors capture hidden preferences:
  Factor 1: action vs drama preference
  Factor 2: old classics vs new releases
  Factor 3: complex plots vs simple stories
  ...

  Predicted rating for user i, item j:
  score(i,j) = dot_product(U[i], V[j])

  Algorithms:
  - SVD++ (Netflix Prize winner component)
  - ALS (Alternating Least Squares) - parallelizable, Spark-native
  - Neural Collaborative Filtering - deep learning variant

  Modern: embeddings from deep learning models (Word2Vec-style)
  Item2Vec: treat items click sequence like a sentence,
  learn item embeddings. Similar items = close vectors.

Production Architecture: Two-Stage Pipeline

How Netflix/YouTube/Amazon Actually Work:

  Stage 1: CANDIDATE GENERATION (fast, recall-focused)
  +-------------------------------------------------+
  | From 50K items, find ~500 candidates             |
  |                                                  |
  | Methods:                                         |
  | - ANN (Approximate Nearest Neighbor) on embeddings|
  | - Collaborative filtering top matches             |
  | - Content-based similarity                        |
  | - Popularity (trending/new releases)              |
  |                                                  |
  | Speed: <50ms for 500 candidates                  |
  +-------------------------------------------------+
           |
           v
  Stage 2: RANKING (slow, precision-focused)
  +-------------------------------------------------+
  | Score 500 candidates with a rich model            |
  |                                                  |
  | Features per candidate:                           |
  | - CF score (how similar users rated this)          |
  | - Content match (genre, metadata similarity)       |
  | - User context (time of day, device, mood)         |
  | - Item freshness (new content boost)               |
  | - Watch history (avoid recommending watched items) |
  | - Social signal (friends watched this)             |
  |                                                  |
  | Model: gradient-boosted trees or deep neural net  |
  | Output: ranked list of 50 items to display        |
  |                                                  |
  | Speed: <100ms for 500 candidates                 |
  +-------------------------------------------------+
           |
           v
  Stage 3: BUSINESS RULES + DIVERSITY
  - Ensure genre diversity (not 10 sci-fi in a row)
  - Apply freshness boost (new content gets surfaced)
  - Remove items with legal/regional restrictions
  - Apply A/B test allocation for model experiments

The Cold Start Problem

Cold Start Solutions:

  New User (no history):
  - Onboarding quiz: Spotify asks 3 artists, Netflix shows genre tiles
  - Popularity fallback: show trending/top-rated until signal builds
  - Demographics: age + location suggest initial preferences
  - Transfer learning: use sign-up source (came from TikTok ad?)

  New Item (no ratings):
  - Content-based: match metadata to existing items
  - Creator reputation: new video from popular creator = boost
  - Exploration: show to small random group, measure engagement
  - Bandit algorithms: balance exploitation (show proven hits)
    and exploration (surface unknown items) mathematically

  Signal accumulation speed:
  Explicit signals (ratings): slow, sparse, high quality
  Implicit signals (clicks, time, scroll): fast, dense, noisy
  Best: combine both. Weight implicit heavily, explicit for calibration.

Interview Tip

When designing a recommendation system, structure your answer around the two-stage pipeline: 'Stage 1 is candidate generation - I would use approximate nearest neighbor search on user and item embeddings to find 500 candidates from millions of items in under 50ms. Stage 2 is ranking - a gradient-boosted tree or neural network scores each candidate using collaborative filtering signals, content features, user context (time, device), and freshness. I would post-process for diversity to avoid showing 10 similar items. For cold start, I would use an onboarding quiz for new users and content-based matching for new items, with bandit algorithms to balance exploration and exploitation.' Mention that Netflix uses hundreds of models and A/B tests constantly.

Key Takeaway

Recommendation systems use a two-stage pipeline: fast candidate generation (500 items from millions via embeddings) then rich ranking (scoring candidates with context, history, and content signals). Collaborative filtering finds patterns from collective user behavior. Content-based filtering matches item attributes. Production systems combine both in hybrid approaches. Cold start is solved through onboarding, popularity fallback, and exploration/exploitation balancing.

If you're new to how AI systems like this are built end-to-end, check out our complete guide to Generative Al and LLM architecture.