Cold start
Collaborative filtering needs interactions, but a new user has clicked nothing, a fresh upload has been watched by no one, and a day-one platform has neither. This is not an edge case you patch at the end — on a platform that ingests millions of items a day, cold start is the steady state.
The chicken-and-egg loop
Collaborative filtering learns an embedding for an entity from who it co-occurs with. A brand-new item has no co-occurrences, so it has no learned embedding, so the ranker scores it near-randomly, so it never gets recommended, so it earns no co-occurrences. The loop is closed and self-perpetuating:
Every cold-start technique is, at bottom, a way to break that loop. There are exactly two moves: supply an embedding from somewhere other than history (content side-information, meta-learned initializations, cross-domain transfer), or buy the first interactions with impressions (exploration, paying a bounded learning cost called regret). Everything below is a variation on one of those two.
Three flavors of cold — name which side is empty
"Cold start" is one word for three distinct failures, separated by which side of the user–item matrix is missing. Diagnosing which one you face is the whole first move, because the cures differ.
| Type | What's empty | Why CF fails | Primary bridge |
|---|---|---|---|
| User cold start | The new user's row — no clicks, watches, or likes | No basis to estimate their taste vector | Registration / device priors + fast exploration of interest |
| Item cold start | The new item's column — no impressions or engagement | No co-occurrence to learn its embedding | Content features (CV / NLP / audio) + exploration budget |
| System cold start | The entire matrix — new platform or new vertical | Nothing to train on at all | External transfer, hand-rules, popularity, editorial seeding |
A subtler axis cuts across all three: absolute cold start (literally zero data) versus warming (a handful of signals — one watch, one device fingerprint). The warming case is far more common and far more tractable, because even one interaction lets you start updating a prior. Most of the engineering is about shrinking the absolute-cold window from "weeks" to "the first session."
Content side-information — the bridge that needs no history
The deepest insight in cold start: an item's content exists before any user touches it. A new video has pixels, audio, a title, a creator, and a category the instant it is uploaded — features that require zero interaction history. If we can map content into the same embedding space the ranking model already uses, a cold item gets a usable vector on arrival, and the chicken-and-egg loop is broken from the item side.
Concretely: a multimodal encoder (see 14 · Multimodal recommendation) produces a content embedding e_c — CLIP-style visual semantics, a BERT title vector, audio features. We learn a projection f_θ so content space aligns with the collaborative space the model already trusts. The objective is to make a warm item's content embedding predict its collaborative embedding:
min_θ Σ_{i ∈ warm} ‖ f_θ(e_c^(i)) − e_cf^(i) ‖²
Train f_θ on the items that do have collaborative embeddings (the warm catalog), then at inference apply it to cold items, which have only content. This is the trick: warm items supply free supervision for the cold ones, because every warm item is a (content → behavior) example. The same content features can feed the ranker directly as inputs, so even an end-to-end model degrades gracefully when ID embeddings are uninformative — the content tower carries the prediction.
This is exactly the principle lesson 02 · Candidate generation flagged when it said cold start is "handled at the right layer" — solved by which features go into the tower, not by bolting on a separate content-based recommender. This lesson is the deep dive on that claim. The senior framing: make the item tower of the collaborative model itself consume content features, so head and tail items share one code path; add a dedicated content source only if you have evidence the content tower is being starved of gradient on tail items.
Bootstrapping a new user — priors before behavior
A new user is an empty row, but never truly empty. Before they click anything, you already hold weak priors — and the art is stacking enough of them to make the first recommendation better than random.
- Registration info. Age, gender, declared interests, onboarding "pick 3 topics" screens. Cheap and explicit, but sparse and often skipped. Best used as a coarse segment prior, not a precise taste vector.
- Device & context metadata. Phone model (a proxy for spending power), OS, IP-derived geolocation, time of day, network type. These need no user cooperation and are available on the very first request — the workhorse of implicit profiling.
- Popularity priors. When you know nothing about a user, the population's behavior is your best guess. Serve what is globally (or segment-locally) popular — the maximum-likelihood bet under zero personal evidence. This is the universal fallback for all three cold-start flavors.
- Fast interest capture. Treat the first session as an active probe. Show a deliberately diverse opening set, read the millisecond-level feedback (watch-time, swipe-away, like), and collapse the candidate interest space within a handful of items. On a high-DAU app a user's row can go from empty to richly informative in under a minute.
- Cross-domain transfer. If the user authenticated via a sister product (e-commerce, social), import that profile as a starting prior — covered below.
Exploration vs exploitation — the regret you must pay
Here is the conflict at the heart of cold start. Every impression is a choice: exploit (show the item your current model thinks is best, banking certain short-term reward) or explore (show an uncertain new item to learn its quality, gambling short-term reward for information). Pure exploitation never discovers good new items; pure exploration tanks the experience. The cold-start question, formalized, is the multi-armed bandit.
Picture each item as a slot-machine arm with an unknown payout probability — its true CTR μ_i. You have a budget of pulls (impressions). The cost of not playing optimally is regret — the gap between what you earned and what an oracle who knew every μ_i would have earned:
Regret(T) = T · μ* − Σ_{t=1..T} μ_{a(t)} where μ* = max_i μ_i, a(t) = arm pulled at step t
Good bandit policies guarantee regret that grows only as O(log T) — meaning the per-impression cost of learning shrinks toward zero. Three policies, in increasing sophistication:
ε-greedy — the blunt instrument
With probability ε pull a random arm (explore); otherwise pull the current best (exploit). Trivial to implement, but it wastes exploration uniformly — it keeps re-testing arms it has already proven bad. Regret is O(εT) with fixed ε (linear — it never stops paying), so you must decay ε over time to do better. The right intuition: ε-greedy explores blindly.
UCB — optimism in the face of uncertainty
Upper Confidence Bound is smarter: explore arms you are uncertain about, not random ones. Score each arm by its empirical mean plus a bonus that grows with uncertainty (few pulls → fat bonus):
UCB_i(t) = x̄_i + √( 2 ln t / n_i ) x̄_i = mean reward of arm i, n_i = times pulled
A new item has tiny n_i, so the bonus √(2 ln t / n_i) is huge → it gets tried. As pulls accumulate, n_i grows, the bonus shrinks, and the score converges to the true mean. UCB directs exploration toward genuine unknowns and achieves O(log T) regret. Its contextual cousin LinUCB adds features (user profile, item tags) so the confidence bound is per-context — essential when "best item" depends on who is watching.
Thompson sampling — let the posterior decide
The Bayesian answer, and the production favorite for CTR. Model each item's CTR as a Beta distribution updated by clicks and misses: Beta(α + clicks, β + misses). To pick an arm, sample one CTR from each item's posterior and play the highest sample:
θ̃_i ~ Beta(α_i, β_i) → play arg max_i θ̃_i → observe click? α_i += 1 else β_i += 1
The elegance: exploration falls out for free. A cold item has a wide posterior, so its samples are sometimes very high → it gets played. As evidence accumulates the posterior narrows and the item is played in proportion to the probability it really is best. No ε to tune, no bonus to calibrate — uncertainty drives exploration automatically.
Interactive · multi-armed bandit simulator
Five items, each with a hidden true CTR (one is a hidden gem the model would not guess from priors). Pick a policy and run impressions. Watch cumulative regret accumulate and the estimated CTRs converge — see how ε-greedy wastes pulls, UCB directs them, and Thompson balances by sampling its own uncertainty.
Advanced bridges — meta-learning and cross-domain transfer
Content and bandits handle the common case. Two heavier tools attack the structural problem directly: how do you adapt to a new entity with few samples, by design?
Meta-learning — learn to adapt fast
The framing of MAML and its kin: instead of training one model to fit all users, train an initialization that any new user can fine-tune into a good personal model in just a few gradient steps. Each user is a "task"; meta-training optimizes for fast adaptation across tasks rather than average performance:
inner: φ_u = θ − α ∇_θ L_u(θ) (adapt on one user's few samples)
outer: θ ← θ − β ∇_θ Σ_u L_u(φ_u) (optimize the start point itself)
The result is a parameter vector that sits in a "ready-to-adapt" region of weight space — so a brand-new user's three clicks move it to a strong personalized model immediately. This treats cold start as a few-shot learning problem, which is exactly what it is.
Cross-domain transfer — borrow a warm domain
If you run an e-commerce app and launch video, the user who is cold on video may be warm on shopping. Transfer maps the rich source-domain profile into the target domain. The mechanics, in four moves:
- Aligned IDs / profiles. A shared user-ID space lets you carry demographics, purchase categories, and activity patterns across.
- Embedding mapping. A two-tower model learns a joint representation so that "bought camping gear" and "watches outdoor clips" land near each other — bridged through a shared interest space, not a literal feature match.
- Adversarial domain alignment (DANN-style). Add a domain discriminator and train the encoder to fool it, so features become domain-invariant — closing the distribution gap between sparse-discrete shopping signals and dense-continuous video signals.
- Decaying source weight. Start heavily reliant on the source prior; as the user generates native target-domain behavior, anneal the source weight to zero. The transfer is training wheels, removed once the user can balance on their own.
Putting it together — the cold-start relay
No single mechanism wins; cold start is a relay handing off as data arrives. The phases, ordered by how much you know:
| Phase | Data available | Dominant mechanism | Goal |
|---|---|---|---|
| Absolute cold | None (first request / upload) | Content embedding + popularity + device prior + transfer | A non-random first shot |
| Early warming | A handful of signals | Bandit exploration (Thompson / LinUCB), meta-adapted init | Measure true quality / capture interest fast |
| Warm | Enough interactions | Hand off to the standard CF / deep ranking model | Full personalization; decay the exploration boost |
Interview prompts you should be ready for
- "What is the cold-start problem, and why can't collaborative filtering just handle it?" (The chicken-and-egg loop: CF learns an embedding from co-occurrences, a new entity has none, so it is never recommended and never earns any. Name the loop explicitly — that is the signal.)
- "There are three kinds of cold start — which is which, and do they have the same fix?" (User = empty row, item = empty column, system = empty matrix. Item cold start leans on content; user on priors + fast exploration; system on transfer / editorial seeding. Diagnosing which side is empty is the first move.)
- "How does content side-information give a cold item a usable embedding?" (Train a projection f_θ on warm items to map content embeddings to collaborative ones — warm items are free (content → behavior) supervision — then apply it to cold items at inference. Senior nuance: bake content features into the item tower so head and tail share one code path.)
- "Compare ε-greedy, UCB, and Thompson sampling for new-item exploration." (ε-greedy explores blindly with O(εT) linear regret unless ε decays; UCB explores by uncertainty via the √(2 ln t / n_i) bonus, O(log T); Thompson samples from each arm's Beta posterior so exploration is automatic and there is nothing to tune. Thompson is the production CTR favorite.)
- "Why does content alone never fully solve item cold start?" (Content says what an item is, not whether people will like it — near-identical content embeddings can have very different CTRs. Content gets a fair first shot; only real impressions, bought via exploration, reveal true quality.)
- "You ship a popularity prior for new users and retention drops over weeks. What happened?" (The Matthew effect / popularity trap: popular items get shown more and look even more popular, narrowing new-user profiles and starving the tail. Cold start and popularity bias are the same coin — exploration is the counterweight.)
- "When would you reach for meta-learning or cross-domain transfer over a bandit?" (Meta-learning when you want few-shot adaptation by design — a ready-to-adapt init that personalizes in a few gradient steps. Transfer when a warm sister domain exists and correlates with the target; gate it against negative transfer with a domain-relevance check and decay the source weight as native signal arrives.)