Hyper-Personalized Merchandising Through Hybrid LLM and Deep Learning Systems

doordash · E-commerce · 2026 · source Agentic: yes · promotional bias: low · source-backed · extracted with prompt 0.5.6 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: hyper-personalized local commerce merchandising and recommendation

DoorDash needed to personalize discovery across a large local-commerce catalog for millions of users whose needs shift by moment, event, location, and session intent, while keeping serving latency and cost low enough for consumer-facing feeds.

Constraints:

Architecture

DoorDash built a hybrid personalization architecture that uses LLMs where language, world knowledge, and generalization matter, and keeps traditional deep-learning rankers for low-latency last-mile optimization. Product understanding uses LLMs, fine-tuning, RAG over DoorDash ontology/taxonomy/catalog, and agentic external information gathering to extract product attributes. Consumer understanding is represented as natural-language profile narratives organized into memory blocks such as dietary habits, household information, category preferences, item/brand preferences, and taxonomy preferences, with structured facets extracted for efficient targeting. LLMs generate weekly content blueprints for evergreen and event-driven merchandising; online serving blends those offline artifacts with real-time session embeddings, performs many embedding/lexical/semantic retrievals, and then uses two-tower/MTML models for final ranking. Evaluation combines quantitative metrics, LLM-as-judge, human textual feedback, dogfooding, and GEPA optimization inside DSPy to tune prompts, templates, retrieval logic, profile scope, and ranking objectives.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  Merchant_catalog_inputs["Merchant catalog inputs"] --> Product_understanding_layer["Product understanding layer"]
  Ontology_taxonomy_catalog_RAG["Ontology taxonomy catalog RAG"] --> Product_understanding_layer
  Agentic_enrichment_process["Agentic enrichment process"] --> Product_understanding_layer
  Product_understanding_layer --> Product_graph["Product graph"]
  Consumer_behavior_history["Consumer behavior history"] --> Consumer_profile_generator["Consumer profile generator"]
  Consumer_profile_generator --> Profile_memory_blocks["Profile memory blocks"]
  Product_graph --> Content_blueprint_generator["Content blueprint generator"]
  Profile_memory_blocks --> Content_blueprint_generator
  Content_blueprint_generator --> Feed_service["Feed service"]
  Personalized_homepage["Personalized homepage"] --> Consumer_behavior_history
  Feed_service --> DoorDash_Brain["DoorDash Brain"]
  Profile_memory_blocks --> DoorDash_Brain
  DoorDash_Brain --> Retrieval_layer["Retrieval layer"]
  Content_blueprint_generator --> Item_embedding_index["Item embedding index"]
  Item_embedding_index --> Retrieval_layer
  Retrieval_layer --> Final_ranking_models["Final ranking models"]
  Final_ranking_models --> Personalized_homepage
  Personalized_homepage --> Evaluation_framework["Evaluation framework"]
  Evaluation_framework --> GEPA_optimizer["GEPA optimizer"]
  GEPA_optimizer --> Content_blueprint_generator
  GEPA_optimizer --> Consumer_profile_generator
  GEPA_optimizer --> Final_ranking_models
  Profile_memory_blocks --> Agent_context_grounding["Agent context grounding"]
Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component Role Interacts with
Merchant catalog inputs Product feeds, merchant spreadsheets, catalog metadata, inventory, deals, and external merchant/web information. Product understanding layer
Product understanding layer LLM/fine-tuned/RAG/agentic extraction system that identifies product attributes such as brand, form factor, allergens, flavor, and variants. Ontology taxonomy catalog RAG, Agentic enrichment process, Product graph
Ontology taxonomy catalog RAG DoorDash grounding layer that supplies ontology, taxonomy, and carried-product context to product-understanding LLMs. Product understanding layer
Agentic enrichment process Searches Google, scrapes merchant websites, aggregates context, and lets an LLM reason over sparse merchant data. Product understanding layer
Product graph Shared product knowledge primitive used by personalization, retrieval, and downstream experiences. Content blueprint generator, Item embedding index
Consumer behavior history Purchases, searches, substitutions, browsing, and app interactions used to initialize and update profiles. Consumer profile generator
Consumer profile generator LLM process that converts behavior into natural-language profile narratives and structured facets. Profile memory blocks, DoorDash Brain
Profile memory blocks Natural-language and structured profile units for dietary habits, household information, categories, items, brands, and taxonomy preferences. Content blueprint generator, DoorDash Brain, Agent context grounding
Content blueprint generator LLM process that creates carousel themes, search queries, and merchandising blueprints for consumers and events. Feed service, Item embedding index
Feed service Mobile-feed orchestration layer that passes events and calls microservices for homepage generation. DoorDash Brain, Content blueprint generator, Retrieval layer, Final ranking models
DoorDash Brain Consumer-understanding service that hosts profiles and blends real-time intent using embeddings. Profile memory blocks, Retrieval layer
Retrieval layer Executes multiple embedding, lexical, and semantic retrievals over item indexes and search terms. Item embedding index, Final ranking models
Item embedding index Embedding store searched to populate carousels and adapt to real-time intent. Retrieval layer
Final ranking models Two-tower and MTML deep-learning rankers used for efficient last-mile ranking under latency constraints. Personalized homepage
Personalized homepage Consumer-facing page with personalized carousels, copy, deals, merchants, and exploration items. Consumer behavior history, Evaluation framework
Evaluation framework Quantitative metrics, LLM-as-judge, human annotator feedback, and dogfooding used to evaluate generated experiences. GEPA optimizer
GEPA optimizer DSPy Genetic-Pareto optimizer that mutates prompts, templates, search-term logic, profile scope, and ranking objectives. Content blueprint generator, Consumer profile generator, Final ranking models
Agent context grounding RAG path that places consumer profiles into consumer-facing and catalog/shopping agent contexts. Profile memory blocks

