zero gravitySOLUTIONS
← All insightsPRODUCT DATA / REPLAY SAFETY GUIDE

Customer.io campaigns that respect event replay.

QUICK ANSWER

Separate historical event delivery from permission to start a message journey. Preserve original timestamps, use an explicit replay policy, and check direct and indirect campaign effects; event age and campaign frequency alone do not provide complete replay control.

Inside this article 5 sections

Prevent unwanted Customer.io messages by separating historical event ingestion from current message eligibility. Preserve original event time, mark replay traffic explicitly, and make the application and campaign rules agree about which events may start a customer journey.

A data repair should be able to rebuild analytics without sending a second welcome email or an outdated reminder. Event timestamps help preserve history, but they are not a complete suppression mechanism: backfilled events can still be eligible to trigger automations under platform timing and campaign rules.

Separate a historical fact from an invitation to act

Consider an illustrative event, workspace_activated, that was originally generated yesterday but missed the lifecycle destination. Replaying it may be useful for customer history. Whether it should send a message today depends on the campaign's purpose, the account's current state, and whether the person already received equivalent communication.

Store an event ID, occurrence time, delivery attempt time, replay batch ID where applicable, and an explicit delivery mode. “Live,” “replay without messages,” and “approved catch-up” represent different intentions. Avoid inferring intention only from the event's age; an outage can delay a legitimate live event, and a recent event can still be a duplicate.

Original message eligibility gate
A business event reaches the lifecycle destination
Live deliveryEvaluate eligibility

Check current state, campaign filters, and prior business operation.

Historical replayStore without triggering

Use an isolated route or an explicit trigger exclusion.

Approved catch-upApply a bounded policy

Limit recipients, message age, and permitted campaign purpose.

Delivery mode is an application contract. It is not a claim that Customer.io supplies these three modes automatically.

Put a gate before the campaign

At the integration boundary, decide which events may enter message-triggering paths. Historical rebuilding can use a separate workspace, a non-triggering event namespace, or another deliberately isolated data route. The right choice depends on whether the history must be visible in the production customer profile.

If replay events enter the same workspace and event type, every relevant trigger must exclude the replay marker. Treat a missing mode as a contract violation in the sender, not as an invitation to assume the event is live. A single forgotten campaign can defeat an otherwise consistent convention.

Customer.io supports event data filters and campaign frequency settings, but a one-time campaign is not a general replacement for replay control. Different campaigns may react to the same fact, and changes to workflow configuration may alter eligibility. Keep suppression logic understandable outside the campaign editor.

The following JavaScript policy fixture belongs in the application integration layer. It demonstrates a strict welcome-message rule: a replay may update history, but it cannot itself authorize a welcome message. Inputs come from authenticated event processing and current account state.

import assert from 'node:assert/strict';

function maySendWelcome(event, account) {
  return event.kind === 'workspace_activated'
    && event.mode === 'live'
    && account.active === true
    && account.recipientEligible === true
    && account.welcomeRecorded === false;
}

const current = { active: true, recipientEligible: true, welcomeRecorded: false };
const live = { kind: 'workspace_activated', mode: 'live' };
assert.equal(maySendWelcome(live, current), true);
assert.equal(maySendWelcome({ ...live, mode: 'replay' }, current), false);
assert.equal(maySendWelcome(live, { ...current, welcomeRecorded: true }), false);

This is a policy function, not a Customer.io API call or a concurrent deduplication mechanism. Claim the message intent durably before dispatch, and enforce the campaign’s eligibility rules again at send time. An approved catch-up campaign needs its own reviewed purpose and identity rather than relabeling a historical event as live.

Preserve time and deduplicate business intent

Send the original occurrence timestamp when backfilling. Assigning the current time makes an old event look new and changes downstream reporting. Keep delivery time separately so operators can measure lag without rewriting customer history.

Use a stable event identifier across retries, and maintain a destination delivery ledger where needed. Distinguish “accepted by the destination” from “message sent.” A network timeout after acceptance is ambiguous; blindly treating it as a new event can create another campaign entry. The ledger should record attempts and outcomes without pretending an HTTP acknowledgment proves the final message result.

For especially sensitive communication, define an application-level message intent such as account, milestone, and campaign purpose. Deduplicating that intent is different from deduplicating raw event transport. Two distinct events can represent the same reason to contact someone, while one account milestone may legitimately notify two designated people.

Test replay against current customer state

Prepare synthetic profiles for a live first activation, a duplicate delivery, a historical replay, a cancelled account, and an approved catch-up. Use test recipients. Confirm both campaign entry and actual message behavior; a profile that enters and exits before sending is different from a profile that never entered.

Include delayed actions. A reminder scheduled earlier may become irrelevant after a customer completes the task. Recheck the necessary condition close to sending through the campaign's filters and workflow design. Replay safety cannot be solved entirely at the original trigger when customer state changes during a wait.

Check event-based segments and profile updates too. A replay can indirectly alter segment membership, which may trigger another journey even if the original event-triggered campaign excludes it. Inventory downstream effects before a large backfill rather than reviewing only the most obvious welcome sequence.

Give the batch an accountable owner and preserve a record of its filters, event range, and intended messaging behavior. A later investigator should be able to distinguish an authorized catch-up from an accidental retry storm without reconstructing decisions from chat messages.

Operate a backfill as a controlled batch

Start with a small test batch, record expected eligible and suppressed counts, and inspect the resulting profiles. Expand only after the observations match. Keep a stop mechanism that halts delivery to lifecycle destinations independently of warehouse rebuilding. A shared retry queue should not force both destinations to continue together.

The product event architecture describes destination-specific responsibilities, and reliable background jobs covers durable retries. Software implementation can make replay intent, campaign eligibility, and delivery evidence part of one integration contract.

FROM INSIGHT TO ACTIONCustom software development

Make data repair independent of customer messaging.

We can implement replay routes, delivery ledgers, and campaign validation that keep historical rebuilding under deliberate control.

Explore software developmentDiscuss your build

Start with your goals.
We’ll work through the next step together.