Cold Start Problem

The cold start problem in recommender systems is the structural inability of a recommendation algorithm to make accurate predictions for users or items about which it has no prior interaction history. There are three distinct flavours — new user (the user just signed up and has no rated or clicked anything), new item (the item was just added to the catalog and no one has interacted with it), and new community (the entire system is brand new and there is no historical interaction data at all). Cold start is not a bug to be patched out; it is a fundamental consequence of the inputs available to a collaborative-filtering algorithm. Every production recommender must have an explicit cold-start strategy because cold conditions occur every day in real systems, not just at launch.

1. Why Cold Start Exists — The Structural Argument

To see why cold start is structural rather than incidental, walk through the inputs that pure Collaborative Filtering consumes. A collaborative-filtering algorithm operates exclusively on the user-item interaction matrix R ∈ ℝ^{m × n}, where:

• m is the number of users known to the system.
• n is the number of items in the catalog.
• R[u, i] is the recorded interaction (rating, click, watch-time) between user u and item i. Most cells of R are unobserved (the user has not touched the item).

A new user u_{new} corresponds to a new row in R, all of whose entries are unobserved. There is, by construction, no signal from which to compute similarities to existing users (because every cell in the user’s row is empty), and no signal from which to learn a latent factor vector for the user (in matrix factorization, the user’s row is the data the algorithm uses to fit the user’s embedding — with zero data points, no fit is possible). Likewise, a new item i_{new} corresponds to a new column with all entries unobserved. The algorithm has no information from which to place the new item in the latent space.

This is not a fixable property of any specific collaborative-filtering algorithm. It is a property of the data — the matrix has no relevant entries. Any algorithm that consumes only R will be unable to make a meaningful prediction for the new row or new column. The only way around this is to use additional information — features of the user, features of the item, prior assumptions, exploration policies — that go beyond R itself.

Pure Content-Based Filtering partially solves the new-item problem because it does not rely on R for items. A new item enters the system with its features (text, category, image, audio) and can be placed in the content space immediately. However, content-based methods do not solve the new-user problem, because the user’s profile in the content space is itself derived from the items they have liked — and a new user has liked nothing.

The Wikipedia article on cold start (Cold start (recommender systems), Wikipedia) and the comparative review by Bobadilla, Ortega, Hernando, Bernal 2014 both establish this structural framing as the field’s standard understanding.

2. The Three Flavours of Cold Start

The cold-start problem is not monolithic. Three distinct cases arise, with different solutions.

2.1 New user (user cold start)

A user has just signed up. There is no row for them in R, or the row exists but contains zero or very few observations. Symptoms: the recommender has no basis for personalization; the system either falls back to non-personalized recommendations or attempts to elicit information.

This is the most common cold-start condition in any growing system, because users sign up continuously. Every successful platform faces a constant stream of cold users. A robust cold-user strategy is not a one-time fix but a permanent feature of the recommendation pipeline.

2.2 New item (item cold start)

An item has just entered the catalog. There is no column for it in R, or the column has zero or very few observations. Symptoms: the recommender cannot use collaborative signals to place the item; the item is invisible to the user-user or item-item neighborhood algorithms; matrix factorization cannot fit a latent vector for it.

This is also a permanent condition of any platform with content turnover. YouTube uploads ~500 hours of video per minute; every one of those uploads is initially a cold item. News sites publish hundreds of articles per day; every article is cold for the first hour of its life. E-commerce platforms add thousands of SKUs per week. The item-cold condition is not a corner case — it is the modal state of a high-turnover catalog.

2.3 New community (system cold start)

The entire system is brand new. No users, no items, no interactions. This is the launch-day problem. Symptoms: literally nothing in the matrix.

System cold start is the rarest of the three because it occurs once per system launch (or once per geographic expansion into a new market). Solutions usually involve seeding from an adjacent system (e.g., importing user behaviour from a sibling product) or relying entirely on content-based and editorial techniques until interaction volume builds.

