ChatGPT answers, unedited

I’d recommend a two-layer personalization system: use a recommendation model for products, and a lightweight decisioning/LLM layer for subject lines.

Recommended architecture

1. Customer profile + event stream

Combine relatively stable attributes with recent behavioral signals:

• Customer attributes: lifecycle stage, preferred categories, price sensitivity, geography, loyalty status.
• Recent activity: views, searches, cart additions, purchases, email clicks, and recency/frequency of those events.
• Product attributes: category, brand, price, inventory, margin, newness.

For recommendations, recent interactions should have substantial influence because they capture changing intent. Amazon Personalize, for example, supports event types, user/item metadata, contextual information, and real-time events. AWS Documentation AWS Documentation

2. Product recommendation model

For a relatively mature catalog, I would use Amazon Personalize User-Personalization-v2 as the initial managed solution rather than building a recommendation model from scratch. It uses interaction history and item/user metadata and can update recommendations from recent activity. AWS Documentation AWS Documentation

A practical scoring concept would be:

recommendation = f(long-term preferences, recent activity, item attributes, context)

Then apply business rules afterward—for example:

• Don't recommend products already purchased.
• Exclude unavailable products.
• Respect category or age restrictions.
• Enforce price/margin constraints.
• Reserve some slots for new products.

Amazon Personalize supports recommendation filtering and business rules, including excluding previously purchased items. AWS Documentation AWS Documentation

3. Subject-line personalization

I wouldn't have an LLM independently decide what to recommend. Instead, have the recommendation system produce the products/intent, then let a constrained generation layer turn that information into several subject-line candidates.

For example:

Customer:
  segment = "repeat buyer"
  recent_category = "running shoes"
  last_activity = "viewed trail shoes 2 hours ago"
  preferred_price = "$100-$150"

Recommendations:
  [trail shoe A, trail shoe B, hydration vest]

Subject candidates:
  "New trail picks based on what you’ve been browsing"
  "Fresh trail gear, picked for you"
  "Your next trail run starts here"

Keep the generator constrained to approved facts—don't let it invent discounts, scarcity, product features, or customer attributes.

The important part: optimize both together

Don't optimize subject-line CTR alone. A subject line can generate clicks while producing poor downstream commerce results.

I'd run an experiment measuring:

Use randomized holdouts so you can distinguish genuine incremental lift from customers who would have purchased anyway.

A good production flow

Customer activity
       ↓
Customer profile / feature store
       ↓
Recommendation model
       ↓
Candidate products
       ↓
Business rules + eligibility
       ↓
Subject-line generation
       ↓
Email platform
       ↓
Clicks / purchases / opens
       ↓
Event stream ────────────────┘

I'd start with rules + managed recommendations + constrained subject-line generation, then graduate to a joint learning/ranking system once you have enough experimentation data. This gives you personalization quickly without making the entire email-generation system dependent on an opaque model.

One useful additional capability is exploration: deliberately expose a small percentage of recommendations to newer or less-observed products so the system doesn't simply reinforce existing behavior. Amazon Personalize explicitly supports configurable exploration for this purpose. AWS Documentation

If you're already on AWS, this architecture is particularly straightforward because Amazon Personalize can provide both real-time recommendations and batch recommendations that can feed email workflows. aws.amazon.com

A good solution is a customer data + AI decisioning personalization stack that combines:

1. A unified customer profile layer
2. A subject-line personalization model
3. A product recommendation engine
4. A campaign orchestration/testing layer

A reference architecture:

Customer Data Sources
 ├─ CRM attributes (segment, loyalty tier, location, preferences)
 ├─ Web/app activity (views, searches, clicks, carts)
 ├─ Purchase history
 ├─ Email engagement (opens, clicks, conversions)
 └─ Product catalog data
          ↓
Customer Data Platform / Feature Store
          ↓
AI Personalization Layer
 ├─ Subject line generator + ranking model
 ├─ Recommendation engine
 └─ Send-time/content optimization
          ↓
Email / Push / SMS / Web personalization
          ↓
Experimentation + feedback loop

1. Build customer profiles from attributes + recent activity

Create a profile with both static attributes and behavioral signals.

Example features:

Recent activity should receive higher weight than older history. For example:

• Viewed running shoes yesterday → strong signal
• Bought hiking gear two years ago → weaker signal

Recommendation systems commonly combine browsing, purchasing, and catalog attributes to rank products for each customer. Experience League Salesforce

2. Personalize subject lines with an AI ranking model

Instead of generating one subject line per user, generate multiple candidates and rank them.

Example:

Customer:

• Loyalty member
• Viewed coffee machines twice this week
• Has purchased premium beans before

Candidate subject lines:

• “Still thinking about your next coffee upgrade?”
• “New espresso machines picked for you”
• “Your premium coffee setup, refreshed”

Model inputs:

• Customer segment
• Recent product/category interest
• Past subject lines opened
• Tone preferences
• Seasonality
• Campaign goal

Model output:

Customer ID: 12345

Subject line:
"Your espresso upgrade is waiting"

Predicted open probability: 38%

Reason:
- Recent espresso machine views
- High engagement with product launches
- Premium customer segment

A practical approach is:

• Use an LLM to generate variants.
• Use a machine-learning ranking model to choose the best variant.
• Continuously retrain from opens, clicks, and conversions.

AI email personalization platforms commonly separate content generation from decisioning/ranking so the system can adapt based on behavior. Braze

3. Use a hybrid recommendation engine

Avoid relying only on “customers like you bought X.” Combine multiple recommendation strategies:

Behavioral recommendations

Based on:

• recently viewed products
• searches
• carts
• purchases

Example:

“Because you viewed trail shoes, you may like these hiking socks.”

Collaborative filtering

Based on similar customers:

“Customers who bought this camera often bought these lenses.”

Content-based recommendations

Based on product attributes:

“You liked lightweight jackets → here are similar lightweight jackets.”

Business rules

Apply constraints:

• remove out-of-stock items
• exclude recently purchased products
• prioritize new launches
• respect inventory and margins

Recommendation systems often combine personalized signals with catalog rules and filtering before delivering recommendations. Attentive

4. Recommended technology options

Managed enterprise approach

• salesforce.com + personalization tools

Good if your CRM and marketing stack already run on Salesforce.

• experienceleague.adobe.com

Good for enterprise omnichannel personalization.

• aws.amazon.com

Good if you want AWS-managed recommendation models. AWS describes combining recommendation models with generated personalized communications as one approach for customer outreach. Amazon Web Services, Inc.

• cloud.google.com

Good for commerce catalogs and recommendation APIs. Google Cloud Documentation

More custom stack

A typical custom build:

• Data warehouse: Snowflake / BigQuery / Databricks
• Feature store: Feast or cloud feature store
• Models:

• gradient boosted trees for subject-line ranking
• two-tower neural networks for product retrieval
• learning-to-rank models for final ordering
• LLM:

• subject-line generation
• campaign copy variations
• Activation:

• Braze, Klaviyo, HubSpot, Salesforce Marketing Cloud, custom email service

5. Implementation roadmap

Phase 1 — 4–8 weeks

• Track customer events
• Build unified profiles
• Add basic “recently viewed” and “recommended for you” blocks
• A/B test personalized vs. generic emails

Phase 2 — 2–3 months

• Add ML recommendations
• Add subject-line generation/ranking
• Add lifecycle triggers:

• abandoned browse
• abandoned cart
• replenishment
• win-back

Phase 3 — ongoing optimization

• Optimize:

• subject line
• product ordering
• offers
• send time
• channel choice

Metrics to monitor

Do not optimize only for opens. Track:

• Open rate
• Click-through rate
• Add-to-cart rate
• Conversion rate
• Revenue per email
• Unsubscribe rate
• Customer lifetime value

A strong first version would be: CDP + recommendation engine + LLM-generated subject line variants + ML ranking + continuous A/B testing. It gives personalization without requiring a fully custom AI platform from day one.

I’d recommend a real-time personalization layer that combines a unified customer profile with two separate models: one for subject-line/message personalization and another for product recommendations.

Recommended architecture

1. Customer profile + event stream

Capture both relatively stable attributes and recent behavioral events:

• Attributes: customer segment, location, lifecycle stage, loyalty tier, preferred categories, historical spend.
• Recent activity: product views, searches, cart additions, purchases, email opens/clicks, and recency/frequency.
• Product data: category, brand, price, margin, availability, seasonality, etc.

The important part is giving recent behavior significant weight. Modern recommendation systems can update recommendations as new interactions arrive rather than relying solely on historical profiles. AWS Documentation Experience League

2. Product recommendation engine

Use a candidate-generation → ranking → business-rules pipeline:

1. Generate candidates from:

• recently viewed products
• products similar to recent activity
• complementary products
• customer's historically preferred categories
• trending/new products
• Rank candidates using customer attributes + behavioral signals.
• Apply constraints such as inventory, price range, exclusions for recently purchased products, and category diversity.

This architecture is used by current commercial recommendation systems; for example, Attentive describes separate candidate-generation, ranking, and filtering stages, while Amazon Personalize supports real-time recommendations influenced by recent interactions. Attentive AWS Documentation

3. Subject-line personalization

I would not have an LLM independently decide what every customer should receive. Instead, create a controlled set of subject-line strategies and let a model select or optimize among them.

For example:

An LLM can then generate the wording within those approved strategies, while a ranking/experimentation model determines which variant to show.

4. Combine them at send time

A useful flow is:

Customer event → update profile → generate product candidates → rank products → select messaging strategy → generate subject line → apply safety/business rules → send → record outcome

The feedback loop should capture opens, clicks, purchases, unsubscribes, and recommendation conversions so both systems improve over time.

What I’d build first

For an organization starting from scratch, I’d use:

• CDP/customer profile: unified first-party customer and event data
• Recommendation service: real-time behavioral + attribute-based ranking
• Rules layer: inventory, eligibility, exclusions, diversity
• LLM: controlled subject-line generation, not unconstrained personalization
• Experimentation layer: A/B or contextual-bandit testing
• Analytics: incremental conversion/revenue, CTR, unsubscribe rate, recommendation coverage

This also keeps the recommendation decision separate from the delivery channel, which is a useful architecture because the same decision can feed email, web, and mobile experiences. Experience League

If you already use a major marketing/CDP platform, you may not need to build the recommendation engine yourself. Salesforce, Adobe, Twilio Segment, and Amazon all currently provide pieces of this architecture. help.salesforce.com Experience League twilio.com AWS Documentation

My default choice would therefore be buy the recommendation/CDP infrastructure and build a thin personalization/orchestration layer on top, unless you have unusual catalog scale or highly specialized ranking requirements.

4. Combine them at send time

A useful flow is:

Customer event → update profile → generate product candidates → rank products → select messaging strategy → generate subject line → apply safety/business rules → send → record outcome

The feedback loop should capture opens, clicks, purchases, unsubscribes, and recommendation conversions so both systems improve over time.

What I’d build first

For an organization starting from scratch, I’d use:

• CDP/customer profile: unified first-party customer and event data
• Recommendation service: real-time behavioral + attribute-based ranking
• Rules layer: inventory, eligibility, exclusions, diversity
• LLM: controlled subject-line generation, not unconstrained personalization
• Experimentation layer: A/B or contextual-bandit testing
• Analytics: incremental conversion/revenue, CTR, unsubscribe rate, recommendation coverage

This also keeps the recommendation decision separate from the delivery channel, which is a useful architecture because the same decision can feed email, web, and mobile experiences.

I’d recommend a hybrid real-time personalization architecture rather than trying to have an LLM generate everything from scratch.

Recommended solution

Use a customer profile + event stream + recommendation model + generative subject-line layer:

CRM / CDP / Ecommerce
        │
        ├── Customer attributes
        │   (segment, loyalty tier, location, preferences)
        │
        └── Recent activity
            (views, searches, carts, purchases)
                    │
                    ▼
            Customer Profile Store
                    │
          ┌─────────┴─────────┐
          ▼                   ▼
 Product recommender      Subject-line engine
          │                   │
          │             LLM + templates
          ▼                   ▼
 Recommended products     Personalized subject
          │                   │
          └─────────┬─────────┘
                    ▼
             Email / CRM platform
                    │
                    ▼
              Click / purchase
                    │
                    └──► event stream

1. Product recommendations

For this component, Amazon Personalize is a strong managed option. It can combine user metadata, item metadata, and interaction data such as clicks and purchases, while its real-time personalization can react to newly recorded activity. AWS Documentation AWS Documentation

I'd feed it events with different strengths, for example:

• Product view → weak signal
• Search → medium signal
• Add to cart → strong signal
• Purchase → very strong signal
• Product return → negative signal

Then incorporate customer attributes such as:

• Customer/loyalty tier
• Preferred categories and brands
• Price sensitivity
• Geographic market
• New vs. returning customer
• Lifetime value
• Seasonality

The recommendation layer should also enforce business rules—for example, exclude products already purchased, out-of-stock products, or products unavailable in the customer's market. Amazon Personalize supports filtering and promotional/business-rule controls. AWS Documentation AWS

2. Personalized subject lines

I would not let the LLM decide the personalization strategy itself.

Instead, pass it a structured personalization context:

{
  "customer_segment": "premium_customer",
  "recent_interest": "running shoes",
  "recent_activity": "viewed 4 running shoes in 48 hours",
  "recommended_products": [
    "Trail Runner X",
    "Road Runner Pro"
  ],
  "promotion": "15% off",
  "brand_preference": "Brand A"
}

Have the LLM generate several subject-line variants from that context, while a deterministic policy controls what information can actually be mentioned.

For example:

• Recent intent: “Still looking for your next pair of running shoes?”
• Product-led: “Meet your next favorite running shoes”
• Offer-led: “Your 15% off running picks are here”

Then A/B test or multi-armed-bandit the variants against opens, clicks, conversion, and revenue, rather than optimizing only for open rate.

3. Make recency a first-class signal

This is particularly important. Someone who bought a winter coat six months ago shouldn't necessarily receive another coat recommendation, whereas someone who viewed five running shoes yesterday probably should.

