# Real-Time Segmentation: Catch Users Before They Go Dormant

Batch segments update too slowly for retention messaging. How dynamic behavioral segments, journey exit criteria, and suppression rules keep you from messaging too late — or too often.

Author: The Tappd Team · Engineering at Tappd
Date: 2026-07-11
Category: Guides
Canonical URL: https://tappd.io/blog/real-time-segmentation-retention

You notice a user cancelled their subscription. You pull up their activity log. They stopped opening the app three weeks ago — you just didn't know until they hit "cancel."

That's the batch segmentation problem. By the time your segments refresh, the moment to intervene has passed. You end up sending win-back messages to users who already returned, onboarding nudges to users who already activated, and cart recovery pushes to users who already bought.

Retention messaging only works if your segments update as behavior changes.

## Batch vs real-time: why timing breaks retention

Most engagement platforms offer segmentation. Not all segments update at the same speed.

| Segment type | Update frequency | Retention use case | Problem |
|---|---|---|---|
| **Static list** | Manual upload | One-off campaigns | Stale immediately |
| **Batch segment** | Every 12–24 hours | Weekly newsletters | User activated yesterday; still gets "complete setup" push |
| **Real-time segment** | On every event | Activation nudges, cart recovery, stall detection | User exits segment the moment behavior changes |

For retention, batch is often too late:

- A user who abandons checkout at 2 PM shouldn't wait until tomorrow's batch job to enter the recovery segment
- A user who activates at 11 PM shouldn't get a "finish your setup" push at 9 AM because the segment hadn't refreshed
- A user who returns organically shouldn't receive touch 2 of a win-back sequence because enrollment happened 3 days ago

Real-time segments solve this by recalculating membership on every event.

## The segments that matter most

You don't need fifty segments on day one. Start with three that map to your highest-leverage retention flows:

### 1. Signed up, not activated

**Rule:** `account_created` occurred AND `activation_completed` has not occurred

**Journey:** In-app welcome on first session → push at 24h if still not activated → push at 72h → exit on activation

**Why real-time matters:** The moment the user completes activation, they must leave this segment instantly. Sending "complete your setup" to an active user is how you erode trust on day two.

For the messaging playbook, see our [onboarding messaging guide](/blog/user-onboarding-messaging).

### 2. Soft dormant

**Rule:** `last_session` more than 7 days ago (adjust for your app's natural frequency) AND user was previously activated

**Journey:** Gentle reminder push → value-add at day 3 → final nudge at day 7 → exit on return

**Why real-time matters:** If the user opens the app on day 5, they should exit the dormant segment before touch 2 fires. Win-back to someone who's already back is the fastest path to notification disable.

For copy and cadence, see our [win-back strategies guide](/blog/re-engagement-winback-campaigns).

### 3. Cart abandoned

**Rule:** `checkout_started` occurred AND no `purchase_completed` within 60 minutes

**Journey:** Wait 60 min → push with deep link → wait 24h → touch 2 if no return → exit on purchase

**Why real-time matters:** Purchase suppression must happen at send time. A user who buys at minute 59 should never receive the recovery push scheduled for minute 60.

For the full recovery checklist, see our [cart abandonment guide](/blog/cart-abandonment-recovery-messaging).

## Journey exit criteria: the part teams skip

Entering a segment starts a journey. Exiting is what prevents over-messaging.

**Exit immediately when:**

| Event | Journeys affected |
|---|---|
| `activation_completed` | Onboarding, signup nudges |
| `purchase_completed` | Cart recovery |
| `session_started` / app open | Win-back, dormant re-engagement |
| Push token invalidated | All push journeys |
| User unsubscribes / opts out | All outbound |

**Re-check at send time, not just enrollment.** A user enrolled in cart recovery at 1 PM who purchases at 3 PM must be skipped for the 4 PM touch — even if the journey logic says "send touch 1 at 4 PM."

This is where batch systems break down. Enrollment snapshots from hours ago don't reflect current behavior.

## Suppression rules: one sequence at a time

Overlapping journeys are a common source of duplicate sends — the problem Reddit users report with complex canvas re-entry rules in enterprise platforms.

**Rules of thumb:**

1. **One outbound sequence per user.** If someone is in onboarding, don't also enroll them in win-back.
2. **Priority hierarchy.** Cart recovery > onboarding > win-back. High-intent moments get priority.
3. **Cooldown between campaigns.** If a user completed a win-back sequence with no engagement, wait 30 days before re-enrolling — not 7.
4. **Suppress on recent engagement.** If the user opened the app today, skip the dormant push scheduled for tonight.

```
if user.session_today:
    skip_outbound()
elif user.in_journey("cart_recovery"):
    skip_other_journeys()
elif user.completed_activation:
    exit_journey("onboarding")
```

Keep the logic explicit. Implicit re-entry rules in complex canvases are where duplicate-send bugs hide.

## Segment design checklist

Before shipping any retention segment:

- [ ] Segment rule uses events you actually track
- [ ] Segment updates on event (not daily batch)
- [ ] Journey has explicit exit on positive action
- [ ] Send-time eligibility re-check (not enrollment snapshot only)
- [ ] Suppression for users in other active journeys
- [ ] Frequency cap per channel (e.g., max 3 pushes/week)
- [ ] Holdout group to measure incremental lift

## Example segment rules

| Segment name | Rule | Journey |
|---|---|---|
| Needs activation | `signed_up` AND NOT `activated` AND `days_since_signup <= 7` | Onboarding nudges |
| Soft dormant | `activated` AND `days_since_last_session >= 7` AND `< 14` | Win-back touch 1 |
| Hard dormant | `activated` AND `days_since_last_session >= 14` AND `< 30` | Win-back touch 2–3 |
| Cart abandoned | `checkout_started` AND NOT `purchase_completed` AND `minutes_since_checkout >= 60` | Cart recovery |
| Post-purchase nurture | `purchase_completed` AND `days_since_purchase <= 7` | Review request, cross-sell |

Adjust thresholds to your app's natural usage frequency. A weekly-use fitness app sets dormant at 14 days, not 7.

## Building this in Tappd

Tappd segments update as events arrive — not on an overnight schedule:

- **Unified profiles** combine events, traits, and devices in one view
- **Dynamic segments** recalculate membership on every tracked event
- **Journey builder** supports triggers, waits, branches, and event-based exits
- **Suppression** via exit criteria: user completes activation → leaves onboarding flow permanently

Example: a segment for "signed up, not activated" uses rules like `account_created` present, `activation_completed` absent, and `days_since_signup <= 7`. The moment `activation_completed` fires, the user drops out of the segment and any pending journey steps are cancelled.

Measure what matters: activations recovered, carts converted, dormant users returned — not segment size or send volume.

## When batch is fine

Real-time isn't required for everything:

- **Monthly newsletters** — batch is fine
- **Quarterly feature announcements** — batch is fine
- **Annual renewal reminders** — batch is fine

Use real-time segments for any message tied to a behavior moment: activation stalls, checkout abandonment, dormancy thresholds, trial expiry. Those are the flows where hours of delay cost you the user.

## Start here

1. Pick one behavioral segment (start with "signed up, not activated")
2. Verify it updates within seconds of the relevant event
3. Build a journey with one message and one exit criterion
4. Add suppression so activated users never receive the nudge
5. Measure activation lift vs a holdout group before adding complexity

Retention messaging is a timing problem. Real-time segments are how you show up while it still matters — and stay quiet when it doesn't.

---

[All posts](https://tappd.io/blog) · [Tappd](https://tappd.io/)