flowchart TD
  CS[Cold Start] --> NU[New User]
  CS --> NI[New Item]
  CS --> SC[New Community / System]
  NU --> POP[Popularity baseline]
  NU --> Q[Onboarding questionnaire]
  NU --> DEMO[Demographic / context defaults]
  NU --> CTX[First-action content-based]
  NI --> CB[Content-based matching]
  NI --> SI[Side-information MF / two-tower]
  NI --> EXP[Exploration / bandits]
  NI --> ED[Editorial surface]
  SC --> SEED[Seed from adjacent product]
  SC --> CB
  CB --> HY[Hybrid pipeline]
  Q --> HY

What this diagram shows. The top node is the cold-start problem itself. It branches into the three flavours (new user, new item, new community), and each flavour branches into the standard mitigation strategies. Several strategies feed into “Hybrid pipeline” at the bottom, indicating that a production-grade solution composes multiple strategies into a unified recommendation flow rather than applying any single strategy in isolation. The key observation: the strategy depends on which flavour you are facing, and they are not interchangeable — a questionnaire fixes new-user cold start but does nothing for new-item cold start.

3. Strategies for the New-User Case

Four strategies, ordered from cheapest to most aggressive in terms of user friction.

3.1 Popularity baseline

Recommend the most popular items globally, optionally segmented by region, language, or device. Concretely: rank items by some popularity score (interaction count, weighted by recency, optionally with Bayesian shrinkage to avoid items with three glowing reviews from beating items with thousands of moderate ones), and show the top N to every cold user.

This is the floor every fancier strategy must beat. It requires no user input and no model training. The drawback is zero personalization — every cold user sees the same list. However, popularity is informative: most new users do, in fact, have a non-trivial probability of liking the most popular items, simply because popular items are popular for a reason.

The standard Bayesian shrinkage formula (used in IMDB’s Top 250 and many ranking systems) is:

score(i) = (n_i · r_i + m · C) / (n_i + m)

where:

• n_i is the number of interactions item i has received.
• r_i is the average rating (or other quality signal) of item i.
• C is the global average rating across all items — a prior mean.
• m is a “minimum interactions” threshold (often the 75th percentile of n_i across items) controlling how aggressively the score is pulled toward the prior C.

The interpretation: items with few interactions get pulled toward the global mean C; items with many interactions are dominated by their own observed mean r_i. This prevents an item with one glowing review from outranking a well-established item with thousands of moderate reviews. Without this shrinkage, popularity rankings are dominated by tiny-sample-size noise.

3.2 Onboarding questionnaire

Ask the user to express preferences explicitly, in one screen, at signup. Examples:

• Spotify: “Pick three artists you like.”
• Netflix: “Rate five titles to get started.”
• TikTok: “Choose interests from this list.”

This collects a small but meaningful preference signal in a single user interaction, enough to bootstrap a usable profile. The cost is friction at the worst possible moment (signup, when conversion is most fragile). The trade-off is application-specific; platforms with high willingness-to-engage (entertainment, hobbies) tolerate it; platforms with low willingness-to-engage (utility apps, e-commerce) usually do not use it.

A smart variant is to elicit only one or two items at first, then continue eliciting through the natural product flow rather than in a single onboarding screen.

3.3 Demographic and context defaults

Use whatever the system knows at signup — geographic location (from IP), device type (from user-agent), language preference, time of day, referral source — to look up popularity rankings for the cohort the user falls into. A new user from Japan on iOS at 9pm gets a different default ranking than a new user from Brazil on Android at 8am. The cohorts are typically learned offline; at request time, the system just selects the right cohort.

This is weaker than personalization but stronger than a single global popularity ranking. It costs the system nothing in user friction (the user does not know it is happening). The downside is that demographic targeting can amplify biases if the cohorts are constructed crudely.

3.4 Content-based on first action

The moment the user clicks on or interacts with their first item, the system has a content-feature vector to anchor a profile in the content space. From the second recommendation onward, the system can show items similar to the first interaction. This is the cleanest cold-to-warm transition because it requires zero pre-elicitation but begins personalizing immediately.

The technique requires that item content features exist (text, image, category embeddings) and that the system has plumbing to compute similarities at request time. Both are standard infrastructure in any modern stack.

4. Strategies for the New-Item Case

Three principal strategies plus an editorial fallback.

4.1 Content-based recommendation

This is the canonical answer. Use the item’s features (text, image, category, embeddings) to find users whose taste history aligns with those features. The new item gets a content-space embedding from day one because the embedding is computed from features, not from interactions.

