How Netflix and Spotify Use Data Science to Recommend What You’ll Love

Netflix says its recommender system influences the majority of what members stream, and Spotify’s Discover Weekly turned a personalization model into a flagship product. Both platforms solve the same core problem: ranking millions of items for hundreds of millions of users from sparse, noisy behavioral signals. The methods differ in emphasis, but they share one architecture: candidate generation, ranking, and continuous experimentation.

Quick Takeaways

• Netflix relies on matrix factorization, deep neural rankers, and contextual bandits to personalize rows, titles, and artwork.
• Spotify blends collaborative filtering, NLP on playlists and text, and audio analysis (CNNs on spectrograms) to solve the cold-start problem.
• Both use a two-stage pipeline: retrieve hundreds of candidates cheaply, then rank them with a heavier model.
• Success is measured by A/B tests on engagement (retention, streams, completion rate), not just offline metrics like RMSE or NDCG.

The Recommendation Problem: Framing the Data

A recommender estimates a preference score r̂(u, i) for user u and item i. The data lives in a user-item interaction matrix that is more than 99% empty. Two signal types dominate:

• Explicit feedback: star ratings, thumbs up/down. Clean but rare.
• Implicit feedback: plays, skips, watch time, repeats. Abundant but noisy. A play does not equal a like.

Netflix moved away from star ratings toward thumbs and implicit behavior for this reason. Spotify has always been implicit-first: a skip within 30 seconds is a strong negative label, and a save or repeat is a strong positive one.

Stage 1: Collaborative Filtering and Matrix Factorization

Collaborative filtering (CF) assumes users with similar histories like similar items. Matrix factorization compresses the sparse matrix R into two low-rank matrices:

R ≈ P · Qᵀ, where P (users × k) and Q (items × k) hold latent factors.

For implicit data, the standard approach is Alternating Least Squares (ALS) with confidence weighting, popularized by Hu, Koren, and Volinsky. Spotify’s early recommender infrastructure used ALS-style factorization at scale.

Implementation with Python

import numpy as np
import scipy.sparse as sparse
from implicit.als import AlternatingLeastSquares

# Build a sparse user-item matrix from interaction logs
# df columns: user_id (int), item_id (int), plays (int)
user_items = sparse.csr_matrix(
    (df["plays"].astype(np.float32), (df["user_id"], df["item_id"]))
)

# Confidence weighting: more plays = higher confidence, with log damping
alpha = 40
user_items.data = 1 + alpha * np.log1p(user_items.data)

model = AlternatingLeastSquares(
    factors=64,          # latent dimension k
    regularization=0.05, # L2 penalty to limit overfitting
    iterations=20,
    random_state=42,
)
# implicit>=0.5 expects user x item matrices in fit()
model.fit(user_items)

# Top-10 recommendations for one user, filtering already-seen items
ids, scores = model.recommend(
    userid=123,
    user_items=user_items[123],
    N=10,
    filter_already_liked_items=True,
)

Stage 2: Deep Learning Rankers

Matrix factorization captures only linear interactions. Modern rankers add context, such as device, time, session history, and item metadata, through neural networks.

• Two-tower models: One tower encodes the user, the other encodes the item. Their dot product scores relevance. Item embeddings are precomputed and served through approximate nearest neighbor (ANN) indexes (e.g., FAISS, ScaNN) for fast retrieval.
• Sequence models: RNNs, Transformers, and attention-based architectures model the order of watched or played items. Netflix has published work on sequential and foundation-model approaches to member behavior.
• Multi-task learning: A single network predicts several outcomes (click, completion, save) and blends them into one ranking score.

Minimal Two-Tower Skeleton (TensorFlow/Keras)

import tensorflow as tf

EMB_DIM = 64

def build_tower(vocab_size, name):
    inp = tf.keras.Input(shape=(), dtype=tf.int32, name=f"{name}_id")
    x = tf.keras.layers.Embedding(vocab_size, EMB_DIM)(inp)
    x = tf.keras.layers.Dense(128, activation="relu")(x)
    x = tf.keras.layers.Dense(EMB_DIM)(x)
    # L2-normalize so the dot product equals cosine similarity
    x = tf.keras.layers.UnitNormalization()(x)
    return inp, x

user_in, user_vec = build_tower(vocab_size=1_000_000, name="user")
item_in, item_vec = build_tower(vocab_size=200_000, name="item")

# Dot product gives the relevance logit
score = tf.keras.layers.Dot(axes=1)([user_vec, item_vec])
model = tf.keras.Model([user_in, item_in], score)

# Train with implicit labels (1 = positive interaction, 0 = sampled negative)
model.compile(
    optimizer=tf.keras.optimizers.Adam(1e-3),
    loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
    metrics=[tf.keras.metrics.AUC(name="auc", from_logits=True)],
)

Solving Cold Start: Content Signals

New users and new items have no interaction history. Both platforms lean on content.

Spotify analyzes tracks three ways:

1. Audio: Convolutional networks over spectrograms learn timbre, tempo, and rhythm representations.
2. Text: NLP models process playlist titles, track metadata, and web text about artists.
3. Collaborative signals: Tracks that co-occur in user playlists end up near each other in embedding space.

Netflix uses title metadata (genre, cast, language), content embeddings, and early-exposure exploration to place new releases. New members get onboarding genre selections to seed the model.

Explore vs. Exploit: Contextual Bandits

