5.1 Real-Time vs. Batch Recommendations

Machine Learning Interview Guide for Top Tech Roles (2025)

5 min read 1050 words

🪄 Step 1: Intuition & Motivation

Core Idea: A recommender model is only as good as its speed. No one wants to wait 2 seconds for Netflix to suggest a movie — you need relevant, personalized results instantly.

That’s where the real-time vs. batch distinction comes in.

Batch systems think deeply but slowly 🧠🐢
Real-time systems think quickly but must stay lightweight ⚡️🐇

The art of recommender engineering lies in balancing intelligence and speed — so users get smart recommendations faster than they can blink.

Simple Analogy: Think of a restaurant kitchen 🍽️

The batch system is like meal prep: chopping vegetables and marinating meat before the rush.
The real-time system is like the chef assembling your dish in seconds when you order. Both are essential — one prepares, the other performs.

🌱 Step 2: Core Concept

Recommender pipelines usually follow a three-stage process:

User request → Candidate Generation → Scoring → Ranking → Final Recommendations

Let’s unpack these stages step by step.

Candidate Generation: Finding the Needle in the Haystack

This is where we narrow billions of possible items down to a few hundred candidates.

If you have:

1M users
10M items

You can’t score every item for every user — that’s computational suicide. Instead, you first find potentially relevant items quickly.

Techniques:

Collaborative similarity (nearest neighbors in embedding space)
ANN search (using FAISS or ScaNN)
Heuristics (e.g., trending, category filters)

Output: top ~1,000 candidates per user Fast and approximate, but not perfect.

Think of it as pre-selecting promising ingredients before cooking the final dish.

Scoring: Assigning Relevance Values

Now, for each candidate, a heavier model (like a neural network or gradient boosted tree) predicts a relevance score: “How much will this user like this item?”

Input features may include:

User embeddings
Item embeddings
Context (time, device, session, etc.)

This is where deep models like NCF or Wide & Deep often operate.

Output: A ranked list of candidate–score pairs.

Think of scoring as the taste test — assigning a flavor rating to each dish candidate.

Ranking: Final Sorting for Display

Finally, a lightweight ranking model or heuristic orders the items:

Sort by predicted relevance score
Apply business logic (diversity, freshness, fairness)
Return the top K items (e.g., 10–20)

Ranking ensures balance — maybe a mix of trending, new, and relevant items.

Like arranging the final platter — everything tasty, but also colorful and balanced.

⚙️ The Real-Time vs. Batch Dilemma

Aspect	Batch Recommendations	Real-Time Recommendations
When Trained	Offline, periodically (e.g., daily)	Continuously or on-demand
Data Used	Historical	Recent or streaming
Computation	Heavy (full model retraining)	Lightweight (incremental updates)
Examples	User embeddings, item embeddings, global retrains	Session-based ranking, trending content
Latency	Minutes–hours	Milliseconds–seconds

Most modern recommenders use both:

Batch: build the foundation (embeddings, similarity graph)
Real-time: add freshness (session updates, re-ranking)

📐 Step 3: Mathematical Foundation

Let’s now unpack the magic behind fast retrieval — the secret sauce of real-time recommendations.

Approximate Nearest Neighbor (ANN) Search

When you represent users and items as vectors in an embedding space:

Recommendation = finding nearest item vectors to a given user vector.

The naïve approach (exact search) computes distance to every item:

$$ \text{Nearest}(u) = \arg\min_i ||p_u - q_i|| $$

That’s $O(N)$ — too slow for millions of items.

ANN (Approximate Nearest Neighbor) algorithms trade a bit of accuracy for massive speed, achieving sublinear time:

Build an index of item embeddings
Partition space using trees, graphs, or quantization
Query only nearby clusters

Frameworks:

FAISS (Facebook AI Similarity Search)
ScaNN (Google’s Scalable Nearest Neighbor Search)

These reduce latency from seconds → milliseconds.

Instead of checking every store in town for your favorite snack, ANN jumps straight to the few neighborhoods most likely to have it.

Caching & Precomputation

For heavy models, precompute as much as possible:

Precompute item embeddings offline
Cache top-K recommendations per user
Store frequent results in memory or Redis

When a user revisits, the system only adjusts for freshness (e.g., new items, latest interactions).

$$ \text{Final Rec} = \text{Cached Rec} + \text{Realtime Adjustments} $$

This hybrid caching approach keeps latency under 50 ms.

It’s like a chef who keeps partially-prepped meals — just add the final garnish when the order comes in.

Offline vs. Online Learning

Type	Description	Pros	Cons
Offline (Batch)	Train full models periodically	Stable, accurate	Slow to adapt
Online (Incremental)	Update weights with streaming data	Adapts quickly	Risk of drift, instability

Many systems use hybrid retraining:

Retrain major embeddings nightly (batch)
Refresh user embeddings or biases in real-time (online)

This maintains balance between freshness and stability.

Offline models are like textbooks — comprehensive but slow to update. Online models are like newsfeeds — always fresh but sometimes noisy.

🧠 Step 4: Assumptions or Key Ideas

User and item embeddings are static enough to reuse for short time windows.
Recent activity = higher relevance → session or recency bias improves click-through.
Approximate similarity is acceptable if results are fast.
Hybrid retraining ensures consistency between long-term and short-term data.

⚖️ Step 5: Strengths, Limitations & Trade-offs

Enables large-scale, low-latency recommendation serving.
ANN indexing scales to billions of items.
Hybrid batch + real-time design ensures freshness and stability.
Caching and precomputation massively cut inference cost.

ANN is approximate — some accuracy loss possible.
Complex system design (multiple layers, caches, retraining).
Online learning may drift without control.
Maintaining freshness at scale adds operational overhead.

You trade accuracy for speed — but when your target is <50 ms latency, a 1% accuracy loss is often worth it. This is why production systems use multi-stage architectures instead of one monolithic model.

🚧 Step 6: Common Misunderstandings

🚨 Common Misunderstandings (Click to Expand)

“Real-time means retraining the whole model instantly.” No — only user embeddings or scores are updated. The core model stays stable.
“ANN gives exact results.” ANN gives close enough results much faster — a deliberate trade-off.
“Caching = stale data.” Smart caching includes freshness logic (e.g., weighted by recency or trending signals).

🧩 Step 7: Mini Summary

🧠 What You Learned: Real-time vs. batch recommendations represent the trade-off between intelligence and latency.

⚙️ How It Works: Batch systems train embeddings and precompute candidates, while real-time systems use ANN search, caching, and incremental updates for millisecond serving.

🎯 Why It Matters: Understanding this balance is the backbone of scalable recommender architecture — ensuring users get personalized, up-to-date recommendations instantly.

5.2 Model Deployment and Monitoring 4.2 Contextual and Hybrid Features