I'd maintain features such as:

last_viewed_category_1d
last_viewed_category_7d
views_24h
cart_items
last_purchase_category
days_since_purchase
purchase_frequency
discount_affinity
brand_affinity

The recommendation system can consume the interaction stream directly; for example, Amazon Personalize says supported recipes can incorporate new interaction events into recommendations within seconds. AWS Documentation

4. Put a policy layer between personalization and email

This is the piece I'd consider essential:

Raw customer data
      ↓
Personalization / recommendation model
      ↓
Business + privacy policy
      ↓
LLM copy generation
      ↓
Email rendering

The policy layer prevents things like:

• Revealing sensitive attributes
• Mentioning an inferred characteristic the customer never provided
• Recommending unavailable products
• Recommending something immediately after the customer purchased it
• Making misleading claims about discounts
• Over-personalizing every message

What I'd build

For a typical ecommerce business, my preferred stack would be:

This gives you ML-driven product recommendations, recency-aware personalization, and flexible LLM-generated copy without making the LLM responsible for customer targeting.

For an MVP, I'd start with 5–10 high-value customer attributes + the last 30 days of behavioral events + 3 recommendation slots + 3 subject-line variants, then measure incremental revenue per recipient.

Raw customer data
      ↓
Personalization / recommendation model
      ↓
Business + privacy policy
      ↓
LLM copy generation
      ↓
Email rendering

The policy layer prevents things like:

• Revealing sensitive attributes
• Mentioning an inferred characteristic the customer never provided
• Recommending unavailable products
• Recommending something immediately after the customer purchased it
• Making misleading claims about discounts
• Over-personalizing every message

What I'd build

For a typical ecommerce business, my preferred stack would be:

This gives you ML-driven product recommendations, recency-aware personalization, and flexible LLM-generated copy without making the LLM responsible for customer targeting.

For an MVP, I'd start with 5–10 high-value customer attributes + the last 30 days of behavioral events + 3 recommendation slots + 3 subject-line variants, then measure incremental revenue per recipient.

I’d recommend a real-time personalization layer that combines a unified customer profile, recent behavioral signals, a recommendation model, and an LLM constrained by business rules.

Recommended architecture

Customer attributes
(age, location, loyalty tier, preferences, price affinity)
              +
Recent activity
(views, searches, carts, purchases, email clicks)
              ↓
      Unified customer profile
              ↓
     ┌────────┴────────┐
     ↓                 ↓
Recommendation      Personalization
   engine              engine
     ↓                 ↓
 ranked products   subject-line variants
     └────────┬────────┘
              ↓
       Eligibility / rules
              ↓
       Email / CRM platform
              ↓
      A/B testing + feedback

The important design choice is to separate product selection from language generation. Recommendation systems should determine what products are relevant; an LLM can then generate the subject line around those signals. This prevents the LLM from inventing products or making unconstrained recommendations.

1. Build a customer feature profile

Maintain features such as:

• Stable attributes: location, loyalty tier, preferred categories, typical price range.
• Long-term behavior: purchases, favorite brands, historical categories.
• Recent intent: products viewed, searches, cart additions, email clicks.
• Recency/frequency: e.g. viewed running shoes 3 times in the last 48 hours.
• Negative signals: recently purchased, unsubscribed from a category, repeatedly ignored a product.
• Predicted affinity: probability of purchasing a category/product/brand.

Recent activity should generally receive more weight than old activity; modern personalization systems explicitly use real-time interactions and changing affinities for this purpose. Mastercard Mastercard

2. Use a recommendation model for products

I'd use a candidate-generation + ranking architecture:

1. Generate candidates from: - collaborative filtering
2. products similar to recently viewed items
3. complementary products
4. popular/trending products
5. new arrivals
6. Rank them using: - customer attributes
7. recent activity
8. product attributes
9. inventory/price
10. predicted purchase probability
11. Apply business filters: - in stock
12. don't recommend something purchased yesterday
13. respect category exclusions
14. price limits
15. diversity constraints

This is similar to the architecture used by current recommendation platforms: candidate generation, learned ranking, then real-time filtering/business rules. Attentive

3. Personalize the subject line separately

Instead of asking an LLM:

"Write a personalized email."

give it structured facts:

{
  "customer": {
    "loyalty_tier": "Gold",
    "preferred_category": "Running"
  },
  "recent_activity": {
    "viewed": "Trail Running Shoes",
    "days_since_view": 1
  },
  "recommendations": [
    "Trail Shoe A",
    "Running Jacket B",
    "Hydration Vest C"
  ],
  "campaign": "Fall running"
}

Then generate several controlled variants, such as:

• Intent: “Still looking for trail-running gear?”
• Benefit: “Your next trail run starts here”
• Discovery: “New trail gear picked for you”
• Loyalty: “Gold members: your running picks are here”

I'd have a deterministic policy decide which variants are eligible, then use multi-armed bandit/A-B testing to learn which style works for each segment.

4. Make recommendations available at send time

For high-value campaigns, don't calculate recommendations once when the campaign is created. Calculate them as close to send/open time as practical so a customer who browsed a product 20 minutes ago can receive a message reflecting that intent.

Real-time recommendation architectures explicitly combine historical customer data with current behavioral signals, and some email systems calculate recommendations at send time. Experience League Attentive

What I'd actually choose

If you're building this yourself, I'd implement:

• Customer profile/CDP: warehouse + customer identity resolution
• Event pipeline: web/app/email events → streaming/event bus
• Feature store: customer and product features with recency
• Recommendation service: candidate generation + ranking API
• LLM service: constrained subject-line generation
• Decision layer: eligibility, inventory, frequency caps, exclusions
• Email platform: renders the selected subject + recommended products
• Experimentation: A/B tests and bandits
• Analytics: open → click → add-to-cart → purchase → revenue

If you want a managed solution rather than building the ML infrastructure, I'd shortlist Twilio Segment, Adobe Journey Optimizer/Real-Time CDP, Salesforce Personalization, and Klaviyo, depending on your existing stack. These platforms already combine customer data with recommendation/personalization capabilities. Twilio Experience League Developer Klaviyo

My default recommendation: if you're an e-commerce company with an existing warehouse and engineering team, build the decisioning layer yourself but use a managed email/CRM platform for activation. That gives you much more control over the recommendation logic while avoiding the cost and complexity of building the entire customer-engagement stack.

For this use case, I’d recommend a real-time personalization layer built around a unified customer profile + behavioral events + recommendation/decisioning models, rather than relying on static email segments.

A good reference architecture looks like this:

Customer attributes
  ├─ demographics / preferences
  ├─ loyalty tier
  ├─ lifecycle stage
  └─ purchase history
          +
Recent activity
  ├─ products viewed
  ├─ searches
  ├─ cart additions
  ├─ purchases
  └─ email/app engagement
          ↓
   Unified customer profile
          ↓
 ┌──────────────────────────┐
 │ Personalization/Decision │
 │ Engine                   │
 │                          │
 │ • Subject-line ranking   │
 │ • Product recommendations│
 │ • Offer selection        │
 │ • Frequency controls     │
 └──────────────────────────┘
          ↓
 Personalized email

My recommended approach

1. Combine profile and behavioral data

Maintain a customer profile containing relatively stable attributes—such as preferred categories, loyalty status, geography and lifecycle stage—and stream recent behavioral events into it.

For example:

Customer:
  category_affinity: running
  loyalty_tier: gold
  avg_order_value: $120

Recent activity:
  viewed: Nike Pegasus
  viewed: running socks
  added_to_cart: Nike Pegasus
  last_purchase: 18 days ago

This distinction matters: stored attributes tell you who the customer is, while recent activity tells you what they appear to want right now. Braze Braze

2. Use separate models for recommendations and messaging

For product recommendations, use a ranking/recommendation model that considers recent views, purchases, searches and product affinities. A practical strategy is to combine:

• Recent-item recommendations
• Collaborative/behavioral recommendations
• Category or attribute affinity
• Business constraints such as inventory, margin and availability
• Exclusions such as products already purchased

Behavioral recommendation systems commonly use views, purchases, searches and other interactions as ranking signals. Experience League

For subject lines, generate a small set of on-brand variants and use an optimization layer to select the best variant for each customer. The important architectural distinction is that generative AI creates candidates; a decisioning model determines which candidate a customer actually receives. Braze

3. Make recency heavily weighted

I'd give recent activity substantially more weight than old behavior.

For example:

Recommendation score =
  40% recent behavior
+ 25% long-term category affinity
+ 15% purchase history
+ 10% customer attributes
+ 10% business rules

Those aren't universal optimal weights—they're a sensible starting point to validate experimentally.

A customer who normally buys running equipment but searched for hiking boots three times today should probably see hiking-related products in tomorrow's email.

4. Personalize at send time

Don't calculate everything once per campaign and freeze it.

At send time, retrieve the customer's latest eligible products and recent activity, then select:

Subject line:
"Ready for your next run?"

Products:
1. Product most likely to convert
2. Complementary product
3. Trending item within preferred category

This prevents stale recommendations when someone has just purchased, abandoned a cart, or changed interests. Real-time personalization systems increasingly use this approach. Braze

Technology choice

If you want an off-the-shelf solution, I'd shortlist:

• Braze — particularly strong if email/lifecycle marketing is the center of the use case. Its current platform combines customer profiles, behavioral data, AI item recommendations, generative content and decisioning. Braze Braze
• Adobe Journey Optimizer + Real-Time CDP — a strong option if you're already invested in Adobe Experience Platform. Adobe documents a behavioral-recommendation architecture combining Real-Time CDP, Journey Optimizer Decisioning and behavioral ranking models. Experience League

If you have a strong engineering/data-science team, I'd instead build the decisioning/recommendation layer yourself on top of your existing CDP/data warehouse, while using an LLM only for generating subject-line candidates. That gives you more control over ranking, experimentation, explainability and cost.

The key design principle

I would not build this as:

customer segment → generate one personalized email

I'd build it as:

customer profile + recent events → candidate content/products → ranking/decisioning → individualized email → outcome → model feedback

That creates a closed learning loop: opens, clicks, purchases, unsubscribes and subsequent behavior feed back into future recommendations and subject-line selection. Braze

For a typical ecommerce business, Braze would be my fastest path to production; for an organization with an existing Adobe stack, I'd favor Adobe Journey Optimizer/Real-Time CDP; and for a highly differentiated recommendation experience, I'd build the recommendation/decisioning layer in-house.

Subject line:
"Ready for your next run?"

Products:
1. Product most likely to convert
2. Complementary product
3. Trending item within preferred category

This prevents stale recommendations when someone has just purchased, abandoned a cart, or changed interests. Real-time personalization systems increasingly use this approach.

Technology choice

If you want an off-the-shelf solution, I'd shortlist:

I’d recommend a real-time personalization layer built around a unified customer profile + decisioning engine, rather than simple merge fields or static segments.

A practical architecture looks like this:

Customer data → feature/profile layer → recommendation + subject-line models → decisioning → email → outcome feedback

1. Build a unified customer profile

Combine relatively stable attributes with recent behavioral signals:

• Attributes: customer tier, geography, lifecycle stage, preferred categories, price sensitivity, loyalty status.
• Recent activity: products viewed, searches, cart additions, purchases, email clicks, last session, recency/frequency of activity.
• Derived features: category affinity, predicted next purchase, likelihood to convert, churn risk, discount affinity.
• Constraints: consent, inventory, eligibility, frequency caps, and products already purchased.

The important part is that recent activity updates the profile quickly. Static segmentation will otherwise become stale. Braze Braze

2. Use separate models for recommendations and messaging

Product recommendations

Start with a hybrid recommender:

• Recently viewed/cart items
• “Frequently bought together”
• Similar products
• Customer/category affinity
• Popularity within the customer's segment
• Business constraints such as inventory and margin

Then rank candidates for each customer using their most recent activity, with strong recency weighting. For example, someone who viewed running shoes twice today should generally receive different recommendations from someone whose last interaction was a month ago.

Subject lines

Don't have an LLM independently invent a subject line for every customer. Instead, create a controlled library of variants:

• “New arrivals for {{category}}”
• “Still thinking about {{product}}?”
• “Your {{category}} picks are here”
• “A few things you might like”

Use an LLM to generate/test variants within your brand voice, then use an experimentation or decisioning model to select the variant most likely to produce the desired outcome for each customer. AI personalization platforms increasingly separate content generation from decisioning, which is a useful design pattern. Braze

3. Make the decision at send time

For each recipient, calculate something like:

customer
  ├── attributes
  ├── recent events
  ├── predicted affinities
  ├── eligible products
  └── eligible subject-line variants
           ↓
     personalization engine
           ↓
   ┌───────┴────────┐
subject line    products
   ↓                 ↓
         personalized email
                ↓
        opens / clicks / purchases
                ↓
          model feedback

This creates a continuous loop: observe → predict → personalize → measure → update. Real-time decisioning is particularly valuable because the customer's latest behavior can change what they should see. Braze Braze

4. Measure the right thing

Don't optimize only for open rate. I'd use a hierarchy such as:

1. Revenue per recipient
2. Conversion rate
3. Click-through rate
4. Open rate
5. Unsubscribe/spam rate

Run randomized holdouts so you can measure incremental lift, not just correlation.

What I'd implement first

For an MVP, I'd keep it relatively simple:

• Customer profile: CDP/data warehouse
• Event stream: web/app/email activity
• Recommendation service: hybrid rules + collaborative/product-affinity model
• Subject lines: 5–10 approved variants generated from a common campaign brief
• Decisioning: contextual bandit or other online experimentation approach
• Delivery: your existing ESP
• Feedback: clicks, purchases, unsubscribes, and downstream revenue

Then progressively replace rules with learned models as you accumulate outcome data.

A platform such as Braze is worth evaluating if you want much of this capability packaged rather than building the orchestration layer yourself; its current platform explicitly combines customer data, AI decisioning, dynamic content, and personalized recommendations. Braze Braze