Data flow

Merchant/product data flows into an LLM-powered product-understanding layer that extracts attributes, sometimes using external search and merchant-site scraping for sparse small-merchant spreadsheets. User behavior over roughly the past year initializes natural-language profile memory blocks, which are updated on different cadences through delta updates and recency weighting. LLMs create content blueprints and search terms offline for each consumer/use case. At request time, the feed service sends events to DoorDash Brain, retrieves pre-generated carousels, blends in real-time intent through embeddings rather than synchronous LLM calls, executes 20-30 retrievals over item embeddings plus lexical/semantic search, and applies deep-learning rankers before rendering the feed. Evaluation feedback flows back through GEPA to mutate prompts, search-term generation, profile generation, and ranking objectives.

3 supporting quotes
“At a very high level, the architecture of this looks like the following. We have this layer, which is just product understanding layer.”article, stated
“In the real-time thing, it is not really possible to call an LLM and basically have narratives itself.”article, stated
“It becomes 20 to 30 different embedding retrievals that you would essentially have to do, go search for your item-level embeddings”article, stated

Why this architecture

DoorDash keeps LLMs and deep learning in distinct roles because each solves a different part of personalization. LLMs understand messy behavior, world knowledge, product semantics, natural-language narratives, content ideation, and agentic enrichment. Deep-learning models remain better for concrete ranking objectives, CTR/CVR optimization, and low-latency serving. The architecture therefore does expensive LLM work offline or asynchronously, approximates real-time intent through embeddings, and uses traditional rankers for final serving.

3 supporting quotes
“You can actually blend the classic personalization with LLMs to enhance that experience.”article, stated
“Then the last piece of this puzzle is blending what we can do offline and what you can do real-time, because if you want to do everything real-time with LLMs, it can get very costly very quickly.”article, stated
“Don't throw these things away. I think both of them need to work in unison for things to really work well.”article, stated

