Mira

A sender Mira advised had implemented merge-field personalization for the first time. The team was excited. They'd integrated their CRM with their ESP, set up first-name personalization in subject lines and greetings, and prepared a major campaign launch.

Mira ran a data quality check before the send. She found that approximately 12% of the subscriber records had last names populated into the first-name field, due to a bad data import from a previous system. Subject lines for those subscribers would render as "Dear Smith" or "Dear Patel" or "Dear Williams." Greetings would do the same. The 12% would receive obviously broken personalization in their inbox.

She told the team to either fix the data or remove the personalization for the affected subscribers before sending. The marketing director didn't want to delay the campaign. He told her the 12% probably wouldn't even notice.

She held the line. She showed him historical data on what happened to senders who let broken merge fields fire. Complaint rates spiked. Unsubscribe rates spiked. Subscribers who saw obviously wrong personalization felt deceived in a way that random batched emails didn't trigger. The 12% would notice. They always do.

The director eventually agreed to a compromise: send the personalized version to the 88% with clean data, send a non-personalized fallback to the 12%. The data team was given two weeks to clean the records before the next personalized send.

The campaign went out. The 88% had a normal complaint rate (~0.04%). The 12% had a slightly elevated complaint rate (~0.08%, because some subscribers prefer personalization and felt they'd received less). The combined campaign performance was good.

The team then ran a thought experiment: what would have happened if the original "send to all" plan had gone forward? Based on industry benchmarks for broken-merge-field campaigns, complaint rates on the 12% would have been around 1-2%. Across the full list, the campaign-level complaint rate would have been 0.15% to 0.3%. That would have triggered Gmail and Yahoo's deliverability degradation thresholds. Future campaigns would have been delivered to spam at higher rates for weeks.

The lesson she teaches now: wrong > absent every time. A wrong name in a subject line is worse than no name. Personalization works when the data is correct. When it isn't, the personalization actively hurts the relationship. Verify the data before firing the merge.

---

A B2B SaaS sender was running their Q4 holiday campaign with a single global send time of Tuesday 10 AM Eastern. They'd been doing it that way for years. Open rates were stable around 24%.

Mira proposed implementing send-time personalization for the holiday campaign. Each subscriber would receive the email at their individual best send time, based on past engagement data. The implementation cost was a few hours of engineering work plus a bump in the ESP plan.

The marketing director was skeptical. They'd been doing the Tuesday 10 AM thing for years. Why change now?

Mira ran an A/B test. Half the list got the holiday campaign at Tuesday 10 AM Eastern. Half got it at their individually optimized send time, which varied from subscriber to subscriber across all hours and weekdays.

The Tuesday 10 AM cohort opened at 24%, in line with baseline. The personalized cohort opened at 36%. Click-through rates ran 18% higher in the personalized cohort. The conversion rate (subscribers booking a demo) ran 12% higher.

The lift on the personalized version produced enough additional revenue to pay for the implementation cost in the single campaign. The lift in subsequent quarters paid for the ongoing send-time-personalization feature in perpetuity.

The lesson she teaches now: personalization at the timestamp level matters as much as personalization at the content level. The same email, sent to the same subscriber, performs differently at different times. Aggregate "best send time" is an average. Per-subscriber best send time is the actual answer for each subscriber. Tools that automate this exist. The lift is real. Most senders haven't enabled it yet.

Mira's intro:

A passenger named Mrs. Henderson sailed twice a year on the line where I worked as a young steward. The ship's official system knew her cabin number and her birthday. It didn't know that she liked mint tea in the morning, that she still kept a small chess set in her cabin to think with after her husband passed, or that the daily ship newspaper was the only morning correspondence she actually wanted. I learned all of that from paying attention. I wrote it down in a small leather notebook. Six months later, when she returned, those things were waiting for her. The system knew her birthday. It didn't know about the tea. That's the difference. That's what personalization actually is.

---

Personalization is the discipline of treating each subscriber as the specific person they are, not as a record in a database.

Most senders think of personalization as merge fields. "Hi {{FirstName}}." "Welcome back to {{City}}." "Your last order from {{LastPurchaseDate}}." All of these are personalization features in the sense that they fire individually per subscriber. None of them are personalization in the sense that matters.

Real personalization is being correct about someone. Knowing that Mrs. Henderson likes mint tea, not chamomile. Knowing that Mr. Choi reads on Sunday evenings, not Tuesday mornings. Knowing that Sarah's daughter started college this year, so the "back-to-school for parents" content might land differently than the "back-to-school for kids" content. These are facts about the person that the standard merge fields don't capture, but that distinguish a personalized email from a batched one.

Three layers, in order of difficulty.

Layer one: identity data

Identity data is the basic stuff a subscriber gave you at signup or that you've inferred from their account. First name. Email address. Country. Birthday if they shared it. Plan tier if you have one. The fields you might use in merge tags.

This layer is the easiest to use and the most-overused. Senders do "Hi {{FirstName}}" personalization and call it done. The lift from first-name personalization in subject lines is real (5-10% open rate increase for B2C, neutral or negative for B2B), but it's also limited. A subscriber who's been called "{{FirstName}}" by every brand they've subscribed to is no longer wowed by it. The novelty is gone.

The value of identity data isn't in the surface-level usage. It's in segmentation and routing. Knowing the subscriber is in Tokyo means you send at a Tokyo-friendly time, not at 9 AM Eastern. Knowing they're on the Pro plan means you don't show them upsell ads for Pro features. Knowing their industry means you tailor case studies to their context. Identity data is most useful when it's used to make decisions, not when it's used as filler in subject lines.

Layer two: behavioral data

Behavioral data is what the subscriber has actually done. What they've opened, clicked, replied to, bought, ignored. What pages they've visited on your site. What products they've abandoned in the cart. What support tickets they've filed.

Behavioral data is the richest source of personalization signal because past behavior predicts future behavior more reliably than any demographic ever will. Someone who's clicked on three product-update emails wants product updates. Someone who's only ever clicked on storytelling content wants stories. Someone who's bought hiking gear in the past is more likely to buy hiking gear in the future than someone who hasn't, regardless of their age, zip code, or stated preferences.

The mistake most senders make is collecting behavioral data and not using it. The data sits in the analytics platform, generating reports nobody reads, while the marketing emails go out as flat blasts. Connecting the behavioral data to the email content is the work.

Practical examples: - A subscriber who clicked on three articles about a specific topic in the last 90 days gets the next article on that topic featured in their next email - A subscriber who's looked at a product page three times in the last week but hasn't bought gets a soft email with information about that product - A subscriber who's been engaged for two years but hasn't opened in the last 30 days gets a re-engagement attempt before being suppressed

This is personalization at the level that matters. The merge field is a tag. The behavioral signal is a relationship.

Layer three: contextual data

Contextual data is what's true at the moment of send. The subscriber's local time. Their device. Whether they've engaged with a previous send in the same campaign. Whether the weather in their city is rainy or sunny. Whether there's a major event in their location.

Contextual data is the hardest layer to use well, because it requires real-time integration that most ESPs don't natively support. But the lift when it's done correctly can be significant.

Examples: - Send-time personalization: each subscriber gets the email at their personal best moment, not a global "best time" - Weather-aware content: a clothing retailer shows raincoats to subscribers in cities currently raining, sunglasses to those in sunny cities - Event-aware content: a sports retailer adjusts content based on the user's local team's recent performance - Behavioral chaining: if the subscriber clicked on email one of a series, send email two; if they didn't, send a re-engagement variant

This layer is more advanced and most senders shouldn't start here. But the senders at scale who get this layer right see the largest lifts. The full personalization stack is identity + behavior + context working together.

What personalization isn't

A few common confusions worth correcting.

It isn't merge fields alone. Merge fields are a mechanic. Personalization is the discipline of using the right data correctly. A merge field with bad data is worse than no merge field. (See article 2.)

It isn't segmentation. Segmentation is grouping subscribers into buckets and sending different content to each bucket. Personalization is making individual sends feel addressed to a specific person within their bucket. They work together. They aren't the same.

It isn't surveillance. Personalization that knows too much can read as creepy. The line between "I see you've shown interest in this product" and "I see you visited this page at 2:47 AM from your phone" matters. Use the data the subscriber would expect you to use. Don't reveal that you have data they didn't realize they were sharing.

It isn't a one-time setup. Personalization data drifts. Subscribers' interests change. Their addresses change. Their preferences shift. Personalization that worked a year ago might be wrong now. The discipline is ongoing.

Where to start

If you've never run personalization beyond first-name merges, three steps to begin.

One, build a behavioral data flow into your ESP. Most modern ESPs (Klaviyo, Brevo, ActiveCampaign, etc.) have integrations with ecommerce platforms and analytics tools. Connect them. The data starts flowing automatically.

Two, build one or two simple segments based on behavior. Engaged vs Stale. Recently-purchased vs Browsed-but-didn't-buy. New subscriber vs Long-term. Send slightly different versions of your campaigns to each.

Three, run data quality checks before every personalized send. Verify that merge fields aren't broken. Verify that the behavioral data is current. Catch the misnames before they fire. (Article 2 has the full version of this.)

That's the foundation. Send-time personalization, dynamic content blocks, predictive next-best-content all build on top.

The system knows the birthday. The thoughtful purser knows about the tea. Be the thoughtful purser.

- Mira

Mira's intro:

A sender I advised had implemented merge-field personalization for the first time. They were excited. The data was bad. About 12% of their records had last names populated into the first-name field. Subject lines for those subscribers would have read "Dear Smith" or "Dear Patel" instead of "Dear Sarah." The marketing director didn't want to delay the campaign. He told me the 12% probably wouldn't notice. They always notice. Here's why broken merge fields cost more than no personalization at all, and how to make sure the data is honest before you fire.

---

The most common personalization failure isn't that the personalization is too aggressive or too creepy. It's that the personalization is wrong. Wrong first names. Wrong cities. Wrong product recommendations based on data that wasn't accurate when it was collected. Wrong language because the subscriber's locale field was set incorrectly.

In every case, the wrong personalization is worse than the missing personalization would have been. A subscriber who reads "Hi {{FirstName}}, welcome back" because the merge field broke is worse off than a subscriber who reads "Hi there, welcome back" with no personalization attempt at all.

The reason is trust. A subscriber who sees obviously broken personalization realizes two things at once:

One, the sender tried to address them personally. This is a small positive signal.

Two, the sender failed to address them correctly. This is a larger negative signal. It tells the subscriber that the sender's data about them is wrong, that the sender didn't bother to verify before sending, and that the sender's "personalization" is performative rather than thoughtful.

The negative signal is bigger than the positive. The net effect is worse than no attempt would have been.

The specific failures

Three types of personalization failures, in order of how often they happen.

Type one: broken merge fields. The placeholder ("{{FirstName}}" or "[FNAME]") fires literally because the data is missing or the merge syntax broke. The subscriber sees "Hi FNAME" or "Hi [FirstName]" or some variation. This is a known failure mode and most ESPs have fallback handling for it (showing "friend" or "there" instead of empty), but the fallback only works if it's configured correctly. Many senders never configure it.

Type two: wrong-data merge fields. The placeholder fires with data that's technically there but incorrect for the field. Last name in first-name slot. Old address in current-address slot. Outdated product recommendations based on purchases from years ago. Wrong gendered language because the gender field was never updated. The merge fires. The output is wrong.

Type three: stale behavioral data. The personalization fires with data that was correct at some point but isn't anymore. "Welcome back, we noticed you're still interested in [product]" sent to a subscriber who bought that product 18 months ago and isn't interested anymore. "You haven't logged in in a while" sent to a subscriber who logged in this morning but the data hasn't synced. The personalization is technically correct based on the data, but the data is stale, and the subscriber feels misunderstood.

Why senders ship broken personalization anyway

Three reasons.

Reason one: nobody ran the data quality check. The team set up merge fields, didn't verify the underlying data was clean, and shipped. The 12% with broken data fire as wrong on every send.

Reason two: the team thought "good enough" was good enough. A 88% accuracy rate sounds high. It feels like the win is worth the few losses. Then the campaign-level complaint rate shows up at 0.15% (above the safe threshold) because that 12% mostly hit the spam button.

Reason three: the team didn't know how to test. They didn't have a test process for merge fields. They sent the campaign to themselves and saw the merge fields fire correctly for their own records. They didn't realize that other records had different data shapes.

In all three cases, the fix is process. Data quality checks. Test sends to a representative sample. Fallback handling configured. The work is mechanical and unglamorous, and the senders who do it ship clean personalization.

The data quality discipline

The minimum viable check before any personalized send:

Step one: pull a sample of records. A few hundred records, randomly selected from the segment you're sending to. Include the merge fields you'll be using.

Step two: scan for obvious errors. Are first-name fields populated with first names, not last names? Are city fields populated with cities, not countries? Are merge values lowercase, properly capitalized, or all-caps in inappropriate ways?

Step three: identify percentage of broken records. What share of the sample has a problem? If it's under 0.5%, you're probably fine to send. If it's higher than 1%, you need to fix data or remove personalization for the affected records.

Step four: configure fallback handling. Whatever ESP you're using, set the fallback for empty merge fields to a sensible default. "Hi friend" beats "Hi" beats "Hi {{FirstName}}". Test the fallback by sending to a record with empty first-name field.

Step five: test against representative records. Send the campaign as a test to records with: clean data, missing data, edge-case data (very long names, names with special characters, etc.). Verify the email renders correctly in all cases.

This takes about 30-60 minutes per personalized send. It catches roughly 90% of the failures that would otherwise ship to subscribers.

What to do when you find broken data

If your data quality check finds significant broken records, three options:

Option one: fix the data before sending. This is the right answer when the data is fixable. Pull the broken records into a spreadsheet, correct them, re-import. Time-consuming but durable.

Option two: send the personalized version to clean records, fallback to non-personalized for broken records. This is the right answer when fixing is too time-consuming. Most ESPs let you segment based on whether merge fields are populated. Send the personalized version to "first_name is not null AND first_name does not contain numbers." Send the fallback to everyone else.

Option three: skip personalization for this send entirely. This is the right answer when both the data and the time are bad. Send a non-personalized version to everyone. Schedule data cleanup before the next send.

What is NOT an option: shipping the personalization to everyone and hoping the broken 12% won't notice. They will. The complaint rate spike will hit the entire list's deliverability.

The compounding cost of one bad send

A single send with a 0.5% complaint rate (which is what broken merge fields can produce on the affected segment, scaled to the full list) damages domain reputation in measurable ways.

Mailbox providers see the spike. They flag the domain. Inbox placement on subsequent sends drops. The drop persists for 4-12 weeks even after subsequent sends are clean.

So one broken-personalization send can cost a quarter of inbox placement performance on the next ten sends. The math on "we'll just ship it" is actually "we'll just ship it and pay for it for the next two months."

The data quality check that costs 30 minutes prevents the deliverability damage that costs months.

Where to start

If you've never run a data quality discipline on personalization, three steps:

One, audit your existing data. Pull a sample. Find the broken records. Document the failure modes (last names in wrong field, blank values, etc.).

Two, build a pre-send check process. Add it as a step in your campaign launch checklist. Make it required, not optional.

Three, configure fallback handling for every merge field you use. The fallback is the safety net that catches the failures the check missed.

That's the foundation. Personalization works when the data is correct. The work is making sure the data is correct.

The right name in the subject line beats the wrong name every time. The honest greeting beats the personalized lie. Build the discipline. The trust compounds.

- Mira

Mira's intro:

Two subscribers join a fitness apparel newsletter on the same day. Same age, same zip code, same stated interest in "running." Six months later, one subscriber has clicked on every email about ultramarathon training and ignored everything about casual jogging. The other has clicked on every email about beginner-friendly gear and ignored everything intense. They are demographically identical. They are behaviorally completely different. The senders who treat them as the same subscriber are leaving a lot on the table. The senders who use behavioral data treat them as two different subscribers, which they actually are.

---

Personalization data comes in three flavors: identity (who someone is), behavioral (what they've done), and contextual (what's true at the moment of send). Most senders rely heavily on identity data and barely use behavioral data. The senders who flip the ratio see the largest performance gains.

The reason is simple: past behavior predicts future behavior more reliably than any demographic does.

A subscriber who clicked on three articles about a specific topic in the last 90 days is more likely to click on the next article about that topic than a subscriber who matches a demographic profile but has never engaged with that topic. The clicks are the signal. The demographics are a guess.

Behavioral personalization is the practice of using past behavior as the primary input for what to send next.

What counts as behavioral data

Three categories.

Email engagement signals: opens, clicks, replies, time since last engagement. These are usually available in your ESP without any extra setup. They tell you who's actively engaged and what content they've engaged with.

Site/app behavior signals: pages visited, products viewed, items added to cart, items abandoned, content read, time spent on specific pages. These come from your analytics platform or your product. Connecting them to your ESP requires integration but is usually one-time setup.

Transactional signals: purchases made, refunds requested, support tickets filed, plan upgrades, downgrades. These come from your commerce platform or CRM. Often the highest-value signal because they're tied directly to revenue.

The three categories overlap. A subscriber who clicked an email link, viewed the product page three times, and then bought is sending all three signals about the same intent. The richest behavioral data combines all three.

Why behavioral beats demographic

Demographic personalization sounds intuitive: target the email to the subscriber's age, gender, location, or stated preferences. The problem is that demographics are weak predictors of email behavior.

Two examples:

The age proxy fails. A 35-year-old and a 65-year-old both subscribe to a fitness newsletter. The 35-year-old hasn't engaged in 90 days. The 65-year-old opens every email and clicks regularly. Demographically, the 35-year-old is the "ideal" target audience. Behaviorally, the 65-year-old is. Sending the same campaign to both based on age would underperform.

The gender proxy fails. A retail brand assumes male subscribers want men's products and female subscribers want women's. A subscriber's recorded gender is "female." She has bought four men's gifts in the last year (presumably for her partner). She has clicked on every men's-product email. She has ignored women's-product emails for months. Gender-based personalization would send her women's content. Behavioral personalization would send her men's content. The behavioral version converts.

The demographic data isn't useless, but it's a weak proxy. Behavioral data is the stronger signal in almost every case.

Practical behavioral personalization patterns

Three patterns I use most.

Pattern one: content topic affinity. Tag your content by topic. Track which topics each subscriber has engaged with. Send more of what they engage with, less of what they don't. The simplest version: every link click logs the topic. The subscriber's topic affinity is the topic distribution of their last 10-20 clicks. The next email's content prioritizes their top affinity topics.

Pattern two: lifecycle-stage triggered content. Tie sends to behavioral milestones, not just calendar dates. A subscriber who just made their first purchase gets the post-purchase welcome. A subscriber who's hit their 10th purchase gets a loyalty acknowledgment. A subscriber who hasn't engaged in 60 days gets the re-engagement attempt. Each trigger fires based on their specific behavior, not a calendar.

Pattern three: abandoned-action recovery. A subscriber who started something but didn't finish gets a follow-up. Cart abandonment is the classic example. So is form abandonment, content download abandonment, and trial signup abandonment. The recovery email's job is to address the friction that prevented completion.

These three patterns produce more revenue than most demographic personalization tactics combined. The implementation cost is moderate (mostly integration work between your tools). The lift is real and durable.

How to capture behavioral data

If you don't already have behavioral data flowing into your ESP, three integrations to set up.

One: ecommerce integration. Your ESP probably has a native integration with Shopify, WooCommerce, BigCommerce, or whatever platform you use. Turn it on. Order data, abandoned carts, product views, and customer lifetime value start flowing automatically.

Two: site behavior tracking. Tools like Klaviyo and ActiveCampaign have site-tracking scripts you embed on your website. They tell the ESP when subscribers visit specific pages. Useful for triggering page-based emails ("you looked at this product three times, want a closer look?").

Three: app event tracking. If you have a product app, send key events to your ESP via API or webhook. Account creation, feature usage, plan changes. These events trigger behavioral campaigns.

The setup is one-time. The data flow is automatic after.

What behavioral data tells you about each subscriber

Once the data is flowing, you can ask questions like:

- What topics has this subscriber engaged with most in the last 90 days? - What's their last-engaged date? What does the engagement-time pattern look like? - What stage are they in (new, engaged, at-risk, lapsed)? - What products or content categories have they shown interest in but never converted on? - What's their typical send-time engagement pattern?

Each answer is the basis for a personalization decision. The decisions stack. A single subscriber can be: - Top topic affinity: hiking gear - Lifecycle stage: engaged, post-purchase - Behavioral stage: cart abandoner from this morning - Send-time pattern: opens at 7:30 AM Pacific

The next email this subscriber gets should be: hiking-gear focused, post-purchase oriented, with a soft mention of the cart they abandoned, sent at 7:30 AM Pacific. That's behavioral personalization at four overlapping layers, and it's the kind of email that produces 5-10x the engagement of a flat batch.

What this isn't

A few clarifications.

It isn't surveillance. Using behavioral data the subscriber would expect (their interactions with your brand) is fine. Tracking them across the open web and stitching together a creepy profile crosses a line. Stay within your own data.

It isn't predictive AI necessarily. Most behavioral personalization is rule-based, not AI-based. "If subscriber clicked on hiking content in the last 90 days, prioritize hiking content in the next send." Simple rules cover most of the value. AI is a layer on top, not a replacement.

It isn't unlimited data. Behavioral data has limits. A subscriber's recent behavior is a strong signal. A subscriber's behavior from two years ago is mostly noise. Use recent windows (30/60/90 day) for active personalization.

Where to start

If you're new to behavioral personalization, three steps:

One, set up one behavioral integration (likely ecommerce or site tracking, depending on your business). Get the data flowing. Don't act on it yet.

Two, after 30-60 days of data, build one behavioral segment. Start with topic affinity or recent-purchase recency. Run one campaign personalized for that segment alongside a flat campaign for everyone else.

Three, measure. The behavioral campaign should outperform the flat one on engagement and revenue per send. If it does, expand. If it doesn't, investigate the data quality before assuming the technique doesn't work.

That's the foundation. Behavioral personalization is the largest underused lever in most email programs. The senders who figure it out outperform the senders who don't, by margins that compound over years.

What people did says more about who they are than what they wrote in the signup form. Listen to the doing.

- Mira