Bottom line: use customer attributes for context, recent activity for intent, ML for ranking/decisioning, and generative AI primarily for controlled content variation. That gives you personalization that adapts to what the customer is doing now without turning the system into an unpredictable “LLM writes everything” black box.

A strong approach is a real-time customer personalization layer that combines customer attributes with recent behavioral activity, then generates both subject lines and product recommendations from the same customer profile.

Recommended architecture

• Customer profile: Store relatively stable attributes such as location, lifecycle stage, preferences, past purchases, price sensitivity, and loyalty status.
• Recent-activity stream: Capture events such as product views, searches, cart additions, purchases, email clicks, and category engagement. Give recent events higher weight than older activity.
• Feature layer: Convert raw events into features such as: - categories viewed in the last 7 days
• products viewed repeatedly
• abandoned-cart products
• days since last purchase
• average order value
• preferred brands/categories
• predicted purchase propensity
• Recommendation engine: Start with a hybrid model combining collaborative filtering ("customers like you bought…") with content-based signals ("you recently viewed…"). Add business rules for inventory, margin, eligibility, and exclusions.
• Subject-line personalization: Feed a compact set of customer features and campaign context to an LLM or templating model. Rather than generating arbitrary copy, constrain it to approved product/value propositions and brand guidelines.
• Decisioning layer: Choose the best subject line and recommendation set based on predicted engagement/conversion. Use experimentation to continuously compare variants.

Example

Suppose a customer:

• is a repeat customer,
• usually buys running apparel,
• viewed three trail-running products yesterday,
• has an average order value of $100,
• hasn't purchased in 45 days.

The system might select:

Subject: New trail gear picked for you

and recommend trail shoes, hydration gear, and running apparel—while suppressing products they've already purchased.

Implementation I'd favor

For most businesses, I'd build this as:

CDP/warehouse → event stream → feature store → recommendation model + LLM → email/commerce platform

Keep the recommendation model deterministic and measurable, and use the LLM primarily for language generation. That gives you personalization without letting an LLM make unconstrained product or eligibility decisions.

For measurement, run randomized holdouts and track open rate, click-through rate, conversion rate, revenue per recipient, and incremental revenue, rather than optimizing subject lines solely for opens.

If you tell me your stack (e.g. Shopify + Klaviyo, Salesforce, HubSpot, custom warehouse), I can recommend a concrete architecture and specific tools.

A strong solution is a real-time customer personalization layer that combines a customer profile with recent behavioral events and uses those features to personalize both email subject lines and product recommendations.

Recommended architecture

• Customer profile: Store stable attributes such as location, language, lifecycle stage, preferred categories, historical spend, and loyalty status.
• Recent activity stream: Capture events such as product views, searches, cart additions, purchases, email clicks, and recency/frequency signals.
• Feature layer: Transform those inputs into features like: - days_since_last_purchase
• recent_categories
• top_brand_affinity
• cart_value
• products_viewed_last_7_days
• price_range_affinity
• Recommendation engine: Generate a ranked list using a hybrid approach: - Collaborative filtering for behavioral similarity.
• Content-based matching for product/category affinity.
• Business rules for inventory, margin, exclusions, and recently purchased products.
• Subject-line personalization: Feed the same customer/context features into an LLM or supervised model to select the most relevant messaging angle—e.g., new arrivals, replenishment, price drop, or a category the customer recently browsed.
• Decisioning layer: Rank candidate subject lines and products together so the system optimizes for the desired outcome, such as clicks, purchases, or revenue rather than personalization for its own sake.
• Experimentation: Continuously A/B test personalized vs. generic experiences and use uplift/holdout groups to determine whether personalization actually causes incremental revenue.

Example

Suppose a customer has recently:

Viewed running shoes → compared three models → abandoned a $120 pair → historically buys athletic apparel → lives in a warm climate.

The system could generate a subject line such as:

“Still looking for your next running pair?”

and recommend:

1. The abandoned shoe, if still relevant.
2. A similar model around $100–$130.
3. A complementary running apparel item.
4. A highly rated alternative with a stronger discount.

Importantly, I would avoid simply passing the entire customer record to an LLM. Use a structured feature layer and deterministic recommendation/ranking system, then let the model handle language generation or selection. This gives you better control, reproducibility, privacy, latency, and measurement.

If you're building this for an actual marketing stack, a practical MVP is customer events → feature store → recommendation/ranking service → email platform, with an LLM only for subject-line generation and variant selection.

A good solution is to build a customer intelligence + personalization layer that combines customer attributes, behavioral signals, and product data to generate individualized email subject lines and recommendations.

Recommended architecture

1. Create a unified customer profile

Combine first-party data into a customer profile store:

Customer attributes

• Demographics (age range, region, language)
• Customer lifecycle stage (new, active, dormant, VIP)
• Preferences (categories, brands, price sensitivity)
• Purchase history (order frequency, average order value)

Recent activity signals

• Products viewed
• Searches performed
• Cart additions/abandonment
• Email opens/clicks
• Website/app sessions
• Recent purchases
• Time since last interaction

A profile might look like:

{
  "customer_id": "12345",
  "segment": "high_value_fashion_buyer",
  "favorite_categories": ["sneakers", "jackets"],
  "last_viewed_products": ["running_shoe_42"],
  "cart_items": ["winter_jacket"],
  "days_since_purchase": 18,
  "preferred_channel": "email"
}

2. Use an AI personalization engine

Use a combination of rules + machine learning rather than only static segments.

Subject line personalization

Generate subject lines using:

Inputs

• Customer name (when appropriate)
• Recent activity
• Lifecycle stage
• Preferences
• Promotion context

Examples:

A language model can generate variants, but a ranking model should choose the best-performing option based on predicted engagement.

3. Build product recommendations

Use a recommendation system combining multiple approaches:

Collaborative filtering

"Customers like you also bought..."

Useful for:

• Cross-sells
• Discovering new products

Content-based recommendations

Match products to customer interests:

Signals:

• Category affinity
• Brand preference
• Price range
• Colors/styles
• Previous purchases

Example:

Customer bought running shoes → recommend socks, apparel, GPS watches

Real-time behavioral recommendations

Prioritize recent intent:

Example ranking:

40% recent browsing behavior
25% purchase history
20% customer similarity
10% product popularity
5% business rules

4. Add experimentation and feedback loops

Measure:

• Open rate
• Click-through rate
• Conversion rate
• Revenue per email
• Unsubscribe rate
• Recommendation acceptance

Run:

• A/B tests on subject lines
• Multivariate tests on recommendation placement
• Continuous model retraining

Example:

Control

"New arrivals are here"

Personalized

"Alex, new running gear picked for your next workout"

Compare incremental lift, not just engagement.

5. Suggested technology stack

Data layer

• Customer data platform (CDP) or warehouse: - Snowflake
• Databricks
• Google BigQuery

Customer engagement

• Braze
• Salesforce Marketing Cloud
• Adobe Campaign

Recommendation engines

• Amazon Personalize
• Google Recommendations AI

AI generation layer

• Large language models for: - Subject line creation
• Message variation
• Personalization copy
• ML ranking models for: - Selecting the best subject line
• Ordering recommended products

Practical implementation roadmap

Phase 1: Quick wins (4–8 weeks)

• Connect purchase + browsing data
• Create customer segments
• Add: - Recently viewed products
• Abandoned cart emails
• Basic personalized subject lines

Phase 2: Predictive personalization (2–4 months)

• Build recommendation models
• Add propensity scores: - likelihood to buy
• churn risk
• category affinity

Phase 3: Real-time AI personalization

• Generate subject lines dynamically
• Personalize email blocks per customer
• Optimize send time and channel automatically

A strong default approach is:

Customer data platform → feature store → recommendation model → AI copy generation → experimentation loop

This gives you personalization that improves over time instead of a one-time segmentation project.

• A/B tests on subject lines
• Multivariate tests on recommendation placement
• Continuous model retraining

Example:

Control

"New arrivals are here"

Personalized

"Alex, new running gear picked for your next workout"

Compare incremental lift, not just engagement.

5. Suggested technology stack

Data layer

A strong solution is a real-time customer personalization layer that combines a customer profile, recent behavioral events, and a recommendation model, then exposes personalized outputs to your email/commerce systems.

Recommended architecture

• Customer profile: Store relatively stable attributes such as location, customer tier, preferences, purchase history, and lifecycle stage.
• Recent activity stream: Capture events such as product views, searches, cart additions, purchases, email opens/clicks, and recent browsing. Keep a short rolling window (e.g., 7–30 days) for high-intent signals.
• Feature layer: Transform these into features such as: - days_since_last_purchase
• views_of_category_7d
• cart_items_24h
• preferred_categories
• price_band
• engagement_score
• Recommendation engine: Use a hybrid approach: - Collaborative filtering for "customers like you also bought..."
• Content-based matching for product/category preferences
• Recent activity to boost products related to current intent
• Business rules for inventory, margin, eligibility, and exclusions
• Subject-line personalization: Generate a small set of candidate subjects using profile + activity features, then rank them with a model trained on historical opens/clicks. Avoid putting sensitive attributes into the subject line.
• Decision API: Have one service return something like:

{
  "customer_id": "123",
  "subject_line": "New picks based on what you've been browsing",
  "products": ["SKU_42", "SKU_91", "SKU_17"],
  "reason_codes": [
    "recent_category_interest",
    "similar_to_previous_purchase"
  ]
}

How I'd implement it

Start with a rules + ML hybrid, rather than immediately building a complex generative system.

For example, if someone recently viewed running shoes three times, has historically purchased athletic apparel, and hasn't purchased in 30 days:

1. Increase the ranking weight for running shoes.
2. Recommend products similar to the viewed shoes.
3. Exclude products they've already bought.
4. Personalize the subject around their demonstrated interest rather than exposing personal attributes.
5. Experiment against a non-personalized control group.

The key is to optimize incremental conversion/revenue, not simply open rate. For subject lines especially, an A/B or multi-armed-bandit framework can measure whether personalization actually causes additional engagement.

If you tell me your stack (e.g. Shopify + Klaviyo, Salesforce Marketing Cloud, Braze, or a custom data platform), I can propose a concrete architecture and implementation plan.

A strong solution is a real-time personalization service that combines customer attributes with recent behavioral events, then feeds both subject-line generation and product-ranking models.

Recommended architecture

• Customer profile: Store relatively stable attributes such as location, lifecycle stage, preferences, past purchases, and customer value.
• Event stream: Capture recent activity—product views, searches, cart additions, purchases, email opens/clicks, and session activity.
• Feature layer: Turn those inputs into features such as: - days_since_last_purchase
• products_viewed_7d
• favorite_category
• cart_value
• engagement_score_30d
• price_range
• Product recommender: Start with a hybrid model combining: - Collaborative filtering for behavioral similarity
• Content/category similarity
• Business rules such as inventory, margin, eligibility, and exclusions
• Recency weighting so yesterday's behavior matters more than behavior six months ago
• Subject-line personalization: Use customer/behavioral features to select or generate subject-line variants. For example, a customer who recently viewed running shoes might receive a subject emphasizing running footwear, while a dormant customer could receive a re-engagement message.
• Decision layer: Rank candidate subject lines and products for each customer, with frequency caps and fallback logic when insufficient data exists.
• Experimentation: A/B or multivariate test personalized vs. generic content. Optimize initially for clicks/conversions rather than opens alone.

Example

For customer C123:

Attributes:
  lifecycle = "repeat_customer"
  preferred_category = "outdoor"
  price_band = "$50-$150"

Recent activity:
  viewed = ["hiking boots", "rain jackets"]
  cart_added = ["hiking boots"]
  last_activity = "2 hours ago"

Recommendations:
  1. Hiking boots
  2. Waterproof jacket
  3. Hiking socks

Subject candidates:
  A. "Ready for your next adventure?"
  B. "Still thinking about those hiking boots?"
  C. "New outdoor gear picked for you"

The system can then select B + the ranked product recommendations, provided experimentation shows that this combination performs well for customers with similar behavior.

Implementation approach

I would not start with a large generative-AI system. Begin with a feature store + recommender/ranking model + templated subject lines. Once you have enough interaction data, introduce an LLM to generate subject-line candidates, while keeping the ranking/eligibility layer deterministic.

A practical stack could look like:

CRM/CDP → event stream → feature store → personalization API → recommendation/ranking models → email platform

The key design principle is to separate what you're allowed to recommend from what is likely to perform well. Eligibility, inventory, privacy, and business rules should constrain the candidate set before an ML/LLM model ranks or generates personalized content.

A strong solution is a real-time personalization service that combines a customer profile with recent behavioral events and feeds both a subject-line model and a product-ranking model.

Recommended architecture

• Customer profile store: demographics, preferences, lifecycle stage, historical purchases, price sensitivity, and category affinities.
• Event stream: recent views, searches, cart additions, purchases, email opens/clicks, and inactivity. Keep short windows such as 1 hour, 1 day, 7 days, and 30 days.
• Feature layer: transform raw attributes/events into model-ready features, e.g.: - days_since_last_purchase
• views_of_category_7d
• cart_items_24h
• preferred_price_band
• recently_viewed_product_ids
• Subject-line personalization: predict the probability of an open/click for candidate subject lines given the customer's features. Start with a gradient-boosted model or contextual bandit rather than generating arbitrary text for every customer.
• Product recommendations: use a hybrid ranker combining: - collaborative filtering from purchase/view behavior,
• content/category similarity,
• real-time session activity,
• business constraints such as inventory, margin, and eligibility.
• Decision layer: rank candidate subject lines and products, apply frequency/eligibility rules, and return the top choice plus a fallback.
• Experimentation: continuously A/B test against a non-personalized control and measure incremental revenue, conversion, unsubscribe rate, and long-term customer value.

Example

A customer who recently viewed running shoes, normally buys mid-priced athletic products, and has not purchased in 45 days could receive a subject line emphasizing new running footwear, while the recommendation module ranks relevant running shoes first.

The important design choice is to separate prediction from generation: let behavioral models determine what is likely to work, then use controlled templates or an LLM to produce the final subject-line wording. This makes personalization measurable and much easier to govern.