Models used: LLMs · fine-tuned product-understanding models · two-tower embedding models · multi-task deep learning rankers · LLM-as-judge models · GEPA optimizer within DSPy

Scale

Alternatives considered (roads not taken)

Classic collaborative filtering and deep learning only

Rejected because: Classic systems learn from engagement and metadata but do not react quickly enough to moment-specific needs or use world knowledge for new catalog items.

“classic personalization here, they were basically doing a couple of things right. One is this learning from within the system.”article, stated
“Understanding that in the moment context, and making personalization be dynamic in that context, is something that classic personalization cannot do very well.”article, stated

Static merchandising and editorial carousels

Rejected because: Static merchandising targets an average consumer and cannot create unique dynamic paths for each person.

“the store manager is basically putting out deals and promos within the store. They're reorganizing the locations of the things in the store to sell better”article, stated
“in the digital world like in DoorDash, we have the ability to actually give you your personalized path within the app”article, stated

LLMs for everything in real time

Rejected because: The speakers say that end-to-end real-time LLM use becomes costly and introduces latency concerns.

“if you want to do everything real-time with LLMs, it can get very costly very quickly. There's also latency concerns.”article, stated

Vanilla LLM extraction for product understanding

Rejected because: Vanilla LLMs delivered only part of the desired accuracy, and safety-critical attributes such as allergens required higher precision.

“We started with vanilla LLMs. They get you somewhere. It's the 80 of the 80/20.”article, stated
“we cannot actually sell something for which the allergen was wrongly extracted because someone might actually die”article, stated

Per-user prompt modification for feedback optimization

Rejected because: The Q&A says per-user prompt modification would be too expensive; context selection does the personalization instead.

“That becomes too expensive, so we still do a single prompt for a use case, but not for per user.”article, stated
“what you pull into the context as part of the answer generation process, you can have some leeway there.”article, stated

Patterns

agent-memory (context)

Consumer profiles are stored as natural-language memory blocks and reused across homepage, search, notifications, ranking, and agents.

“These consumer profiles that we talk about, we group them into different memory blocks about dietary habits, household information, category preferences, item brand preferences, taxonomy preferences”article, stated
“It becomes a shared primitive that we use across all of our different problems”article, stated

rag-retrieval (retrieval)

RAG grounds product understanding in DoorDash ontology/taxonomy/catalog and later pulls profiles into agent contexts.

“Then we also ground these systems with RAG. Basically, we let the system know about our ontology, taxonomy, and the products we carry”article, stated
“the grounding of the agent with RAG, with this profile thing that we talked about.”article, stated

tool-use-orchestration (agent-architecture)

Agentic product enrichment searches Google, scrapes merchant websites, aggregates context, and lets an LLM reason over the combined information.

“This is where agentic processes come in. Basically, with that text, if you go and search on Google, normally, it finds a lot of information that's very relevant”article, stated
“we can go to the merchant's website and scrape the data, things like that, we can bring in a bunch of information over which an LLM can reason”article, stated

fine-tuning-adaptation (model-adaptation)

Product-understanding models needed fine-tuning to reach production-grade precision beyond vanilla LLM extraction.

“We set pretty high bars on the accuracy of these systems, which meant that we had to go and do fine-tuning.”article, stated

retrieval-ranking (ranking)

Generated search terms and profile facets feed embedding, lexical, and semantic retrieval before two-tower/MTML rankers perform last-mile ranking.

“Still, basically, you need to use them to make sure that they encode a lot more information about specific item preferences”article, stated
“go search for your item-level embeddings that you've stored in a different index and do this embedding-based retrieval, do some lexical search”article, stated

cost-aware-routing (operations)

The system keeps expensive LLM narrative generation offline/asynchronous and uses embeddings for low-latency real-time intent blending.

“In the real-time thing, it is not really possible to call an LLM and basically have narratives itself.”article, stated
“You try to, essentially, approximate the user's intent since they've come onto the app, largely through embeddings.”article, stated