Concretely: each user has a “taste vector” that is the (possibly weighted) mean of the embeddings of items they have previously liked. A new item’s embedding is computed from its features. The match is the cosine similarity (or any other vector similarity) between the user’s taste vector and the new item’s embedding. The user is shown the new item if the similarity is above a threshold or if the new item ranks among the top-K candidates.

See Content-Based Filtering for the detailed treatment, including TF-IDF (Term Frequency–Inverse Document Frequency) representations for text and the use of pretrained embeddings (CLIP for images, sentence-transformers for text) for modern variants.

4.2 Side-information matrix factorization

Standard Matrix Factorization learns a latent vector per item from interaction data, which fails for new items. The fix is to extend the model so the latent vector is predicted from item features rather than learned solely from interactions. Two well-known implementations:

• LightFM (Maciej Kula, 2015) — represents each item as a sum of feature embeddings (one embedding per content feature, like genre, tag, category); a new item’s vector is computed by summing its feature embeddings. The model is trained jointly with collaborative signals on warm items.
• DropoutNet (Volkovs, Yu, Poutanen 2017) — trains a model with feature inputs and randomly masks the item-ID embedding during training to force the model to rely on features. At inference, a cold item with no learned embedding is scored using only its features.

Both approaches give cold items a usable embedding on day one, eliminating the new-item failure mode while preserving the collaborative signal for warm items.

The Two-Tower Retrieval Model is the modern industrial form of this idea: each tower consumes features rather than IDs, so a brand-new item with no prior interactions still gets a meaningful tower output.

4.3 Exploration / multi-armed bandits

Deliberately allocate some impression budget to under-explored items in order to learn about them faster. The classical formal framework is the multi-armed bandit (MAB) problem: each item is a “bandit arm”; pulling the arm (showing the item) yields a stochastic reward (click, dwell-time); the algorithm balances exploration (showing items it has not learned much about) against exploitation (showing items it knows are good).

Standard algorithms:

• ε-greedy: with probability ε, show a random item from the candidate set; with probability 1 − ε, show the item with the highest estimated reward. Simple but uninformed about uncertainty.
• Upper Confidence Bound (UCB): show the item with the highest upper confidence bound on reward, rewarding both high-mean and high-variance items.
• Thompson sampling: maintain a posterior distribution over each item’s reward; sample from each posterior; show the item with the highest sampled value. Mathematically elegant and often the best-performing in practice.

The cost of exploration is short-term engagement loss — showing under-explored items will, on average, produce fewer clicks than always showing the best-known items. Production teams must explicitly budget for this trade-off; some systems allocate a fixed fraction of impressions to exploration, others use the bandit framework only for cold items.

4.4 Editorial / curation surface

A “New Releases” carousel, a “Just Added” section, or an editorial spotlight gives new items guaranteed exposure that does not depend on the model believing they are good yet. This is purely editorial and bypasses the cold-start problem rather than solving it. Most consumer platforms have at least one such surface, and it serves as a fallback when the model has nothing to say.

5. Strategies for the System Cold-Start Case

System cold start (the entire platform is new) has fewer options. The standard playbook:

1. Bootstrap with content-based and popularity. Until interaction data accumulates, content-based recommendations and editorial popularity rankings are the entire system. This is acceptable for the first weeks or months of operation.
2. Seed from an adjacent product or import. If the company already has user behaviour on a sibling product, import it as a prior. Spotify Wrapped data feeds the discovery system; Amazon’s e-commerce browsing seeds the Prime Video recommender.
3. Generous exploration. With nothing to exploit, the system can afford aggressive exploration. Multi-armed bandits with high exploration rates (or even pure random recommendations) are reasonable until the data warm-up completes.
4. Editorial heavy lifting. Human curation can carry the system through the cold phase; many publication-style platforms (newspapers, magazines) operate this way long after the cold phase ends.

6. Why Hybrids Are the Standard Answer

The pure pure paradigms each have a structural failure mode:

• Pure collaborative filtering breaks on cold items and cold users.
• Pure content-based filtering breaks on cold users and produces filter-bubble outputs even for warm users (recommendations only resemble what the user has already seen).
• Pure knowledge-based recommenders require explicit constraints that consumer users do not want to specify.