For an initial implementation, I'd build one shared customer-feature pipeline with two models—a subject-line propensity model and a product-ranking model—rather than creating a single monolithic personalization model.

A strong solution is a real-time customer-personalization layer that combines a customer profile with recent behavioral events and uses separate models for subject-line optimization and product recommendations.

Recommended architecture

1. Unified customer profile

• Demographics: location, age range, customer tier, language
• Lifecycle: new customer, active, lapsed, VIP
• Preferences: categories, brands, price range
• Historical behavior: purchases, opens, clicks, returns
• Recent-activity stream

Capture events such as:

• Product views and searches
• Cart additions/abandonments
• Recent purchases
• Email opens/clicks
• Website/app sessions

Give recent events substantially more weight than older behavior—for example, using time-decayed features.

3. Subject-line personalization

Start with a rules/model hybrid:

• Generate several candidate subject lines.
• Predict the probability of an open/click for each customer.
• Select the highest-scoring candidate subject to brand and frequency constraints.
• Use A/B or multi-armed-bandit testing to continuously learn which styles work for different customer segments.

Example features:
customer_tier + preferred_category + days_since_last_purchase + recent_category_views + email_engagement + local_context

4. Product recommendations

Use a hybrid recommender:

• Collaborative filtering for "customers like you bought..."
• Content-based matching for products similar to recently viewed items
• Business rules for inventory, margin, availability, and exclusions
• Recency weighting so a product viewed yesterday matters more than something viewed six months ago

A ranking model can then score:
customer × product → purchase_probability

5. Personalized email assembly

Customer profile
       +
Recent activity
       ↓
Feature store
    ↙       ↘
Subject      Product
model        recommender
    ↘       ↙
  Personalized email
       ↓
   Experimentation
       ↓
  Engagement events
       ↺

Practical implementation

For an MVP, I'd avoid jumping straight to a complex deep-learning system. Build:

• Event pipeline: website/app/email events → streaming or batch warehouse
• Feature store: customer attributes + time-decayed behavioral features
• Recommendation service: candidate generation → ranking → business-rule filtering
• Subject-line service: template/candidate generation → propensity scoring
• Experimentation layer: randomized A/B tests initially, progressing to contextual bandits
• Feedback loop: opens, clicks, conversions, unsubscribes, and purchases continuously feed model retraining

The key design principle is to separate candidate generation from ranking. Generate perhaps 50–200 plausible products, then use the customer's attributes and recent activity to rank them. This keeps the system fast while allowing sophisticated personalization.

For subject lines, optimize for downstream value rather than opens alone—e.g., revenue per recipient or conversion probability—because a subject line that generates opens but attracts low-intent clicks can look successful while hurting the business.

If you tell me your stack (e.g. Salesforce/HubSpot + Snowflake + AWS, or Shopify + Klaviyo), I can map this into a concrete implementation architecture.

A strong solution is a real-time customer personalization service that combines a customer profile with recent behavioral signals, then uses separate models for subject-line generation and product ranking.

Recommended architecture

1. Customer profile

• Demographics and preferences
• Purchase history and lifetime value
• Categories/brands previously purchased or viewed
• Consent and communication preferences
• Recent-activity stream

• Page/product views
• Searches
• Cart additions/abandonments
• Purchases
• Email opens/clicks
• Recency and frequency of activity
• Feature layer

Create features such as:

• days_since_last_purchase
• views_7d_by_category
• cart_items_24h
• favorite_brand
• purchase_frequency
• email_engagement_30d

Keep these features available both for batch training and low-latency inference.

4. Product recommendation model

Use a two-stage approach:

• Candidate generation: collaborative filtering + content/category similarity + recently popular products.
• Ranking: score candidates using customer attributes, recent activity, product attributes, inventory, margin, and business rules.

For example:

recommendation_score = model(customer_features, activity_features, product_features)

5. Subject-line personalization

Don't simply put customer attributes directly into an LLM prompt. Instead, generate several controlled variants based on the customer's current intent, such as:

• New arrivals in a recently viewed category
• Replenishment after a previous purchase
• Abandoned-cart reminder
• Personalized offer
• Editorial/discovery content

A language model can turn the selected strategy and approved product/message attributes into natural-sounding subject lines, while a policy layer prevents inappropriate or misleading personalization.

6. Decisioning + experimentation

Before sending, apply eligibility, frequency-cap, inventory, pricing, and consent rules. Then use A/B testing or contextual bandits to learn which subject-line strategy and recommendation strategy works best for each customer segment.

A practical MVP

I'd start with:

Customer data → event stream → feature store → recommendation ranker → personalization API → email platform

For the first version, you don't need a sophisticated deep-learning system. A gradient-boosted ranking model plus simple candidate generation can perform very well, provided the behavioral features are good. Add an LLM only to the language-generation layer, not as the core recommendation engine.

The personalization API could return something like:

{
  "customer_id": "123",
  "campaign": "weekly_email",
  "subject_strategy": "recent_interest",
  "subject_context": {
    "category": "running shoes",
    "reason": "viewed 4 products in 7 days"
  },
  "recommendations": [
    {"product_id": "A17", "score": 0.91},
    {"product_id": "B42", "score": 0.87},
    {"product_id": "C08", "score": 0.81}
  ]
}

Key design principle: treat recent activity as intent and customer attributes as context. Recent behavior should generally have more influence on what you recommend than static demographic attributes.

If you're building this for a specific stack (e.g. Snowflake + Databricks + Salesforce/HubSpot, or an in-house email platform), I can sketch the concrete architecture and data schema.

I’d recommend a real-time customer personalization layer that combines a customer profile with recent behavioral events, then uses that context to personalize both email subject lines and product recommendations.

Recommended architecture

• Customer profile: Store relatively stable attributes such as location, lifecycle stage, preferences, loyalty tier, and historical purchase categories.
• Recent activity stream: Capture events such as product views, searches, cart additions, purchases, email clicks, and recent sessions. Give recent events higher weight than older activity.
• Feature/personalization layer: Convert these signals into features such as: - last_viewed_category
• top_interests_30d
• days_since_purchase
• cart_value
• price_affinity
• engagement_score_7d
• Recommendation engine: Generate a ranked set of products using a hybrid approach: - recent behavior
• customer preferences
• similar products
• collaborative behavior from similar customers
• business constraints such as inventory and margin
• Subject-line personalization: Use the same profile/activity features to select or generate subject-line variants. For example: - High recent engagement → “Still thinking about running shoes?”
• Recent purchase → “Complete your new camera setup”
• Category affinity → “New arrivals picked for your home office”
• Decisioning layer: Apply eligibility, frequency caps, suppression rules, and experimentation before sending.
• Measurement: A/B test personalized vs. generic experiences and track incremental conversion/revenue, not just opens or clicks.

A practical implementation

I'd start with rules + ML rather than jumping directly to an LLM:

Customer attributes + recent events → feature store → recommendation model + subject-line decisioning → email/SMS/personalization channel → outcome events

Use an LLM primarily for generating subject-line candidates from structured personalization signals, while keeping product selection and eligibility deterministic/ML-driven.

The key design principle is to make personalization event-aware: a product viewed 10 minutes ago should generally matter more than a category purchased six months ago, while purchases should trigger appropriate exclusions so you don't recommend something the customer just bought.

If you tell me your stack (e.g. Salesforce, Braze, Segment, Snowflake, Shopify, AWS), I can recommend a concrete architecture and vendors.

A strong solution is a real-time personalization service that combines customer attributes with recent behavioral signals, then generates both subject lines and product recommendations.

Recommended architecture

• Customer profile layer: Store relatively stable attributes such as demographics, lifecycle stage, location, preferences, loyalty tier, and historical purchase categories.
• Activity/event layer: Capture recent events such as product views, searches, cart additions, purchases, email opens/clicks, and recency/frequency signals.
• Feature store: Transform these into features such as: - days_since_last_purchase
• products_viewed_last_7d
• favorite_category
• cart_value
• discount_affinity
• recently_viewed_products
• Recommendation engine: Start with a hybrid approach: - collaborative filtering for "customers like you"
• content-based ranking using product/category affinity
• business constraints for inventory, margin, eligibility, and exclusions
• recency weighting so recent activity has more influence
• Subject-line personalization: Use customer/behavioral features to select or generate variants, e.g.: - New customer → onboarding/value proposition
• Recently viewed product → reminder or related benefit
• Abandoned cart → specific cart item/value
• Frequent buyer → complementary products or loyalty messaging
• Decision/ranking layer: Score candidate recommendations and subject-line variants jointly against the campaign objective (click, conversion, revenue, etc.).
• Experimentation: Continuously A/B test personalization against a non-personalized control. Eventually use contextual bandits to allocate traffic toward better-performing variants.

Example

Suppose a customer has recently viewed running shoes twice, purchased running apparel last month, and tends to buy during sales.

The system could produce:

Subject: “Still thinking about those running shoes? 👟”

And recommend:

1. The recently viewed shoes
2. Similar shoes in the customer's preferred price range
3. Complementary running socks
4. A relevant sale item

The key is not to feed every customer attribute directly into an LLM. I'd use a structured feature/ranking system to decide what should be personalized, with an LLM optionally generating the final subject-line wording from approved inputs.

Practical MVP

For an initial implementation, I'd build:

CDP/warehouse → feature pipeline → recommendation model → personalization API → email platform

Start with rules + collaborative/content-based recommendations, 5–10 subject-line templates, and randomized holdout groups. Once you have enough interaction data, replace the hand-tuned ranking with a learned model.

This gives you something relatively simple to launch while preserving a path toward real-time, individualized recommendations and subject lines.

A strong solution is a real-time customer personalization service that combines a customer profile, recent behavioral activity, and a recommendation/ranking layer.

Recommended architecture

• Customer profile store: Maintain attributes such as location, lifecycle stage, loyalty tier, preferred categories, average order value, and historical purchases.
• Activity stream: Capture recent events—product views, searches, cart additions, purchases, email opens/clicks, and inactivity.
• Feature layer: Turn raw data into features such as:

• days_since_last_purchase
• favorite_category
• recently_viewed_products
• discount_affinity
• purchase_frequency
• email_engagement
• Subject-line personalization: Use a template/ranking model to select the best subject line based on customer context. For example, a frequent sneaker buyer might receive “New arrivals picked for your sneaker rotation”, while an inactive customer gets a re-engagement message.
• Product recommendations: Generate candidates from recent views, purchase history, similar products, trending items, and complementary products. Rank them using customer and product features.
• Decision API: Expose something like:

GET /personalize?customer_id=123&channel=email

returning both the recommended subject line and ranked products.

• Experimentation: Continuously A/B test subject lines and recommendation strategies, measuring open rate, click-through, conversion, revenue per recipient, and unsubscribe rate.

Practical model strategy

Don't start with a large generative model for everything. I'd use a hybrid system:

Rules → candidate generation → ML ranking → optional LLM wording

For example:

Customer + recent events → features → product candidates → ranking model → top 5 products

and

Customer + campaign + ranked products → subject-line templates/LLM → safety & brand checks → final subject

This gives you personalization without sacrificing predictability or control.

Important safeguards

• Apply frequency caps so recent activity doesn't cause creepy repetition.
• Don't expose sensitive attributes in subject lines.
• Keep recommendations explainable enough to debug.
• Fall back to popular/trending products when there isn't enough customer history.
• Separate eligibility from ranking so unavailable, inappropriate, or already-purchased products can be filtered before ranking.
• Use holdout groups to measure whether personalization actually creates incremental revenue rather than merely correlating with already-engaged customers.

If you're building this for a real production system, I'd recommend event streaming + feature store + recommendation/ranking service + experimentation platform, with the personalization API serving both email subject lines and product recommendations.

A strong solution is a real-time customer personalization service that combines a customer profile with recent behavioral signals, then uses separate models for subject-line generation and product ranking.

Recommended architecture

• Customer profile: Store relatively stable attributes such as location, lifecycle stage, preferred categories, loyalty tier, and historical purchase patterns.
• Recent activity stream: Capture events such as page views, searches, cart additions, purchases, email opens/clicks, and product interactions.
• Feature layer: Transform these into features such as: - days_since_last_purchase
• views_by_category_7d
• cart_items_24h
• recently_viewed_products
• email_engagement_30d
• price_range_preference
• Product recommendation model: Generate candidates using collaborative filtering/embeddings, then rank them using customer attributes + recent activity. Apply business rules afterward for inventory, eligibility, margin, and diversity.
• Subject-line personalization: Feed the same customer/context features into a constrained LLM or supervised model to select or generate subject lines. Keep the model focused on style and messaging, while the recommendation/ranking system determines the actual products.
• Decision layer: Choose the final subject line and recommendations, with fallback to non-personalized content when confidence is low.
• Experimentation: Continuously A/B test personalization against a control and optimize for downstream metrics such as conversion and revenue—not just opens.

Example

For a customer who recently browsed running shoes, bought athletic apparel, and usually purchases mid-priced products:

Subject: “New running gear picked for you”
Recommendations: 2 running shoes + 1 complementary apparel item, ranked according to their preferences and recent behavior.

I'd favor this hybrid approach over having an LLM directly make all recommendations: traditional ranking models are better suited to relevance, while an LLM is useful for natural-language personalization.

If you're building this from scratch, a good MVP is event tracking → feature store → candidate generation → ranking model → LLM subject-line personalization → A/B testing.

A strong solution is a real-time customer personalization layer that feeds both email subject-line generation and product recommendations.

Recommended architecture

• Customer profile store: Maintain stable attributes such as location, lifecycle stage, loyalty tier, preferred categories, historical spend, and price sensitivity.
• Behavior/event stream: Capture recent events—product views, searches, cart additions, purchases, email opens/clicks, and inactivity—with timestamps.
• Feature layer: Convert raw data into features such as: - Last product/category viewed
• Products viewed in the last 7 days
• Purchase recency/frequency
• Category affinity
• Discount engagement
• Current cart contents
• Predicted next purchase category
• Recommendation engine: Start with a hybrid model combining collaborative filtering, content-based similarity, and recent behavioral signals. Apply business rules for inventory, eligibility, margin, and frequency caps.
• Subject-line personalization: Use a controlled LLM or template system that receives a small, approved set of customer features and campaign context. Generate several candidates, then rank them using historical engagement models.
• Decision/ranking layer: Optimize for the actual business objective—e.g. conversion or revenue per recipient—not simply open rate.
• Experimentation: Continuously A/B test personalized vs. generic content and use multi-armed bandits once you have enough traffic.

