How Netflix combined LLMs with collaborative filtering to scale personalization

Netflix serves over 230 million subscribers across different time zones, devices, and content preferences. Traditional collaborative filtering—the method of predicting what you'll like based on what similar users enjoyed—powers most of their recommendations today. But as their catalog grows and user behavior becomes more nuanced, patterns alone don't capture the full story.

A user might watch horror films in October, documentaries during lunch breaks, and family comedies on weekends. Pure collaborative filtering struggles with these shifting contexts because it treats every viewing decision as equally weighted historical data. The system can't distinguish between a binge session and a palette cleanser.

Netflix's research team recently shared how they're addressing this gap with GenRec, a system that combines large language models (LLMs) with traditional recommendation algorithms. The approach uses LLMs not to replace collaborative filtering, but to add a reasoning layer that understands why users make choices. This matters because recommendation systems are moving from pattern matching to context-aware decision making, and the engineering challenges of doing this at global scale reveal practical lessons for anyone building personalized systems.

Why collaborative filtering alone wasn't enough

Collaborative filtering works by finding neighborhoods of similar users or items. If you watched Breaking Bad and users similar to you watched Better Call Saul, the system recommends it. The mathematics is elegant—matrix factorization reduces millions of user-item interactions into compact latent factors that predict preferences efficiently.

But this approach has blind spots at Netflix's scale. A user who just finished a thriller might want something lighter, but collaborative filtering only sees that similar users also watched more thrillers. It treats a show you abandoned after five minutes the same as one you watched twice. As Netflix's catalog expanded past 15,000 titles and viewing patterns fragmented across mobile, TV, and background watching, these gaps widened.

The engineering constraint is real: you can't ask users to manually tag every viewing context. Netflix needed a system that could infer intent from implicit signals—time of day, device type, recently viewed genres, even how quickly someone scrolled past a title. Traditional collaborative filtering algorithms don't have a natural way to incorporate these heterogeneous signals without building dozens of specialized models.

Collaborative filtering tells you what similar users liked; LLMs can explain why a recommendation makes sense right now.

How GenRec uses LLMs to reason about context

GenRec treats the LLM as a reasoning engine, not a pattern matcher. The system constructs a prompt that includes your recent viewing history, the current context (device, time, location), and candidate titles from the collaborative filtering stage. The LLM then generates natural language explanations for why each candidate might be relevant given your current state.

Think of it like the difference between a librarian who knows what books you checked out versus one who also knows you just mentioned planning a trip to Japan. The first can recommend books by authors you've read. The second can suggest travel guides, Japanese cinema, and novels set in Tokyo. GenRec's LLM layer provides that contextual bridge.

The technical implementation uses few-shot prompting with carefully selected examples. Instead of fine-tuning a massive model from scratch, Netflix provides the LLM with three to five exemplar recommendation scenarios in the prompt itself. Each example shows the format: user context, candidate titles, and a brief explanation of fit. The LLM learns the task structure from these examples and applies the reasoning pattern to new cases.

The system doesn't generate recommendations from scratch—that would be computationally prohibitive and unreliable. Instead, collaborative filtering produces a candidate set of perhaps 100 titles, and the LLM re-ranks them based on contextual fit. This hybrid approach keeps the statistical rigor of collaborative filtering while adding the flexible reasoning of language models.

Prompt engineering and fine-tuning techniques

Netflix's prompt design balances completeness with token efficiency. A typical prompt includes structured user data (genres watched, time spent, completion rates), temporal context (day of week, season), and device information. The candidate list comes with metadata—genre, release year, similar titles the user has seen. This structured format helps the LLM focus on reasoning rather than parsing.

The team found that chain-of-thought prompting improved recommendation quality. Instead of asking "Which title best fits this user right now?", they prompt "First, what patterns do you notice in this user's recent behavior? Second, which of these candidates align with those patterns?" Breaking the reasoning into explicit steps reduces hallucination and makes the system's logic auditable.

For production deployment, Netflix uses a combination of approaches. They start with a capable base model (likely GPT-4 class) and apply parameter-efficient fine-tuning (PEFT) using LoRA (Low-Rank Adaptation). LoRA adds small trainable matrices to specific layers rather than updating all model weights. This reduces training time from weeks to days and memory requirements by 75%, making it feasible to maintain multiple model variants for different regions and content types.

The fine-tuning data comes from human raters who evaluate recommendations alongside implicit feedback (did users actually watch what was recommended?). Netflix discovered that combining explicit human judgments with click-through rates produced better models than either signal alone. Human raters catch culturally inappropriate suggestions that might have high predicted click rates, while behavioral data keeps the model grounded in what users actually choose.

Prompt versioning became critical in production. Netflix maintains a library of prompt templates tested against held-out sets of users. They A/B test prompt variations just like they test UI changes, measuring both engagement metrics and explanation quality. Small wording changes—like "recent viewing history" versus "what you've been watching"—can shift the LLM's reasoning in measurable ways.

Balancing computational cost with recommendation quality

Running LLM inference for every recommendation request across 230 million users is economically impractical. Netflix uses a tiered strategy. Most recommendations still come from fast collaborative filtering models that cost fractions of a cent per user per day. The LLM layer activates for specific scenarios: new users with limited history, cold-start items without much interaction data, and personalized browsing contexts where engagement signals suggest the user is actively exploring.