The pragmatic answer is to combine paradigms in a hybrid architecture that uses content-based methods for cold cases and collaborative-filtering methods for warm cases. The Burke 2002 hybridization taxonomy formalizes seven distinct combination strategies; in practice, the dominant production pattern is the cascade: a fast retrieval stage (often two-tower with feature inputs) generates candidates, then a heavier ranker scores them with rich features. Both stages naturally handle warm and cold items because their inputs are features, not IDs.

7. Modern Deep-Learning Mitigations

Beyond the classical hybrid approach, a few specifically deep-learning-flavoured strategies have emerged.

7.1 Two-tower models with feature inputs

A Two-Tower Retrieval Model whose item tower takes raw item features (text embedding, image embedding, category) as input — not just an item-ID lookup — produces a usable item embedding for any item, including ones it has never seen during training. The user tower is similarly feature-driven (history embeddings, demographic features). This makes the entire retrieval stage cold-start-aware by construction.

7.2 Pretrained foundation-model embeddings

Use embeddings from pretrained foundation models — CLIP (Contrastive Language-Image Pretraining, OpenAI) for images, sentence-transformers (Reimers & Gurevych 2019) for text, CLAP for audio — as the item representation directly. The pretrained model has already learned a rich representation from billions of items, so any new item gets a high-quality embedding from day one without needing to be trained on. This is increasingly the default for cold-start in modern stacks.

7.3 Meta-learning

A meta-learning approach trains the recommender on many small users (each with few interactions) so that the model becomes good at adapting fast to a new user with only a handful of observations. The canonical example is MeLU (Lee, Im, Jang, Cho, Chung, KDD 2019), which adapts Model-Agnostic Meta-Learning (MAML, Finn et al. 2017) so that the recommender’s parameters are tuned to a point in parameter space from which a small number of gradient steps on a new user’s few interactions yields a personalized model. The two-loop structure — outer loop optimizes the initialization across many “tasks” (users); inner loop fine-tunes that initialization on the task’s support set (a user’s first few items) — lets the system make calibrated predictions after only k = 5–20 observations rather than the hundreds usually needed by a from-scratch matrix-factorization fit.

The follow-up literature is substantial: MAMO (Dong et al. KDD 2020) adds a memory-augmented variant; MetaCF, PAML, and TaNP extend the framework along different axes. The cumulative academic record is robust — every credible cold-start benchmark since 2019 includes a MAML/MeLU baseline, and the Awesome-Cold-Start-Recommendation survey lists meta-learning as one of four dominant cold-start paradigms. Despite this, named industrial deployments are scarce in the open literature — most production cold-start papers from large platforms (Pinterest, Alibaba, Meta, Google) emphasize feature-driven two-tower retrieval and side-information matrix factorization, not MAML fine-tuning per user at inference. The MeLU GitHub reference implementation reports ML-1M and Book-Crossing results but does not name a production deployment. Operational concerns plausibly explain the gap: per-user inner-loop fine-tuning is expensive at request-time scale, the meta-training procedure is sensitive to task-sampling distribution, and the marginal lift over a feature-rich two-tower model is often small once the latter has good features. Treat meta-learning as a research-grade option with proven offline strength but operationally heavier than feature-driven alternatives.

7.4 Generative recommenders and Semantic IDs

A 2023–2024 line of work — beginning with Rajput et al.’s TIGER (Transformer Index for Generative Recommenders), NeurIPS 2023 — re-frames item identity itself as a sequence of discrete “semantic” tokens derived from a content embedding via residual vector quantization (RQ-VAE), rather than an opaque integer ID. Items with similar content share token prefixes, so a generative model that learns to predict next-item tokens autoregressively naturally generalizes to unseen item IDs that nevertheless share content with seen items. This is structurally cold-start-friendly: the model never had to memorize the new item’s integer ID; it just needs to emit the new item’s quantized content code as a continuation of the user’s interaction history. DoorDash has publicly described using semantic-ID-style representations for catalog hierarchy as one component of their cold-start machinery, presented at KDD/RecSys 2025.

7.5 LLM-augmented recommenders