Example

Suppose a customer:

Gold member → viewed running shoes 3 times this week → abandoned a pair → frequently buys Nike → responds well to 10% discounts.

The system could recommend the abandoned shoes plus related running products, while generating subject-line candidates such as:

• “Still thinking about those running shoes?”
• “Your next run starts here 👟”
• “A little something for your next run”

The ranking model would select the version most likely to produce the desired outcome for that customer segment.

Practical implementation

I'd avoid building a large ML platform initially. A good MVP is:

Event tracking → customer/feature store → recommendation service → subject-line generation/ranker → ESP → experiment feedback

Keep the LLM out of the raw customer-data pipeline. Give it only the minimum approved attributes, enforce privacy/consent rules, and use deterministic templates as a fallback.

If you tell me your stack (e.g. Salesforce/HubSpot + Snowflake/Databricks + an ESP), I can propose a concrete architecture and model choices.

A strong solution is a real-time personalization service that combines a customer profile with recent behavioral events, then uses separate models for subject-line generation and product ranking.

Recommended architecture

• Customer profile: Store relatively stable attributes such as location, lifecycle stage, preferences, historical purchases, average order value, and category affinity.
• Recent activity: Stream events such as page views, searches, product views, cart additions, purchases, email opens/clicks, and inactivity. Keep a short rolling window (e.g. 1–30 days) because recent intent is often more predictive than older behavior.
• Feature layer: Convert the profile + events into features such as: - Last viewed category/product
• Number of views in the last 7 days
• Carted-but-not-purchased products
• Recent purchase category
• Discount sensitivity
• Engagement with previous email campaigns
• Time since last purchase
• Product recommender: Generate a candidate set using collaborative filtering/content similarity, then rank candidates using customer attributes + recent activity. Apply business rules afterward for inventory, eligibility, margin, exclusions, etc.
• Subject-line personalization: Feed the same feature set into a model that selects or generates subject lines. I'd generally prefer template/LLM generation constrained by approved messaging, followed by a predictive ranking model, rather than letting an LLM independently decide what to send.
• Decision layer: Optimize for the actual business objective—e.g. incremental purchase/conversion or revenue—not simply open rate. Use experimentation or contextual bandits to learn which personalization works for which customer segments.

Example

Suppose a customer:

• viewed running shoes 3 times yesterday,
• added a pair to cart but didn't buy,
• historically buys Nike,
• responds well to 10% discounts,
• hasn't purchased in 60 days.

The system might produce:

Subject: “Still thinking about those running shoes?”

Recommendations:

1. The abandoned pair, if still eligible
2. Similar Nike running shoes
3. A complementary running accessory

A different customer who recently bought running shoes would instead receive complementary products rather than another pair.

Implementation choice

For most teams, I'd build this as:

Event stream → customer/feature store → candidate generation → ranking models → personalization API → email/recommendation channels → experimentation/feedback loop

The key design principle is to separate candidate generation, ranking, and message generation. That makes the system easier to evaluate, control, and improve than one large AI prompt.

If you're already using a particular stack (e.g. Snowflake + dbt + Python, AWS, GCP, Salesforce, or Shopify), I can also lay out a concrete production architecture and model choices.

A good solution is a customer data platform (CDP) + personalization engine + marketing automation workflow that uses customer attributes and recent behavioral signals to generate dynamic subject lines and product recommendations.

Recommended architecture

1. Build a unified customer profile

Collect customer attributes and activity into a single profile:

Customer attributes

• Demographics: age range, location, language
• Customer tier: VIP, new customer, churn risk
• Preferences: categories, brands, price sensitivity
• Historical behavior: purchases, returns, average order value

Recent activity signals

• Products viewed in the last 24–72 hours
• Searches performed
• Cart additions and abandonments
• Email opens/clicks
• Recent purchases
• Time since last engagement

A CDP such as segment.com, segment.com, or a cloud data warehouse setup can serve as the profile layer.

2. Use a recommendation engine

Combine multiple recommendation approaches:

Behavioral recommendations

Best for active shoppers:

• “You viewed this, you may like these”
• “Complete your look”
• “Back in stock from your wishlist”

Signals:

• Recent views
• Cart activity
• Similar user behavior

Collaborative filtering

Find products liked by similar customers:

• “Customers like you also bought…”

Contextual recommendations

Adjust by:

• Season
• Location
• Device
• Time of day
• Inventory availability

Business rules

Add guardrails:

• Promote high-margin items
• Avoid recommending already purchased items
• Prioritize available inventory
• Respect category exclusions

Recommendation platforms include aws.amazon.com and cloud.google.com.

3. Generate personalized subject lines

Use a combination of templates, customer attributes, and AI generation.

Examples:

Basic segmentation

• “New arrivals in Chicago just for you”
• “Your favorite brands are back”

Behavior-triggered

• “Still thinking about these?”
• “Your cart favorites are waiting”

Purchase-based

• “New products that match your recent purchase”
• “Complete your setup with these picks”

AI-assisted generation
Feed the model:

• Customer segment
• Recent activity
• Recommended products
• Brand voice rules
• Compliance constraints

Then generate multiple variants and test them.

Example input:

Customer:
- Segment: Premium outdoor shopper
- Recent activity: Viewed hiking jackets twice
- Recommendation: Lightweight rain shell
- Goal: Increase click-through rate

Generate:
- 5 email subject lines
- Under 45 characters
- Friendly, premium tone

4. Add experimentation and learning

Run automated tests:

• Subject line A: “New jackets you’ll love”
• Subject line B: “Your next adventure starts here”
• Subject line C: “The rain shell you viewed is back”

Optimize for:

• Open rate
• Click-through rate
• Conversion rate
• Revenue per recipient
• Long-term engagement

Use tools like optimizely.com or experimentation features in your marketing platform.

5. Example workflow

1. Customer views running shoes twice.
2. Event is captured in the customer profile.
3. Recommendation model identifies: - Similar running shoes
4. Socks/accessories
5. New arrivals in the same brand
6. AI generates subject line options: - “Ready for your next run?”
7. “New gear to match your running style”
8. Email platform sends the best-performing version.
9. Results feed back into the model.

Suggested implementation stack

Enterprise

• CDP: Segment
• Data warehouse: Snowflake or BigQuery
• Recommendations: Amazon Personalize / Vertex AI
• Messaging: Salesforce Marketing Cloud or Adobe Campaign

Mid-market

• Customer data + automation: klaviyo.com
• Recommendations: built-in personalization or third-party recommender
• AI subject line generation + A/B testing

Custom build

• Events → warehouse → ML model → API → email platform
• Use embeddings for product similarity
• Use LLMs for copy generation
• Use rules for business constraints

A practical starting point is to implement behavior-triggered recommendations + segmented AI-generated subject lines, then add machine-learning recommendations once you have enough interaction data.

A strong solution is to build a customer data + AI personalization layer that combines customer attributes, behavioral signals, and product data to generate individualized email subject lines and recommendations in real time.

Recommended architecture

1. Create a unified customer profile

Collect customer attributes and activity into a customer profile:

Static attributes

• Age range, location, language
• Customer segment
• Loyalty tier
• Preferred categories
• Historical purchase value

Behavioral signals

• Recently viewed products
• Searches
• Cart additions/abandonment
• Purchase history
• Email opens/clicks
• Browsing frequency
• Time since last engagement

A customer data platform (CDP) or warehouse-based approach can maintain these profiles.

Examples:

• segment.com
• salesforce.com
• segment.com

2. Use a recommendation engine for products

Combine several recommendation approaches:

• Collaborative filtering

• “Customers like you bought…”
• Uses patterns across similar customers.
• Content-based recommendations

• Matches products based on attributes: - category
• brand
• price range
• style
• compatibility
• Session-based recommendations

• Prioritizes recent intent: - viewed a laptop → recommend accessories
• abandoned running shoes → recommend related items
• Business rules

• Avoid recommending: - already purchased items
• out-of-stock products
• low-margin items when a better option exists

Common platforms:

• aws.amazon.com
• cloud.google.com
• dynamicyield.com

3. Generate personalized subject lines with AI

Use an LLM with structured inputs rather than asking it to write freely.

Example input:

{
  "customer_segment": "frequent outdoor shopper",
  "recent_activity": [
    "viewed hiking boots",
    "searched waterproof jackets"
  ],
  "recommended_products": [
    "Gore-Tex hiking jacket",
    "trail socks"
  ],
  "brand_voice": "friendly and concise",
  "goal": "increase email opens"
}

Generate several variants:

• “Ready for your next trail adventure?”
• “New waterproof gear picked for your hikes”
• “Your hiking essentials are waiting”

Then optimize using:

• A/B testing
• Multi-armed bandits
• Open-rate prediction models

4. Add a personalization decision layer

Before sending, use rules + models to decide:

• Which products to show
• Which message angle to use
• When to send
• How much personalization is appropriate

Example:

5. Measure and continuously improve

Track:

• Open rate
• Click-through rate
• Conversion rate
• Revenue per email
• Recommendation acceptance
• Unsubscribe rate

Use experiments to compare:

• Generic subject line vs AI-generated subject line
• Popular products vs personalized recommendations
• Rule-based vs ML recommendations

Practical implementation stack

A typical setup:

1. Data ingestion

• Website/app events
• CRM
• Ecommerce platform
• Customer data layer

• CDP or data warehouse
• ML layer

• Recommendation model
• Customer segmentation
• Subject-line generation model
• Activation

• Email platform such as braze.com, klaviyo.com, or business.adobe.com
• Experimentation

• Automated testing and feedback loops

Suggested starting approach

For most teams, start with:

1. Capture browsing + purchase events.
2. Build customer profiles.
3. Implement a recommendation model for “recently viewed + similar products.”
4. Use an LLM to generate 3–5 subject line variants per segment.
5. Run controlled experiments and feed results back into the models.

This gives measurable gains without requiring a fully autonomous AI marketing system from day one.

Practical implementation stack

A typical setup:

A strong solution is a real-time customer decisioning + ML personalization layer that feeds both email subject-line generation and product recommendations.

Recommended architecture

1. Unify customer attributes
   • Profile: location, lifecycle stage, loyalty tier, preferences, demographics where appropriate.
   • Behavioral data: purchases, browsing, searches, cart activity, email opens/clicks.
   • Recency/frequency signals: what they viewed or bought in the last 1, 7, 30 days.

2. Create customer-level features

Examples:

• days_since_last_purchase
• recent_categories_viewed
• favorite_category
• average_order_value
• discount_affinity
• recent_product_views
• lifecycle_stage

3. Product recommendation model

Use a hybrid recommender:

• Collaborative filtering for “customers like you bought…”
• Content-based recommendations using product/category attributes.
• Recent activity to capture immediate intent.
• Business rules for inventory, margin, exclusions, and already-purchased products.

A useful ranking formulation is:

score(product, customer) = model_affinity + recency_boost + category_affinity + business_constraints

4. Subject-line personalization

Rather than simply inserting a customer's name, use an ML/LLM-assisted system that selects the message angle based on the same customer features:

• Recent browsing → “Still thinking about…”
• Frequent buyer → new arrivals in their favorite category
• Price-sensitive customer → savings/discount angle
• Lapsed customer → re-engagement angle

Generate several candidates, then use a predictive model to rank them for expected open/click/conversion probability.

5. Experiment continuously

Run randomized A/B or multi-armed-bandit tests comparing:

• Generic vs. personalized subject lines
• Different personalization strategies
• Recommendation algorithms
• Different levels of personalization

Optimize toward incremental revenue/conversion, not merely opens, since highly clickbait-oriented subject lines can inflate opens without improving business outcomes.

Practical implementation

If you already have a customer-data platform/warehouse, I'd build it as:

Data warehouse/CDP → feature store → recommendation/ranking service → personalization API → email/marketing platform

For each campaign, the API could return something like:

{
  "customer_id": "123",
  "subject_line": "New arrivals picked for your style",
  "recommendations": [
    {"product_id": "A17", "score": 0.94},
    {"product_id": "B42", "score": 0.89},
    {"product_id": "C08", "score": 0.83}
  ]
}

My recommendation

For most organizations, don't build two independent personalization systems. Build a shared customer-feature layer and decisioning/ranking service, then let subject lines and recommendations consume the same signals.

That gives you consistent personalization, makes experimentation easier, and lets you eventually optimize the whole customer journey rather than isolated email metrics.

If you're choosing technology, the right stack depends heavily on whether you already use something like Salesforce, Braze, Klaviyo, Adobe, Snowflake, Databricks, or a custom data warehouse.

A strong approach is a real-time customer segmentation + personalization layer that feeds both your email subject-line generator and recommendation engine.

Recommended architecture

1. Build a unified customer profile
Combine relatively stable attributes with behavioral signals:

• Attributes: location, language, customer tier, lifecycle stage, preferences
• Recent activity: pages/products viewed, searches, purchases, cart activity, email engagement
• Derived features: favorite categories, price affinity, purchase frequency, recency, predicted interests

Store these in a customer data platform, warehouse, or feature store with a consistent customer ID.

2. Generate personalized subject lines
Use a template/LLM layer constrained by customer attributes and campaign context.

For example:

Customer: high-value customer, recently viewed running shoes, purchased athletic apparel
Campaign: footwear promotion
→ “New running shoes picked for you 👟”

I'd avoid simply prompting an LLM with the entire customer record. Instead, expose a small set of approved personalization features and enforce rules around sensitive attributes, frequency, tone, and factual claims.

3. Generate product recommendations
Use a hybrid recommender rather than relying exclusively on an LLM:

• Collaborative filtering: customers with similar behavior
• Content-based: products similar to recently viewed/purchased items
• Business rules: inventory, margin, eligibility, exclusions
• Recency weighting: recent behavior gets more influence
• Personalization fallback: popular/trending products when activity is sparse

A useful ranking formulation is roughly:

recommendation score = behavioral affinity + product similarity + recency + business value − exclusions

4. Personalize at send time
Instead of creating a static segment like “people who viewed shoes,” calculate the subject line and recommendations using the latest available activity shortly before the message is sent.

A typical flow:

Customer activity → profile/features → candidate products → ranking → subject-line personalization → email

What I'd implement first

For an MVP, I'd use:

The key is to separate recommendation/ranking from language generation. The recommender decides what to show; the personalization layer decides how to communicate it. That makes the system easier to evaluate, control, and improve.

If you're choosing a specific technology stack, I can also recommend an implementation using Snowflake/Databricks + a CDP + a recommender model + an LLM, including the data schema and event flow.

A strong approach is to combine attribute-based personalization (who the customer is) with behavior-based personalization (what they recently did). This typically produces better engagement than relying on either alone.

Subject line personalization strategy

Create a subject line using multiple signals instead of just inserting the customer's name.

Examples:

• Name + interest: "Emma, new arrivals in your favorite collection"
• Loyalty status: "Gold members get first access today"
• Recent browsing: "Still thinking about these headphones?"
• Recent purchase: "Complete your setup with these accessories"
• Location: "Ready for cooler weather in Seattle?"

Use dynamic rules such as:

IF abandoned_cart
    Subject = "Your items are waiting"
ELSE IF browsed_category
    Subject = "New arrivals in {favorite_category}"
ELSE IF loyalty_tier = Gold
    Subject = "Exclusive early access for Gold members"
ELSE
    Subject = "Products we picked just for you"

Product recommendation strategy

Combine several recommendation models rather than relying on a single algorithm.

1. Recently viewed

• Show products the customer viewed but didn't purchase.

2. Similar products

• Recommend items with similar attributes (brand, style, category, price).

3. Frequently bought together

• Suggest complementary products based on historical purchase patterns.

4. Personalized ranking
Score each product using signals such as:

• affinity to category
• recent browsing
• purchase history
• inventory availability
• popularity
• profit margin
• business priorities

Example scoring function:

Recommendation Score =
0.40 × Category Affinity +
0.30 × Recent Activity +
0.15 × Purchase Similarity +
0.10 × Popularity +
0.05 × Business Priority

Customer attributes to use

Useful profile data includes:

• First name
• Age group (where appropriate and compliant)
• Gender preference (if collected)
• Geographic location
• Loyalty tier
• Preferred brands
• Favorite categories
• Average order value
• Purchase frequency
• Customer lifetime value

Recent activity signals

Behavioral signals often outperform static profile data:

• Products viewed
• Searches performed
• Items added to cart
• Cart abandonment
• Purchases
• Email opens
• Email clicks
• Website visits
• Time since last purchase
• Time since last visit

End-to-end example

Customer

• Gold member
• Favorite category: Running
• Viewed three pairs of shoes yesterday
• Purchased socks last month

Subject line

Alex, new running shoes picked just for you

Email content

1. Recently viewed running shoes
2. Similar running shoes in stock
3. Matching performance apparel
4. Running socks and accessories
5. Gold member discount banner

Best practices

• Use behavioral data from the last 7–30 days to keep recommendations relevant.
• Fall back to best sellers or trending products if recent activity is sparse.
• Limit recommendations to 4–8 high-confidence products rather than showing many lower-quality options.
• Continuously A/B test subject lines and recommendation strategies, measuring open rate, click-through rate, conversion rate, and revenue per email.
• Respect user privacy and consent preferences, and avoid using sensitive personal attributes for personalization unless appropriate, compliant, and explicitly permitted.

This hybrid approach—combining customer attributes with recent behavior—typically delivers more relevant subject lines and product recommendations while remaining resilient when either profile or activity data is limited.

A strong approach is to combine attribute-based personalization (who the customer is) with behavior-based personalization (what they recently did). This typically produces better engagement than relying on either alone.

Subject line personalization strategy

Create a subject line using multiple signals instead of just inserting the customer's name.

Examples:

• Name + interest: "Emma, new arrivals in your favorite collection"
• Loyalty status: "Gold members get first access today"
• Recent browsing: "Still thinking about these headphones?"
• Recent purchase: "Complete your setup with these accessories"
• Location: "Ready for cooler weather in Seattle?"

Use dynamic rules such as:

IF abandoned_cart
    Subject = "Your items are waiting"
ELSE IF browsed_category
    Subject = "New arrivals in {favorite_category}"
ELSE IF loyalty_tier = Gold
    Subject = "Exclusive early access for Gold members"
ELSE
    Subject = "Products we picked just for you"

Product recommendation strategy

Combine several recommendation models rather than relying on a single algorithm.

1. Recently viewed

• Show products the customer viewed but didn't purchase.

2. Similar products

• Recommend items with similar attributes (brand, style, category, price).

3. Frequently bought together

• Suggest complementary products based on historical purchase patterns.

4. Personalized ranking
Score each product using signals such as:

• affinity to category
• recent browsing
• purchase history
• inventory availability
• popularity
• profit margin
• business priorities

Example scoring function:

Recommendation Score =
0.40 × Category Affinity +
0.30 × Recent Activity +
0.15 × Purchase Similarity +
0.10 × Popularity +
0.05 × Business Priority

Customer attributes to use

Useful profile data includes:

• First name
• Age group (where appropriate and compliant)
• Gender preference (if collected)
• Geographic location
• Loyalty tier
• Preferred brands
• Favorite categories
• Average order value
• Purchase frequency
• Customer lifetime value

Recent activity signals

Behavioral signals often outperform static profile data:

• Products viewed
• Searches performed
• Items added to cart
• Cart abandonment
• Purchases
• Email opens
• Email clicks
• Website visits
• Time since last purchase
• Time since last visit

End-to-end example

Customer

• Gold member
• Favorite category: Running
• Viewed three pairs of shoes yesterday
• Purchased socks last month

Subject line

Alex, new running shoes picked just for you

Email content

1. Recently viewed running shoes
2. Similar running shoes in stock
3. Matching performance apparel
4. Running socks and accessories
5. Gold member discount banner

Best practices

• Use behavioral data from the last 7–30 days to keep recommendations relevant.
• Fall back to best sellers or trending products if recent activity is sparse.
• Limit recommendations to 4–8 high-confidence products rather than showing many lower-quality options.
• Continuously A/B test subject lines and recommendation strategies, measuring open rate, click-through rate, conversion rate, and revenue per email.
• Respect user privacy and consent preferences, and avoid using sensitive personal attributes for personalization unless appropriate, compliant, and explicitly permitted.

This hybrid approach—combining customer attributes with recent behavior—typically delivers more relevant subject lines and product recommendations while remaining resilient when either profile or activity data is limited.

A strong approach is to combine attribute-based personalization (who the customer is) with behavior-based personalization (what they recently did). This typically produces better engagement than relying on either alone.

Subject line personalization strategy

Create a subject line using multiple signals instead of just inserting the customer's name.

Examples:

• Name + interest: "Emma, new arrivals in your favorite collection"
• Loyalty status: "Gold members get first access today"
• Recent browsing: "Still thinking about these headphones?"
• Recent purchase: "Complete your setup with these accessories"
• Location: "Ready for cooler weather in Seattle?"

Use dynamic rules such as:

IF abandoned_cart
    Subject = "Your items are waiting"
ELSE IF browsed_category
    Subject = "New arrivals in {favorite_category}"
ELSE IF loyalty_tier = Gold
    Subject = "Exclusive early access for Gold members"
ELSE
    Subject = "Products we picked just for you"

Product recommendation strategy

Combine several recommendation models rather than relying on a single algorithm.

1. Recently viewed

• Show products the customer viewed but didn't purchase.

2. Similar products

• Recommend items with similar attributes (brand, style, category, price).

3. Frequently bought together

• Suggest complementary products based on historical purchase patterns.

4. Personalized ranking
Score each product using signals such as:

• affinity to category
• recent browsing
• purchase history
• inventory availability
• popularity
• profit margin
• business priorities

Example scoring function:

Recommendation Score =
0.40 × Category Affinity +
0.30 × Recent Activity +
0.15 × Purchase Similarity +
0.10 × Popularity +
0.05 × Business Priority

Customer attributes to use

Useful profile data includes:

• First name
• Age group (where appropriate and compliant)
• Gender preference (if collected)
• Geographic location
• Loyalty tier
• Preferred brands
• Favorite categories
• Average order value
• Purchase frequency
• Customer lifetime value

Recent activity signals

Behavioral signals often outperform static profile data:

• Products viewed
• Searches performed
• Items added to cart
• Cart abandonment
• Purchases
• Email opens
• Email clicks
• Website visits
• Time since last purchase
• Time since last visit

End-to-end example

Customer

• Gold member
• Favorite category: Running
• Viewed three pairs of shoes yesterday
• Purchased socks last month

Subject line

Alex, new running shoes picked just for you

Email content

1. Recently viewed running shoes
2. Similar running shoes in stock
3. Matching performance apparel
4. Running socks and accessories
5. Gold member discount banner

Best practices

• Use behavioral data from the last 7–30 days to keep recommendations relevant.
• Fall back to best sellers or trending products if recent activity is sparse.
• Limit recommendations to 4–8 high-confidence products rather than showing many lower-quality options.
• Continuously A/B test subject lines and recommendation strategies, measuring open rate, click-through rate, conversion rate, and revenue per email.
• Respect user privacy and consent preferences, and avoid using sensitive personal attributes for personalization unless appropriate, compliant, and explicitly permitted.

This hybrid approach—combining customer attributes with recent behavior—typically delivers more relevant subject lines and product recommendations while remaining resilient when either profile or activity data is limited.

A strong approach is to combine attribute-based personalization (who the customer is) with behavior-based personalization (what they recently did). This typically produces better engagement than relying on either alone.

Subject line personalization strategy

Create a subject line using multiple signals instead of just inserting the customer's name.

Examples:

• Name + interest: "Emma, new arrivals in your favorite collection"
• Loyalty status: "Gold members get first access today"
• Recent browsing: "Still thinking about these headphones?"
• Recent purchase: "Complete your setup with these accessories"
• Location: "Ready for cooler weather in Seattle?"

Use dynamic rules such as:

IF abandoned_cart
    Subject = "Your items are waiting"
ELSE IF browsed_category
    Subject = "New arrivals in {favorite_category}"
ELSE IF loyalty_tier = Gold
    Subject = "Exclusive early access for Gold members"
ELSE
    Subject = "Products we picked just for you"

Product recommendation strategy

Combine several recommendation models rather than relying on a single algorithm.

1. Recently viewed

• Show products the customer viewed but didn't purchase.

2. Similar products

• Recommend items with similar attributes (brand, style, category, price).

3. Frequently bought together

• Suggest complementary products based on historical purchase patterns.

4. Personalized ranking
Score each product using signals such as:

• affinity to category
• recent browsing
• purchase history
• inventory availability
• popularity
• profit margin
• business priorities

Example scoring function:

Recommendation Score =
0.40 × Category Affinity +
0.30 × Recent Activity +
0.15 × Purchase Similarity +
0.10 × Popularity +
0.05 × Business Priority

Customer attributes to use

Useful profile data includes:

• First name
• Age group (where appropriate and compliant)
• Gender preference (if collected)
• Geographic location
• Loyalty tier
• Preferred brands
• Favorite categories
• Average order value
• Purchase frequency
• Customer lifetime value

Recent activity signals

Behavioral signals often outperform static profile data:

• Products viewed
• Searches performed
• Items added to cart
• Cart abandonment
• Purchases
• Email opens
• Email clicks
• Website visits
• Time since last purchase
• Time since last visit

End-to-end example

Customer

• Gold member
• Favorite category: Running
• Viewed three pairs of shoes yesterday
• Purchased socks last month

Subject line

Alex, new running shoes picked just for you

Email content

1. Recently viewed running shoes
2. Similar running shoes in stock
3. Matching performance apparel
4. Running socks and accessories
5. Gold member discount banner

Best practices

• Use behavioral data from the last 7–30 days to keep recommendations relevant.
• Fall back to best sellers or trending products if recent activity is sparse.
• Limit recommendations to 4–8 high-confidence products rather than showing many lower-quality options.
• Continuously A/B test subject lines and recommendation strategies, measuring open rate, click-through rate, conversion rate, and revenue per email.
• Respect user privacy and consent preferences, and avoid using sensitive personal attributes for personalization unless appropriate, compliant, and explicitly permitted.

This hybrid approach—combining customer attributes with recent behavior—typically delivers more relevant subject lines and product recommendations while remaining resilient when either profile or activity data is limited.

A strong approach is to combine attribute-based personalization (who the customer is) with behavior-based personalization (what they recently did). This typically produces better engagement than relying on either alone.

Subject line personalization strategy

Create a subject line using multiple signals instead of just inserting the customer's name.

Examples:

• Name + interest: "Emma, new arrivals in your favorite collection"
• Loyalty status: "Gold members get first access today"
• Recent browsing: "Still thinking about these headphones?"
• Recent purchase: "Complete your setup with these accessories"
• Location: "Ready for cooler weather in Seattle?"

Use dynamic rules such as:

IF abandoned_cart
    Subject = "Your items are waiting"
ELSE IF browsed_category
    Subject = "New arrivals in {favorite_category}"
ELSE IF loyalty_tier = Gold
    Subject = "Exclusive early access for Gold members"
ELSE
    Subject = "Products we picked just for you"

Product recommendation strategy

Combine several recommendation models rather than relying on a single algorithm.

1. Recently viewed

• Show products the customer viewed but didn't purchase.

2. Similar products

• Recommend items with similar attributes (brand, style, category, price).

3. Frequently bought together

• Suggest complementary products based on historical purchase patterns.

4. Personalized ranking
Score each product using signals such as:

• affinity to category
• recent browsing
• purchase history
• inventory availability
• popularity
• profit margin
• business priorities