llm-as-judge (evaluation)

DoorDash uses LLM-as-judge alongside quantitative metrics and human feedback to evaluate generated personalization content.

“Then you use LLM-as-a-judge as well. This is the part where it feels like it's LLMs all the way down.”article, stated

human-in-the-loop-gate (oversight)

Product extraction and evaluation retain human input through human-in-the-loop product workflows, annotators, and employee dogfooding.

“We have been able to solve it from a purely human-driven process because those items are so hard, to something that's very much AI-driven with human in the loop.”article, stated
“We work with a lot of human annotators as well as our own employees with dogfooding to collect this kind of textual feedback.”article, stated

eval-driven-development (quality)

Quantitative metrics, LLM judges, human textual feedback, dogfooding, and GEPA reward functions drive system optimization.

“We evaluate these things across three different axes today. This becomes your reward function for GEPA.”article, stated
“GEPA essentially helps you do that. For it to be able to do well, you need to essentially say, what's the reward function?”article, stated

Tradeoffs

LLMs for understanding, deep learning for last-mile ranking

Chose hybrid LLM/deep-learning division of labor over replacing traditional recommenders with LLM ranking.

Rationale: LLMs are better at narratives, world knowledge, and content ideation, while deep learning remains better for concrete ranking metrics under latency constraints.

“The deep learning models do really well when you have to optimize for some very concrete metrics about whether it's CTR or CVR under constraints.”article, stated
“Don't let your LLMs do the last mile ranking, and don't, in fact, do ranking, do the content ideation piece”article, stated

Offline LLM generation with online embedding blending

Chose pre-generated carousels plus real-time embedding signals over fully real-time LLM personalization.

Rationale: The architecture needs to react to session intent without paying LLM latency/cost on every homepage request.

“blending what we can do offline and what you can do real-time”article, stated
“In the real-time thing, it is not really possible to call an LLM and basically have narratives itself.”article, stated

Natural-language profiles plus structured facets

Chose plain-English narratives with extracted facets over only feature vectors or embeddings.

Rationale: Natural language is expressive and explainable, while structured facets keep retrieval and targeting efficient.

“let's just represent consumer profiles in just plain old English, and it has enough expressiveness.”article, stated
“From these narratives, the system also extracts structured facets (like "electronics taste: premium" or "preferred form factor: over-ear")”summary, stated

Search as the carousel population primitive

Chose LLM-generated search terms feeding retrieval over bespoke generated item lists for every carousel.

Rationale: Search terms are expressive enough for personalized content while remaining tractable and compatible with retrieval/ranking systems.

“For each of those carousels, you need to make 10 to 20 different queries.”article, stated
“Are these search terms all basically exactly getting the same set of items? You want to make sure that you have more diversity again.”article, stated

Shared primitives over bespoke use-case systems

Chose profiles, product graph, and evaluation frameworks reused across applications over tightly coupling each primitive to one feature.

Rationale: Shared primitives are more cost-effective and let multiple products reuse proven context and evaluation foundations.

“invest in shared primitives, profiles, product graph, evaluation frameworks. It's good to make sure that these are actually generic things”article, stated
“You're not tightly coupling them with the specific use case that you want to build it for.”article, stated

Start with targeted experiments before generic frameworks

Chose real experiments with ROI before broad infrastructure over large up-front infra projects.

Rationale: DoorDash recommends learning from concrete experiments and extracting frameworks later to avoid over-engineering.

“people tend to start building these as large infra projects within the company. I think that that doesn't really work.”article, stated
“make sure that you have real experiments where you can drive return on these investments soon enough.”article, stated

Gotchas (what bit them)

Classic personalization misses short-lived moment intent.

Root cause: Collaborative filtering and deep learning rankers mostly learn from long-term engagement and product metadata.

Resolution: Layer LLM-driven profiles, moment-aware content generation, and real-time embedding signals on top of classic ranking systems.

