Win-Back Campaigns with Segment

Why Win-Back Campaigns Fail Before They Start

Most win-back campaigns underperform because they operate on incomplete data. You send a re-engagement email to someone who churned six months ago, but you don't know *why* they left, what they last did in your product, or whether they've already returned through a different channel. The message lands flat, and you've wasted a send.

Segment solves the upstream problem. Before you can run a win-back campaign worth running, you need a clean, unified view of each churned user — their last active date, the features they used, the point where engagement dropped, and their historical value. Segment is where that picture gets built.

This guide walks through how to structure that work inside Segment and connect it to the tools that send the actual campaigns.

---

Define "Churned" Before You Build Anything

The most common mistake is treating churn as a single, binary state. It isn't. You need to define churn segments before you create audiences, or you'll be targeting the wrong people with the wrong message.

Three churn tiers worth building:

• Recently lapsed (15–30 days inactive): Still reachable with a light-touch re-engagement. High recovery rate.
• Churned (31–90 days inactive): Needs a stronger hook — a discount, a new feature announcement, or a compelling reason to return.
• Deeply churned (90+ days inactive): Lower ROI to pursue broadly. Narrow to high-LTV accounts only.

In Segment, you'll define these using Computed Traits and Audiences inside Segment Engage (formerly Personas). The logic is event-driven: you're measuring the gap between `current_date` and the user's last qualifying event (login, purchase, feature interaction — whatever signals active use in your product).

---

Step-by-Step Implementation in Segment

Step 1: Confirm Your Event Tracking Is Complete

Win-back audiences are only as reliable as the events feeding them. Before building anything in Engage, audit your event schema.

You need, at minimum:

• A session start or login event with a timestamp
• A core action event (whatever constitutes meaningful engagement — a purchase, a document created, a project updated)
• A subscription or plan event if you're SaaS

Use Segment's Source Debugger to confirm these events are firing and carrying the right properties. If `user_id` isn't consistently populated across web, mobile, and server sources, your audience counts will be off. Fix identity resolution first using Identity Resolution in Engage — merge anonymous and known profiles before you build a single audience.

Step 2: Create Computed Traits for Churn Signals

In Engage > Computed Traits, build the following:

• `days_since_last_active` — Count of days between today and the most recent qualifying event. Use an "Aggregation" trait with a max timestamp.
• `lifetime_order_count` or `lifetime_sessions` — Establishes baseline engagement level. Helps you separate high-value churned users from low-value ones.
• `last_product_area_used` — If your product has distinct features, knowing which area a user last touched informs message relevance.

These computed traits update automatically as new events arrive. Once a user becomes active again, they exit your churn audience without manual intervention.

Step 3: Build Your Win-Back Audiences

In Engage > Audiences, create tiered audiences using the computed traits from Step 2.

Example audience definition for "High-Value Churned":

• `days_since_last_active` is between 31 and 90
• `lifetime_order_count` is greater than 3
• `subscription_status` is not "cancelled"

Build a separate audience for each churn tier. Keep them mutually exclusive — a user should sit in only one tier at a time. Use audience exclusions to enforce this.

Step 4: Connect Audiences to Your Messaging Tools

This is where Segment's integration catalog matters. The specific configuration depends on which tool you're sending from.

If you're using Braze:

Activate your audience and send it to Braze as a Cohort. Inside Braze, use Canvas to build a multi-step re-engagement journey. Segment passes the audience membership as a Braze Cohort attribute, which Canvas uses as an entry trigger. Map your churn tier as a custom attribute so Canvas can branch messaging by tier — different copy for recently lapsed vs. deeply churned.

If you're using Iterable:

Connect your Engage audience to Iterable via the native destination. Iterable's Workflow Studio can use list membership (populated by Segment) as a workflow trigger. Build separate workflows per churn tier. Segment keeps list membership current — when a user re-engages and exits your churned audience, Iterable removes them from the list automatically, stopping the campaign.

If you're using a simpler ESP (Klaviyo, Customer.io, Mailchimp):

Most of these accept Segment audiences as synced lists or segments natively. The mechanics are the same — audience membership flows in, your tool uses it as a trigger or filter.

Step 5: Suppress Actives and Recent Converters

A win-back campaign that targets someone who already came back is a fast way to erode trust. In Engage, create a suppression audience of users who have been active in the last 14 days. Add this as an exclusion to all three churn-tier audiences. Your messaging tools will respect the exclusion automatically on each sync.

Also suppress users currently in a paid trial or onboarding flow. You don't want win-back messaging colliding with activation messaging.

---

What Segment Does Not Do Here

Be clear-eyed about where Segment stops and your messaging tool begins.

• Segment does not send messages. It builds the audience and routes it. The copy, timing, frequency caps, and A/B tests all live in Braze, Iterable, or whatever tool you're using downstream.
• Segment Engage syncs audiences on a schedule, not in real-time by default. For most win-back use cases this is fine — a 1–4 hour sync lag is acceptable when you're targeting 30+ day churned users. For real-time triggers, you need to use Segment's Event-Triggered Audiences (available on Business tier) or route raw events directly to your messaging tool.
• Historical event data has limits. If you haven't been tracking clean events for the past 90 days, your computed traits will reflect gaps. There's no retroactive fix for missing instrumentation.
• Profile merging takes configuration. If your users interact across web, mobile, and email without a consistent `user_id`, Identity Resolution requires deliberate setup. Defaults won't merge profiles correctly in complex multi-device environments.

---

Frequently Asked Questions

How long does it take for Engage audiences to populate after I create them?

Initial audience computation can take anywhere from a few hours to 24 hours depending on the size of your user base and the complexity of the trait logic. After the initial build, audiences update incrementally as new events arrive. Plan for this delay when scheduling your first campaign sync.

Can I use Segment to track whether a win-back campaign actually worked?

Yes, but you need to close the loop manually. Segment can track re-engagement events after a user receives a campaign, but connecting campaign receipt to re-engagement requires either UTM parameters on your links (which you'd track as event properties) or a reverse ETL setup pulling campaign data back into Segment from your ESP. Neither happens automatically out of the box.

What's the difference between using Segment Engage and just building a list in my ESP directly?

When you build the list in your ESP, it's static or requires manual refreshes. Segment Engage audiences are dynamic — they add and remove users continuously based on live event data. A user who re-engages after day 15 exits the audience and stops receiving win-back messages without anyone touching the list. That automation reduces errors and prevents over-messaging.

Do I need Segment's Business plan to run win-back campaigns?

The core Audiences and Computed Traits features are available on the Teams plan. Event-Triggered Audiences and some advanced Identity Resolution features require Business. For most win-back use cases built on 30–90 day inactivity windows, the Teams plan is sufficient.