Example scoring function:

Recommendation Score =
0.40 × Category Affinity +
0.30 × Recent Activity +
0.15 × Purchase Similarity +
0.10 × Popularity +
0.05 × Business Priority

Customer attributes to use

Useful profile data includes:

• First name
• Age group (where appropriate and compliant)
• Gender preference (if collected)
• Geographic location
• Loyalty tier
• Preferred brands
• Favorite categories
• Average order value
• Purchase frequency
• Customer lifetime value

Recent activity signals

Behavioral signals often outperform static profile data:

• Products viewed
• Searches performed
• Items added to cart
• Cart abandonment
• Purchases
• Email opens
• Email clicks
• Website visits
• Time since last purchase
• Time since last visit

End-to-end example

Customer

• Gold member
• Favorite category: Running
• Viewed three pairs of shoes yesterday
• Purchased socks last month

Subject line

Alex, new running shoes picked just for you

Email content

1. Recently viewed running shoes
2. Similar running shoes in stock
3. Matching performance apparel
4. Running socks and accessories
5. Gold member discount banner

Best practices

• Use behavioral data from the last 7–30 days to keep recommendations relevant.
• Fall back to best sellers or trending products if recent activity is sparse.
• Limit recommendations to 4–8 high-confidence products rather than showing many lower-quality options.
• Continuously A/B test subject lines and recommendation strategies, measuring open rate, click-through rate, conversion rate, and revenue per email.
• Respect user privacy and consent preferences, and avoid using sensitive personal attributes for personalization unless appropriate, compliant, and explicitly permitted.

This hybrid approach—combining customer attributes with recent behavior—typically delivers more relevant subject lines and product recommendations while remaining resilient when either profile or activity data is limited.

A strong approach is to combine attribute-based personalization (who the customer is) with behavior-based personalization (what they recently did). This typically produces better engagement than relying on either alone.

Subject line personalization strategy

Create a subject line using multiple signals instead of just inserting the customer's name.

Examples:

• Name + interest: "Emma, new arrivals in your favorite collection"
• Loyalty status: "Gold members get first access today"
• Recent browsing: "Still thinking about these headphones?"
• Recent purchase: "Complete your setup with these accessories"
• Location: "Ready for cooler weather in Seattle?"

Use dynamic rules such as:

IF abandoned_cart
    Subject = "Your items are waiting"
ELSE IF browsed_category
    Subject = "New arrivals in {favorite_category}"
ELSE IF loyalty_tier = Gold
    Subject = "Exclusive early access for Gold members"
ELSE
    Subject = "Products we picked just for you"

Product recommendation strategy

Combine several recommendation models rather than relying on a single algorithm.

1. Recently viewed

• Show products the customer viewed but didn't purchase.

2. Similar products

• Recommend items with similar attributes (brand, style, category, price).

3. Frequently bought together

• Suggest complementary products based on historical purchase patterns.

4. Personalized ranking
Score each product using signals such as:

• affinity to category
• recent browsing
• purchase history
• inventory availability
• popularity
• profit margin
• business priorities

Example scoring function:

Recommendation Score =
0.40 × Category Affinity +
0.30 × Recent Activity +
0.15 × Purchase Similarity +
0.10 × Popularity +
0.05 × Business Priority

Customer attributes to use

Useful profile data includes:

• First name
• Age group (where appropriate and compliant)
• Gender preference (if collected)
• Geographic location
• Loyalty tier
• Preferred brands
• Favorite categories
• Average order value
• Purchase frequency
• Customer lifetime value

Recent activity signals

Behavioral signals often outperform static profile data:

• Products viewed
• Searches performed
• Items added to cart
• Cart abandonment
• Purchases
• Email opens
• Email clicks
• Website visits
• Time since last purchase
• Time since last visit

End-to-end example

Customer

• Gold member
• Favorite category: Running
• Viewed three pairs of shoes yesterday
• Purchased socks last month

Subject line

Alex, new running shoes picked just for you

Email content

1. Recently viewed running shoes
2. Similar running shoes in stock
3. Matching performance apparel
4. Running socks and accessories
5. Gold member discount banner

Best practices

• Use behavioral data from the last 7–30 days to keep recommendations relevant.
• Fall back to best sellers or trending products if recent activity is sparse.
• Limit recommendations to 4–8 high-confidence products rather than showing many lower-quality options.
• Continuously A/B test subject lines and recommendation strategies, measuring open rate, click-through rate, conversion rate, and revenue per email.
• Respect user privacy and consent preferences, and avoid using sensitive personal attributes for personalization unless appropriate, compliant, and explicitly permitted.

This hybrid approach—combining customer attributes with recent behavior—typically delivers more relevant subject lines and product recommendations while remaining resilient when either profile or activity data is limited.

A strong approach is to combine attribute-based personalization (who the customer is) with behavior-based personalization (what they recently did). This typically produces better engagement than relying on either alone.

Subject line personalization strategy

Create a subject line using multiple signals instead of just inserting the customer's name.

Examples:

• Name + interest: "Emma, new arrivals in your favorite collection"
• Loyalty status: "Gold members get first access today"
• Recent browsing: "Still thinking about these headphones?"
• Recent purchase: "Complete your setup with these accessories"
• Location: "Ready for cooler weather in Seattle?"

Use dynamic rules such as:

IF abandoned_cart
    Subject = "Your items are waiting"
ELSE IF browsed_category
    Subject = "New arrivals in {favorite_category}"
ELSE IF loyalty_tier = Gold
    Subject = "Exclusive early access for Gold members"
ELSE
    Subject = "Products we picked just for you"

Product recommendation strategy

Combine several recommendation models rather than relying on a single algorithm.

1. Recently viewed

• Show products the customer viewed but didn't purchase.

2. Similar products

• Recommend items with similar attributes (brand, style, category, price).

3. Frequently bought together

• Suggest complementary products based on historical purchase patterns.

4. Personalized ranking
Score each product using signals such as:

• affinity to category
• recent browsing
• purchase history
• inventory availability
• popularity
• profit margin
• business priorities

Example scoring function:

Recommendation Score =
0.40 × Category Affinity +
0.30 × Recent Activity +
0.15 × Purchase Similarity +
0.10 × Popularity +
0.05 × Business Priority

Customer attributes to use

Useful profile data includes:

• First name
• Age group (where appropriate and compliant)
• Gender preference (if collected)
• Geographic location
• Loyalty tier
• Preferred brands
• Favorite categories
• Average order value
• Purchase frequency
• Customer lifetime value

Recent activity signals

Behavioral signals often outperform static profile data:

• Products viewed
• Searches performed
• Items added to cart
• Cart abandonment
• Purchases
• Email opens
• Email clicks
• Website visits
• Time since last purchase
• Time since last visit

End-to-end example

Customer

• Gold member
• Favorite category: Running
• Viewed three pairs of shoes yesterday
• Purchased socks last month

Subject line

Alex, new running shoes picked just for you

Email content

1. Recently viewed running shoes
2. Similar running shoes in stock
3. Matching performance apparel
4. Running socks and accessories
5. Gold member discount banner

Best practices

• Use behavioral data from the last 7–30 days to keep recommendations relevant.
• Fall back to best sellers or trending products if recent activity is sparse.
• Limit recommendations to 4–8 high-confidence products rather than showing many lower-quality options.
• Continuously A/B test subject lines and recommendation strategies, measuring open rate, click-through rate, conversion rate, and revenue per email.
• Respect user privacy and consent preferences, and avoid using sensitive personal attributes for personalization unless appropriate, compliant, and explicitly permitted.

This hybrid approach—combining customer attributes with recent behavior—typically delivers more relevant subject lines and product recommendations while remaining resilient when either profile or activity data is limited.

A strong approach is to combine rule-based personalization (for guaranteed business logic) with AI-driven ranking and subject line generation (for relevance and engagement). This gives you control while still adapting to each customer's behavior.

Recommended architecture

Personalizing subject lines

Use multiple signals instead of just the customer's first name.

Customer attributes

• First name
• Loyalty status
• Preferred category
• Geographic location
• Average order value
• Membership anniversary
• Preferred brand

Example:

Emma, your Gold rewards are waiting

or

New arrivals from Patagonia you'll love

Recent activity

• Recently viewed products
• Abandoned cart
• Recently purchased complementary item
• Wishlist additions
• Browsing frequency
• Price drop alerts

Examples:

Viewed running shoes:

Still thinking about those running shoes?

Added coffee machine to cart:

Your coffee machine is almost yours

Recently bought a camera:

Accessories picked just for your new camera

Combining both

Instead of using only one attribute:

{Name},
because you recently viewed {Category},
here are our top picks for {Preferred Brand}.

Example:

Sarah, since you loved Nike, here are our newest running arrivals

Product recommendation strategy

Use a layered ranking approach.

1. Behavioral recommendations

Based on

• recently viewed
• frequently viewed
• abandoned cart
• recent purchases

Weight these most heavily.

2. Attribute-based recommendations

Recommend based on

• gender
• size
• location
• season
• loyalty tier

Example

Customer in Colorado:

Recommend

• winter jackets
• hiking gear

Customer in Florida:

Recommend

• sandals
• beachwear

3. Collaborative filtering

Recommend products purchased by similar customers.

Example

Customers who bought

Noise-cancelling headphones

also bought

Travel case

4. Business rules

Override recommendations when necessary.

Examples

• Exclude out-of-stock products
• Exclude recently purchased items
• Prioritize high-margin inventory
• Promote seasonal campaigns

Example recommendation logic

Score =
0.40 × Recent Activity
+ 0.25 × Purchase History
+ 0.15 × Customer Preferences
+ 0.10 × Similar Customers
+ 0.10 × Business Priority

AI-generated subject lines

Provide the model with structured context such as:

{
  "customer_name": "Emily",
  "loyalty": "Gold",
  "favorite_category": "Running",
  "recent_activity": [
    "Viewed Nike Pegasus",
    "Added socks to cart"
  ],
  "recommended_products": [
    "Nike Pegasus 42",
    "Running Socks",
    "Hydration Belt"
  ],
  "campaign": "New arrivals"
}

Possible outputs:

• Emily, your running favorites just got an upgrade
• Gold members get first access to these running picks
• Complete your running kit today
• Your Nike favorites are back in stock
• Ready for your next run?

Best practices

• Keep subject lines under 40–60 characters for better mobile visibility.
• Limit personalization to one or two key signals to avoid sounding intrusive.
• Don't recommend products the customer recently purchased unless they're replenishable or have natural complements.
• Fall back gracefully when data is sparse (e.g., use trending products or category best sellers).
• Continuously A/B test subject lines, recommendation algorithms, and send times to improve engagement.

This hybrid strategy—using customer attributes for context, recent activity for intent, business rules for control, and AI for generating natural language—typically produces more relevant subject lines and higher-performing product recommendations than relying on any single personalization method.

A strong approach is to combine rule-based personalization (for guaranteed business logic) with AI-driven ranking and subject line generation (for relevance and engagement). This gives you control while still adapting to each customer's behavior.

Recommended architecture

Personalizing subject lines

Use multiple signals instead of just the customer's first name.

Customer attributes

• First name
• Loyalty status
• Preferred category
• Geographic location
• Average order value
• Membership anniversary
• Preferred brand

Example:

Emma, your Gold rewards are waiting

or

New arrivals from Patagonia you'll love

Recent activity

• Recently viewed products
• Abandoned cart
• Recently purchased complementary item
• Wishlist additions
• Browsing frequency
• Price drop alerts

Examples:

Viewed running shoes:

Still thinking about those running shoes?

Added coffee machine to cart:

Your coffee machine is almost yours

Recently bought a camera:

Accessories picked just for your new camera

Combining both

Instead of using only one attribute:

{Name},
because you recently viewed {Category},
here are our top picks for {Preferred Brand}.

Example:

Sarah, since you loved Nike, here are our newest running arrivals

Product recommendation strategy

Use a layered ranking approach.

1. Behavioral recommendations

Based on

• recently viewed
• frequently viewed
• abandoned cart
• recent purchases

Weight these most heavily.

2. Attribute-based recommendations

Recommend based on

• gender
• size
• location
• season
• loyalty tier

Example

Customer in Colorado:

Recommend

• winter jackets
• hiking gear

Customer in Florida:

Recommend

• sandals
• beachwear

3. Collaborative filtering

Recommend products purchased by similar customers.

Example

Customers who bought

Noise-cancelling headphones

also bought

Travel case

4. Business rules

Override recommendations when necessary.

Examples

• Exclude out-of-stock products
• Exclude recently purchased items
• Prioritize high-margin inventory
• Promote seasonal campaigns

Example recommendation logic

Score =
0.40 × Recent Activity
+ 0.25 × Purchase History
+ 0.15 × Customer Preferences
+ 0.10 × Similar Customers
+ 0.10 × Business Priority

AI-generated subject lines

Provide the model with structured context such as:

{
  "customer_name": "Emily",
  "loyalty": "Gold",
  "favorite_category": "Running",
  "recent_activity": [
    "Viewed Nike Pegasus",
    "Added socks to cart"
  ],
  "recommended_products": [
    "Nike Pegasus 42",
    "Running Socks",
    "Hydration Belt"
  ],
  "campaign": "New arrivals"
}

Possible outputs:

• Emily, your running favorites just got an upgrade
• Gold members get first access to these running picks
• Complete your running kit today
• Your Nike favorites are back in stock
• Ready for your next run?

Best practices

• Keep subject lines under 40–60 characters for better mobile visibility.
• Limit personalization to one or two key signals to avoid sounding intrusive.
• Don't recommend products the customer recently purchased unless they're replenishable or have natural complements.
• Fall back gracefully when data is sparse (e.g., use trending products or category best sellers).
• Continuously A/B test subject lines, recommendation algorithms, and send times to improve engagement.

This hybrid strategy—using customer attributes for context, recent activity for intent, business rules for control, and AI for generating natural language—typically produces more relevant subject lines and higher-performing product recommendations than relying on any single personalization method.