The system uses cascade serving. First-pass recommendations come from cached collaborative filtering results updated every few hours. If a user's behavior changes significantly mid-session (they watch something unexpected, change devices, or search for specific content), the system invokes GenRec with the new context. This adaptive triggering reduces LLM calls to about 5% of recommendation events while targeting the moments where contextual reasoning matters most.

Netflix also applies model distillation to compress GenRec's reasoning into smaller student models for high-traffic endpoints. The full LLM serves as a teacher, generating reasoning traces for thousands of recommendation scenarios. A smaller transformer model (tens of millions of parameters rather than billions) learns to mimic these decisions. The student model runs 10x faster at 1/20th the cost, trading slight accuracy for practical deployment at interactive latencies.

Batch processing handles non-real-time personalization. Overnight jobs use GenRec to pre-compute contextualized recommendations for scenarios like "Saturday morning family viewing" or "weeknight mobile browsing." These get cached and served instantly when the context matches. The system doesn't need to reason about every request if it can predict common contexts in advance.

Hybrid architecture: where traditional algorithms meet generative AI

GenRec's architecture reflects a principle: use each technology where it's strongest. Collaborative filtering excels at finding statistical patterns across millions of users—it's the foundation. LLMs excel at flexible reasoning over unstructured context—they're the enhancement layer.

The system's data flow starts with offline processing. Collaborative filtering models train on complete interaction history using Apache Spark clusters. These models run SVD (Singular Value Decomposition) or ALS (Alternating Least Squares) to produce latent factor embeddings for every user and item. This step happens daily and produces the candidate sets that feed into GenRec.

At inference time, the system fetches a user's embedding and retrieves nearest neighbors in item space—this is pure linear algebra, sub-millisecond fast. The top 100 candidates become the LLM's input along with contextual features. The LLM's job is narrow: given these statistically likely matches, which best fit the current moment? This scoping is crucial—it prevents the LLM from hallucinating recommendations for content Netflix doesn't carry or making statistically absurd suggestions.

The output layer blends scores. Collaborative filtering provides a base relevance score, GenRec provides a contextual adjustment, and business rules layer on top (license availability, regional restrictions, content ratings). The final ranking weighs these signals, with GenRec's contribution tuned per market based on A/B test results.

Netflix's team emphasized that this isn't an "either-or" architecture. Generative AI didn't replace decades of recommendation systems research—it augmented it. The hybrid approach lets them deploy improvements incrementally. A new LLM version might improve explanations without touching the collaborative filtering infrastructure. Better embeddings from matrix factorization improve candidate quality even if the LLM stays fixed.

The monitoring strategy treats each component separately. Collaborative filtering metrics (precision, recall, coverage) track candidate quality. LLM metrics (reasoning coherence, explanation diversity, hallucination rate) track re-ranking quality. End-to-end metrics (click-through rate, streaming hours, session length) measure user value. This separation makes debugging production issues tractable—if engagement drops, you can isolate whether the issue is candidate generation, contextual reasoning, or downstream systems.

What this means for builders

If you're building recommendation systems, GenRec's architecture offers a practical blueprint. Start with a solid statistical foundation—collaborative filtering, content-based filtering, or learned embeddings. These systems are well-understood, efficient, and debuggable. Add LLM reasoning selectively where context matters: new users, ambiguous queries, or moments when user intent shifts.

Design prompts that constrain the LLM's task. Don't ask it to generate recommendations from scratch; ask it to re-rank statistically sound candidates using context. This scoping reduces hallucination and keeps inference costs manageable. Structure your prompts with clear sections: user history, current context, candidate items, and the specific reasoning task.

Invest in prompt versioning and A/B testing infrastructure from day one. Track not just engagement metrics but explanation quality. Can users understand why they got a recommendation? Does the reasoning match their actual behavior? Netflix's experience shows that explainability matters—it builds trust and helps users discover content they wouldn't find otherwise.

Consider cascade serving before you scale. Run LLMs only when context changes significantly or for users where cold-start is an issue. Cache predictions for common scenarios. Profile your latency and cost per request obsessively—LLM inference is expensive enough that small optimizations compound at scale.

If you're using open-weight models like Llama or Mistral, LoRA fine-tuning is your friend. You can adapt a base model to your domain using 1-2% of the training cost of full fine-tuning. Start with few-shot prompting to validate the approach, then invest in fine-tuning once you've proven the LLM layer adds measurable value.

For teams without Netflix's resources, model distillation offers a path to production. Run a large model offline to generate training data, then train a smaller model to mimic those decisions. A 100M parameter student model fine-tuned on GPT-4 reasoning traces can deliver 70-80% of the quality at 5% of the cost.

Conclusion

Netflix's GenRec demonstrates that the most powerful uses of LLMs often augment existing systems rather than replace them. Collaborative filtering's statistical rigor combined with an LLM's contextual reasoning creates capabilities neither approach delivers alone. The architecture acknowledges computational reality—you can't afford to run expensive models for every request—while targeting LLM inference where it adds the most value.

This hybrid approach is appearing across production machine learning systems. Search engines use embeddings for retrieval and LLMs for re-ranking. Code completion tools use syntax trees for candidates and LLMs for contextual filtering. The pattern holds: fast, specialized models handle the bulk of work; LLMs add a reasoning layer where context and nuance matter. As these systems mature, the engineering challenge shifts from "should we use an LLM?" to "where exactly does LLM reasoning justify its cost?" Netflix's answer—cascade serving, careful prompting, and hybrid architecture—offers a template for teams working through that question.