“most of these systems only learn from long-term interests. Long-term interests are good. It tells you a lot about you, but it cannot react fast enough”article, stated
“layering that intelligence on top of the classic personalization systems that we have”article, stated

Safety-critical product attributes cannot rely on vanilla LLM extraction.

Root cause: Wrong allergen extraction could cause serious harm, so approximate LLM performance was insufficient.

Resolution: Use fine-tuning and RAG grounded in DoorDash's ontology, taxonomy, and product catalog.

“Because we cannot actually sell something for which the allergen was wrongly extracted because someone might actually die”article, stated
“we had to go and do fine-tuning. We did a lot of our fine-tuning in-house.”article, stated

Sparse small-merchant data is hard for humans and models to interpret.

Root cause: Mom-and-pop stores send abbreviated spreadsheets that lack enough direct product context.

Resolution: Use agentic external search and merchant-site scraping, then let an LLM reason over aggregated evidence.

“a lot of mom-and-pop stores, they send us a spreadsheet that has very abbreviated things that a human even won't be able to decipher.”article, stated
“from all the information we gather from Google, and also, we can go to the merchant's website and scrape the data”article, stated

Personalized evaluation does not scale to manual review.

Root cause: Each consumer can see dozens of brand-new carousels with different copy and items, making exhaustive human evaluation impossible.

Resolution: Combine quantitative metrics, LLM-as-judge, human textual feedback, dogfooding, and GEPA optimization.

“Right now, for every single consumer, there's 50 different carousels which are brand new and which are going to say different things.”article, stated
“You need some way to do this systematically and be able to optimize the system as well, not just evaluation for the sake of evaluation.”article, stated

Recommendation systems can trap users in their existing preference loop.

Root cause: The pigeonhole effect reinforces prior recommendations and purchases.

Resolution: Introduce exploration, potentially guided by LLM world knowledge to suggest adjacent categories.

“This is not going to go away in the LLM world either. The way to break that has always been to introduce exploration.”article, stated
“You can tell the LLM to make sure to expand to adjacent categories that this consumer might be interested in.”article, stated

Profile updates can become too expensive if they regenerate full history.

Root cause: Sending a full year of behavior for every update is costly and ignores the different cadence of profile facets.

Resolution: Use memory-block-specific cadences, delta updates, right-sized models, and recency weighting.

“You don't need to essentially send all the data for all the different memory blocks either, because otherwise it gets too expensive as well.”article, stated
“You do really delta updates. You don't really need to send all of the one year's history again”article, stated

Evaluation

DoorDash evaluates hyper-personalized merchandising with three axes: quantitative metrics such as online behavior and click likelihood, LLM-as-judge rubric evaluation, and open-ended human textual feedback from annotators and dogfooding. These signals become a reward function for GEPA inside DSPy, which optimizes prompts/templates, search-term generation, profile generation scope, and ranking objectives.

Metrics: CTR · CVR · quantitative online metrics · LLM-as-judge rubric ratings · human textual feedback · GEPA reward function · exploration versus exploitation objective

3 supporting quotes
“We evaluate these things across three different axes today. This becomes your reward function for GEPA.”article, stated
“We look at quantitative metrics. We look at, essentially, these are your typical rubrics.”article, stated
“if you're able to collect human annotated feedback, especially just textual feedback, it does much better in terms of optimizing your prompts itself.”article, stated

Outcomes

The article/transcript is a detailed practitioner talk but does not provide aggregate production lift metrics for the personalization system. The strongest measurable result is the 28-day to 2-day extraction improvement; the rest of the value is architecture and operational lessons.

3 supporting quotes
“There's a certain task that used to take 28 days, we do that exact same thing in 2 days today.”article, stated
“These become like a core pillar that you essentially use across the entire company there.”article, stated
“our catalog building process is extremely agentic because there used to be a lot of manual stuff that needs to happen.”article, stated