A strong approach is to combine rule-based personalization (for guaranteed business logic) with AI-driven ranking and subject line generation (for relevance and engagement). This gives you control while still adapting to each customer's behavior.

Recommended architecture

Personalizing subject lines

Use multiple signals instead of just the customer's first name.

Customer attributes

• First name
• Loyalty status
• Preferred category
• Geographic location
• Average order value
• Membership anniversary
• Preferred brand

Example:

Emma, your Gold rewards are waiting

or

New arrivals from Patagonia you'll love

Recent activity

• Recently viewed products
• Abandoned cart
• Recently purchased complementary item
• Wishlist additions
• Browsing frequency
• Price drop alerts

Examples:

Viewed running shoes:

Still thinking about those running shoes?

Added coffee machine to cart:

Your coffee machine is almost yours

Recently bought a camera:

Accessories picked just for your new camera

Combining both

Instead of using only one attribute:

{Name},
because you recently viewed {Category},
here are our top picks for {Preferred Brand}.

Example:

Sarah, since you loved Nike, here are our newest running arrivals

Product recommendation strategy

Use a layered ranking approach.

1. Behavioral recommendations

Based on

• recently viewed
• frequently viewed
• abandoned cart
• recent purchases

Weight these most heavily.

2. Attribute-based recommendations

Recommend based on

• gender
• size
• location
• season
• loyalty tier

Example

Customer in Colorado:

Recommend

• winter jackets
• hiking gear

Customer in Florida:

Recommend

• sandals
• beachwear

3. Collaborative filtering

Recommend products purchased by similar customers.

Example

Customers who bought

Noise-cancelling headphones

also bought

Travel case

4. Business rules

Override recommendations when necessary.

Examples

• Exclude out-of-stock products
• Exclude recently purchased items
• Prioritize high-margin inventory
• Promote seasonal campaigns

Example recommendation logic

Score =
0.40 × Recent Activity
+ 0.25 × Purchase History
+ 0.15 × Customer Preferences
+ 0.10 × Similar Customers
+ 0.10 × Business Priority

AI-generated subject lines

Provide the model with structured context such as:

{
  "customer_name": "Emily",
  "loyalty": "Gold",
  "favorite_category": "Running",
  "recent_activity": [
    "Viewed Nike Pegasus",
    "Added socks to cart"
  ],
  "recommended_products": [
    "Nike Pegasus 42",
    "Running Socks",
    "Hydration Belt"
  ],
  "campaign": "New arrivals"
}

Possible outputs:

• Emily, your running favorites just got an upgrade
• Gold members get first access to these running picks
• Complete your running kit today
• Your Nike favorites are back in stock
• Ready for your next run?

Best practices

• Keep subject lines under 40–60 characters for better mobile visibility.
• Limit personalization to one or two key signals to avoid sounding intrusive.
• Don't recommend products the customer recently purchased unless they're replenishable or have natural complements.
• Fall back gracefully when data is sparse (e.g., use trending products or category best sellers).
• Continuously A/B test subject lines, recommendation algorithms, and send times to improve engagement.

This hybrid strategy—using customer attributes for context, recent activity for intent, business rules for control, and AI for generating natural language—typically produces more relevant subject lines and higher-performing product recommendations than relying on any single personalization method.

A good solution is a real-time personalization layer that combines customer attributes with recent behavioral events, then feeds those signals into both subject-line generation and product-ranking models.

Recommended architecture

1. Unified customer profile
Combine relatively stable attributes such as:

• Location, language, customer tier
• Purchase history and categories
• Price sensitivity
• Lifecycle stage
• Stated preferences

with behavioral signals such as:

• Products viewed recently
• Searches
• Cart additions/abandons
• Purchases and returns
• Email opens/clicks
• Recency and frequency of engagement

2. Feature + decisioning layer
Create features such as:

• days_since_last_purchase
• views_last_7_days
• favorite_category
• cart_items_last_24h
• discount_affinity
• recent_product_interest

Use these to determine what product to recommend and what message angle to use.

3. Product recommendation engine
Start with a hybrid approach:

• Collaborative filtering for "customers like you"
• Content-based recommendations for product/category affinity
• Recent-activity weighting so current intent dominates older behavior
• Business rules for inventory, margin, eligibility, and exclusions

A useful scoring formulation is:

recommendation_score = behavioral_affinity × recency_weight × customer_fit × business_constraints

4. Subject-line personalization
Rather than letting an LLM independently invent subjects, give it structured inputs from the decisioning layer:

Customer: high-value, returning customer
Recent activity: viewed running shoes 3 times this week
Recommendation: running shoe X
Preferred category: running
Discount affinity: high
Objective: maximize click-through

The LLM can then generate several subject-line candidates, while a ranking model chooses among them based on predicted engagement.

5. Continuous learning
Log impressions, opens, clicks, purchases, unsubscribes, and recommendation conversions. Use those outcomes for experimentation and model retraining.

Practical stack

For an initial implementation, I'd use:

Customer/event data → warehouse/CDP → feature store → recommendation/ranking service → LLM subject-line generator → email platform

Keep customer data and behavioral signals in your own controlled data layer, and send the personalization service only the minimum information needed for generation.

Important design choice

I'd avoid making the LLM the recommendation engine. Let a deterministic/ML ranking system decide what to recommend, and use the LLM primarily for how to express the recommendation. This gives you much better control over relevance, inventory, compliance, and measurable experimentation.

If you're building this for an existing email stack, the next step would be to map this architecture onto your specific CRM/email platform and data warehouse.

A strong approach is to combine rule-based personalization (for guaranteed business logic) with AI-driven ranking and subject line generation (for relevance and engagement). This gives you control while still adapting to each customer's behavior.

Recommended architecture

Personalizing subject lines

Use multiple signals instead of just the customer's first name.

Customer attributes

• First name
• Loyalty status
• Preferred category
• Geographic location
• Average order value
• Membership anniversary
• Preferred brand

Example:

Emma, your Gold rewards are waiting

or

New arrivals from Patagonia you'll love

Recent activity

• Recently viewed products
• Abandoned cart
• Recently purchased complementary item
• Wishlist additions
• Browsing frequency
• Price drop alerts

Examples:

Viewed running shoes:

Still thinking about those running shoes?

Added coffee machine to cart:

Your coffee machine is almost yours

Recently bought a camera:

Accessories picked just for your new camera

Combining both

Instead of using only one attribute:

{Name},
because you recently viewed {Category},
here are our top picks for {Preferred Brand}.

Example:

Sarah, since you loved Nike, here are our newest running arrivals

Product recommendation strategy

Use a layered ranking approach.

1. Behavioral recommendations

Based on

• recently viewed
• frequently viewed
• abandoned cart
• recent purchases

Weight these most heavily.

2. Attribute-based recommendations

Recommend based on

• gender
• size
• location
• season
• loyalty tier

Example

Customer in Colorado:

Recommend

• winter jackets
• hiking gear

Customer in Florida:

Recommend

• sandals
• beachwear

3. Collaborative filtering

Recommend products purchased by similar customers.

Example

Customers who bought

Noise-cancelling headphones

also bought

Travel case

4. Business rules

Override recommendations when necessary.

Examples

• Exclude out-of-stock products
• Exclude recently purchased items
• Prioritize high-margin inventory
• Promote seasonal campaigns

Example recommendation logic

Score =
0.40 × Recent Activity
+ 0.25 × Purchase History
+ 0.15 × Customer Preferences
+ 0.10 × Similar Customers
+ 0.10 × Business Priority

AI-generated subject lines

Provide the model with structured context such as:

{
  "customer_name": "Emily",
  "loyalty": "Gold",
  "favorite_category": "Running",
  "recent_activity": [
    "Viewed Nike Pegasus",
    "Added socks to cart"
  ],
  "recommended_products": [
    "Nike Pegasus 42",
    "Running Socks",
    "Hydration Belt"
  ],
  "campaign": "New arrivals"
}

Possible outputs:

• Emily, your running favorites just got an upgrade
• Gold members get first access to these running picks
• Complete your running kit today
• Your Nike favorites are back in stock
• Ready for your next run?

Best practices

• Keep subject lines under 40–60 characters for better mobile visibility.
• Limit personalization to one or two key signals to avoid sounding intrusive.
• Don't recommend products the customer recently purchased unless they're replenishable or have natural complements.
• Fall back gracefully when data is sparse (e.g., use trending products or category best sellers).
• Continuously A/B test subject lines, recommendation algorithms, and send times to improve engagement.

This hybrid strategy—using customer attributes for context, recent activity for intent, business rules for control, and AI for generating natural language—typically produces more relevant subject lines and higher-performing product recommendations than relying on any single personalization method.

I’d recommend a hybrid real-time personalization stack: use structured ML for product recommendations and an LLM for subject-line generation, with both driven by the same customer profile and recent-activity features.

Recommended architecture

1. Build a unified customer profile
Combine relatively stable attributes with behavioral signals:

• Customer attributes: location, lifecycle stage, loyalty tier, preferences, price sensitivity
• Recent activity: products viewed, searches, purchases, cart additions, email clicks, category affinity
• Context: device, channel, time since last activity, current campaign

Keep these features in a customer data platform/warehouse and expose a low-latency profile to your marketing system.

2. Product recommendations: use a recommendation model
Rather than asking an LLM to choose products, use a recommender optimized for ranking:

customer + recent events → candidate generation → ranking → top 3–10 products

A good starting point is a hybrid model combining:

• Collaborative filtering ("customers like you bought...")
• Content similarity ("you recently viewed running shoes...")
• Business rules (inventory, margin, eligibility, exclusions)
• Recency weighting so yesterday's behavior matters more than six-month-old behavior

This gives you measurable recommendation quality and avoids hallucinated products.

3. Subject lines: use an LLM with structured inputs
Give the LLM the campaign objective plus selected customer features and recommendation context, e.g.:

Customer:
- Lifecycle: returning customer
- Preferred category: running
- Recently viewed: trail shoes
- Last purchase: 45 days ago

Campaign:
- Goal: drive a second purchase
- Recommended products: [A, B, C]

Generate 5 subject lines.
Constraints:
- Don't mention attributes that could feel sensitive
- Don't claim a discount unless provided
- Maximum 50 characters
- Match brand voice

Then use an experimentation layer to determine which variants actually perform best.

The important part: personalize jointly

Instead of independently generating a subject line and recommendations, pass the recommendation context into subject-line generation.

For example:

"Still thinking about the trails?"
→ Trail shoes ranked highly because the customer recently viewed them.

versus a generic:

"New products you'll love"

This makes the personalization feel coherent rather than like two separate systems.

Production flow

Customer events
      ↓
Customer profile + behavioral features
      ↓
 ┌───────────────┬────────────────┐
 ↓               ↓                ↓
Recommendation  Audience/        Eligibility
model           segmentation      rules
 ↓               ↓
Top products ──────────→ LLM subject-line generator
                              ↓
                       Safety/brand checks
                              ↓
                       Email/SMS campaign
                              ↓
                    Opens/clicks/purchases
                              ↓
                         Experimentation
                              ↺

What I'd implement first

For an initial version, I'd avoid an overly complicated AI platform:

1. Warehouse/CDP for customer profiles and events.
2. Recommendation service using behavioral + product features.
3. LLM service for subject-line variants, constrained by structured campaign data.
4. Rules/guardrails for privacy, inventory, pricing, frequency caps, and brand voice.
5. A/B or multi-armed-bandit experimentation to continuously measure incremental revenue rather than optimizing just opens.
6. Real-time event ingestion so a product viewed five minutes ago can influence the next message.

The key design principle is LLM for language, ML for ranking. Let the recommender decide what to show and let the LLM decide how to talk about it. That tends to be more controllable, measurable, and scalable than putting the entire personalization decision into an LLM.

A strong solution is a real-time personalization layer that feeds both email subject-line generation and product recommendations from the same customer profile.

Recommended architecture

1. Unified customer profile
Combine:

• Demographics and preferences
• Purchase history and customer lifecycle stage
• Recent browsing/search activity
• Products viewed, carted, or purchased
• Email engagement
• Context such as device, location, and time

Store both relatively stable attributes and recent behavioral events.

2. Feature + decisioning layer
Create features such as:

• days_since_last_purchase
• categories_viewed_7d
• products_viewed_24h
• cart_items
• preferred_category
• price_affinity
• email_engagement_score

Then use a decision engine to determine the customer's current intent.

3. Product recommendations
Start with a hybrid recommender:

• Behavioral: "customers who viewed/bought X also liked Y"
• Content-based: match products to categories/brands the customer recently interacted with
• Personalized ranking: rerank candidates using customer attributes, recency, price affinity, inventory, and business rules

For example:

Customer recently viewed running shoes + historically buys athletic apparel → recommend complementary running socks and apparel, rather than generic best sellers.

4. Subject-line personalization
Use the same features but constrain the output to a small set of tested templates rather than letting an LLM freely invent marketing copy.

Examples:

• "Still thinking about {{product}}?"
• "New {{category}} picks for you"
• "Your {{category}} favorites are back"
• "Complete your {{product}} setup"

A model can select or fill the best template based on predicted open/click probability.

5. Continuous experimentation
Run A/B or multi-armed-bandit experiments on:

• Personalized vs. generic subject lines
• Different recommendation strategies
• Degree of personalization
• Send timing

Optimize for incremental revenue/conversion, not merely opens.

A practical MVP

Customer events
      ↓
Customer profile + recent-activity features
      ↓
 ┌───────────────┬────────────────┐
 │               │                │
Subject-line   Candidate        Business
model          recommender      rules
 │               │                │
 └───────┬───────┴────────────────┘
         ↓
   Personalized email
         ↓
  Click / purchase events
         ↓
       Feedback

I'd implement the first version with rules + a recommender model + a lightweight ML ranking model, then add an LLM specifically for controlled subject-line generation. This tends to be easier to evaluate, safer for brand voice, and less expensive than putting an LLM directly in the entire personalization loop.

If you're choosing a concrete stack, I can also recommend an architecture using Snowflake/Databricks + a CDP + a recommendation service + an LLM, including the data model and APIs.