Cold start

The hardest, most practical problem in recommendations: what do you recommend when you have no data? A brand-new user with no history, or a brand-new item with no interactions, breaks every collaborative-filtering model (no row/column to learn from). Handling cold start well is what separates a toy from a product.

Three flavors of cold start

Each needs a different mix of fixes.

New-user cold start

You can't personalize from nothing, so degrade gracefully along this ladder, adding personalization as signal arrives:

1. Show trending / popular items. The single best zero-knowledge guess — it's why every app's first screen is "Popular now". (This is the Trending baseline, and exactly the fallback in our demo below.)
2. Ask a little (onboarding). "Pick a few topics/creators you like." Three taps convert a cold user into a warm one — these picks seed a content-based profile immediately.
3. Use what context you have. Sign-up country, language, device, referrer, time of day — even a coarse popularity-by-segment ("popular with users in your region") beats global popularity.
4. Switch to personalization fast. After even one or two interactions, content-based filtering can build a (rough) taste vector; after more, CF/MF kicks in. The art is blending these as confidence grows.

See the fallback in code

Our demo asks a personalized model and a fallback model to recommend for a brand-new user id with no history:

cold start — a new user with no interactions:
  ContentBased.recommend(new_user) -> []  (empty: no history)
  Trending fallback                -> [127, 105, 87, 78, 13]  (works without history)

The personalized model correctly returns nothing (it has no profile to work from), and the system falls back to trending — which needs no per-user data. That graceful hand-off is the core cold-start pattern, in two lines.

New-item cold start

A new item has no interactions, so CF can never surface it. Fixes:

1. Content-based filtering. This is content-based's superpower: embed the new item from its features/text and it's immediately recommendable to users whose taste vector is nearby — no interactions required (Chapter 5).
2. Two-tower models. The item tower turns features into an embedding, so a new item gets a vector the moment it's added (Chapter 9).
3. Deliberate exploration. Intentionally show the new item to some users to gather the interactions CF needs — which leads to the key idea below.

Exploration vs. exploitation (bandits)

There's a fundamental tension:

• Exploit: show what you already know works (safe, good short-term metrics).
• Explore: show uncertain/new items to learn whether they're good (risky short-term, essential long-term).

Pure exploitation creates a trap: new items never get shown, so they never gather data, so they're never shown — the feedback loop that buries the long tail. Multi-armed bandit algorithms balance the two:

• ε-greedy: exploit the best item with probability $1-\varepsilon$; with probability $\varepsilon$, show a random/new item to learn. Dead simple, works.
• Upper Confidence Bound (UCB): rank by optimistic estimate — value plus an uncertainty bonus that's large for rarely-shown items — so under-explored items get a chance precisely because we're unsure about them.
• Thompson sampling: keep a probability distribution over each item's true value and sample from it; naturally shows promising-but-uncertain items more often.

Bandits are how systems give new items a fair shot without tanking metrics, and contextual bandits (which condition the choice on user/context features) are widely used for cold-start and exploration in real recommenders.

A practical cold-start policy

A real system stitches these together by how much it knows about the user:

   interactions known about the user
   0            ──►  trending / popular (+ context, + onboarding picks)
   1 .. a few   ──►  content-based taste vector (works from a short history)
   many         ──►  collaborative filtering / MF / two-tower (full personalization)
   throughout   ──►  a little exploration (bandit) to keep learning & surface new items

This blend — popularity for the cold, content-based for the lukewarm, CF for the warm, plus constant exploration — is the backbone of robust real-world systems.

Now, how all this runs fast at scale. 👉