Direct use of large language models for cold-start has matured from speculation to deployed pattern. LLMTreeRec (Yang et al., COLING 2025) organizes a large item catalog into a hierarchical tree so an LLM can prune branches at each level rather than ranking the full catalog in one prompt, sidestepping the token-budget problem that previously made LLM-based recommendation impractical at industrial scale; the paper reports A/B-test wins against Huawei’s production baseline under system-cold-start. DoorDash has published a multi-vertical framework in which an LLM maps tags from a user’s restaurant order history to grocery taxonomies offline, then a downstream ranker consumes the resulting cross-vertical affinity features — producing usable recommendations in a vertical where the user has zero interactions. The common pattern across these deployments is offline LLM enrichment that pre-computes feature representations or cross-domain mappings, then online inference uses the cheap features in a conventional ranker; runtime LLM calls per user request remain rare due to latency and cost.

8. Pitfalls and Misconceptions

“Cold start is a launch-day problem.” No — it happens every day in any growing system. Every new signup is a cold user; every new upload is a cold item. The cold-start strategy is a permanent feature of the production pipeline, not a launch-time patch.

“Just default to popularity.” Defaulting to popularity for cold cases ships the rich-get-richer feedback loop directly into the model. Popular items get more impressions, more clicks, more positive training signal, higher ranks, more impressions — a self-reinforcing concentration of attention. Combine popularity with exploration to avoid trapping the system in the popularity sink.

“Solving cold start = collecting more data.” More data on existing users and items does not fix the structural cold-start problem because the cold cases by definition have no data. The fix has to come from outside R — content features, side information, exploration policies, or pretrained embeddings.

Conflating new-user and new-item cold start. A questionnaire fixes new-user cold start but does nothing for new-item cold start (the new item has no users to ask). A content-based recommender fixes new-item cold start but does nothing for new-user cold start (the new user has no taste vector to anchor). The two cases have different solutions.

Ignoring the exposure-bias feedback loop. Even after the cold-start problem is mitigated, the system continues to be biased by what it shows. A new item that gets shown a hundred times will look much better in the next training pass than a similar new item that got shown twice. Production cold-start strategies must be paired with debiasing in evaluation and training.

Optimizing only steady-state metrics. Offline evaluation typically uses a held-out test set with mature users and items. A model that wins on this evaluation may still produce a terrible new-user experience. Evaluating cold-start performance specifically requires strong generalization splits that hold out users entirely (not just interactions) and items entirely; see Recommender Evaluation Metrics.

9. Open Questions

• Optimal exploration budget. Bandit literature gives bounds in idealized settings (Bernoulli arms, stationary rewards) that do not translate cleanly to messy production. There is no universally agreed-upon formula for how much of the impression budget to allocate to exploration.
• LLM cost / latency at request time. Offline LLM enrichment is now industrially proven (§7.5). Whether runtime LLM calls in the cold-start path can be made cheap enough for high-QPS feeds — without offline pre-computation — remains open; current production deployments universally fall back to offline-precomputed features rather than per-request LLM inference.
• Semantic ID stability under catalog growth. Generative recommenders (§7.4) tokenize items via RQ-VAE on a snapshot embedding space. How to update the codebook as the catalog grows by orders of magnitude without invalidating learned sequences is an active research problem.
• Causal evaluation of cold-start strategies. Most evaluations of cold-start methods are correlational (offline metrics on held-out splits). The causal effect of a cold-start strategy on long-term user retention is much harder to measure and is rarely reported.

10. See Also

• Recommender Systems — the umbrella note where cold start appears as one of the universal properties
• Collaborative Filtering — the algorithm family that suffers most from cold start
• Content-Based Filtering — the natural fix for new-item cold start
• Hybrid Recommender Systems — the production answer that combines content and collaborative methods
• Two-Tower Retrieval Model — the modern feature-driven retrieval approach that mitigates cold start by construction
• Matrix Factorization — pure MF breaks on cold items; LightFM-style extensions fix this
• MeLU — meta-learning (MAML) cold-start estimator; the §7.3 example
• Sequence-Aware Recommenders — sequential next-item prediction; the substrate generative recommenders extend
• Tiger — TIGER generative recommender with Semantic IDs; the §7.4 example
• Beyond-Accuracy Objectives — exploration policies and diversity re-ranking interact with cold-start strategies
• Recommender Evaluation Metrics — strong-generalization splits are required to evaluate cold-start performance
• Recommender Systems MOC