A pure exploitation strategy shows only what the model already knows you like. That traps users in filter bubbles and starves new items of data. Multi-armed bandits balance the two.

Netflix has described using bandit algorithms to personalize which artwork appears for each title. Each image is an arm. The reward is a play. Spotify has described similar exploration in homepage and shelf personalization.

import numpy as np

class ThompsonSampler:
    """Beta-Bernoulli Thompson Sampling for choosing among K variants."""
    def __init__(self, n_arms):
        self.alpha = np.ones(n_arms)  # successes + 1
        self.beta = np.ones(n_arms)   # failures + 1

    def select(self):
        # Sample a plausible CTR for each arm, pick the best draw
        return int(np.argmax(np.random.beta(self.alpha, self.beta)))

    def update(self, arm, reward):
        self.alpha[arm] += reward
        self.beta[arm] += 1 - reward

sampler = ThompsonSampler(n_arms=5)
arm = sampler.select()         # choose artwork variant
sampler.update(arm, reward=1)  # user clicked play

Algorithm Comparison

Evaluation: Offline Metrics vs. Online Truth

Offline metrics guide iteration. Online experiments decide launches.

import numpy as np

def ndcg_at_k(relevances, k=10):
    """relevances: list of graded relevance in ranked order."""
    rel = np.asarray(relevances)[:k]
    discounts = 1.0 / np.log2(np.arange(2, rel.size + 2))
    dcg = np.sum((2**rel - 1) * discounts)
    ideal = np.sort(np.asarray(relevances))[::-1][:k]
    idcg = np.sum((2**ideal - 1) * discounts[: ideal.size])
    return dcg / idcg if idcg > 0 else 0.0

print(ndcg_at_k([3, 2, 0, 1, 0], k=5))

Netflix and Spotify both lean heavily on A/B testing and interleaving experiments. Offline gains often fail to translate online, so every model ships behind an experiment.

Data Engineering Behind the Scenes

Recommendations are only as good as the pipeline feeding them.

• Event streaming: Play, skip, and search events flow through log pipelines (Kafka-style systems) into batch and real-time stores.
• Feature stores: Shared, versioned features keep training and serving consistent and reduce training-serving skew.
• Batch plus real-time: Heavy model training runs offline on distributed frameworks such as Spark. Lightweight session features update in near real time.
• Caching: Precomputed candidate lists and embeddings are served from low-latency stores to meet response budgets.

PySpark ALS for Large Catalogs

from pyspark.sql import SparkSession
from pyspark.ml.recommendation import ALS

spark = SparkSession.builder.appName("recs").getOrCreate()

# ratings: user_id, item_id, plays
als = ALS(
    userCol="user_id",
    itemCol="item_id",
    ratingCol="plays",
    implicitPrefs=True,      # treat plays as confidence, not ratings
    rank=64,
    regParam=0.05,
    alpha=40,
    coldStartStrategy="drop" # avoid NaN predictions for unseen ids
)
model = als.fit(ratings)
top10 = model.recommendForAllUsers(10)

Practical Example: Predicting What a New Listener Will Skip

Scenario: A music app wants to reduce early skips for users with fewer than 20 plays.

1. Label: Skip within 30 seconds = 1.
2. Features: Audio embeddings, tempo, genre, time of day, device, previous-session skip rate.
3. Model: Gradient-boosted trees (e.g., XGBoost) for a strong tabular baseline.
4. Evaluate: AUC-ROC offline, then skip-rate reduction in an A/B test.

import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score

X_train, X_val, y_train, y_val = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

clf = xgb.XGBClassifier(
    n_estimators=400,
    max_depth=6,
    learning_rate=0.05,
    subsample=0.8,
    colsample_bytree=0.8,
    eval_metric="auc",
    early_stopping_rounds=30,
)
clf.fit(X_train, y_train, eval_set=[(X_val, y_val)], verbose=False)

print("Validation AUC:", roc_auc_score(y_val, clf.predict_proba(X_val)[:, 1]))

Practical Example: Fixing Popularity Bias

Scenario: A streaming catalog over-recommends blockbusters.

• Apply inverse propensity weighting to down-weight popular items during training.
• Re-rank with a diversity penalty such as Maximal Marginal Relevance (MMR).
• Track coverage and long-tail share alongside accuracy metrics.

Common Pitfalls

• Data leakage: Split by time, not randomly. Random splits let future behavior leak into training.
• Feedback loops: Models train on data they themselves shaped. Log exploration traffic to correct for it.
• Over-optimizing clicks: Click-through can reward clickbait. Optimize for completion, retention, or satisfaction proxies.
• Ignoring negatives: Skips and abandoned plays carry signal. Include them.

Strategic FAQ

How does Netflix recommend movies?

Netflix combines collaborative filtering, deep neural rankers, and contextual bandits. It scores titles using viewing history, completion, time of day, and device, then personalizes row order and artwork. Every change is validated through A/B tests.

How does Spotify Discover Weekly work?

Discover Weekly blends collaborative filtering (finding tracks that listeners with similar tastes play), NLP on playlists and text, and audio analysis. It then filters out tracks you already know and delivers a fresh playlist weekly.

What algorithm is best for a recommendation system?

No single algorithm wins. Start with ALS matrix factorization as a baseline, add a two-tower neural model for rich features, and use content embeddings for cold start. Validate with A/B tests.

How do recommender systems handle new users or items?

They use content features (audio, text, metadata), onboarding preferences, and bandit-based exploration to gather early signals until enough interaction data exists for collaborative methods.