zero gravitySOLUTIONS
← All insightsDATA & INTEGRATION / EVENT CONTRACT LAB

PostHog, Customer.io, and Redshift: one event, three responsibilities.

QUICK ANSWER

Give product events a stable business meaning and identity, then adapt them for each destination. PostHog supports product analysis, Customer.io supports lifecycle communication, and Redshift supports warehouse reporting. Replays and corrections should respect those different responsibilities.

Inside this article 6 sections

A user completes a product setup step. Product managers want to understand activation. The lifecycle team wants to send a relevant follow-up. Finance wants a durable account-level view alongside billing data. Sending an event to PostHog, Customer.io, and Redshift can serve those needs, but the three destinations should not become three competing definitions of what happened.

Begin with the business fact. In this illustrative design, an account has completed its first successful data import. The backend knows when the import actually succeeded, which account owns it, and which operation produced it. That makes the backend a better source for this event than a browser click on “Start import.”

Write a small contract before adding destinations

Give the event a stable identity, a clear name, a schema version, an occurrence time, and the minimum context consumers need. Separate the person who initiated the operation from the account that owns the result. Preserve both where appropriate; a B2B product often has several people contributing to one account-level outcome.

{
  "event_id": "evt_demo_1042",
  "event_name": "first_import_completed",
  "schema_version": 1,
  "occurred_at": "2026-10-20T14:30:00Z",
  "account_id": "account_demo_17",
  "actor_id": "user_demo_8",
  "operation_id": "import_demo_93",
  "properties": { "source_type": "csv" }
}

This is a proposed internal envelope, not a payload to send unchanged to every provider. An adapter should map its fields to each destination’s API. Keep customer content, credentials, and unnecessary personal information out of the event. Adding a field is easy; removing its copies from multiple systems later can be much harder.

ORIGINAL EVENT DESIGN / ONE FACT, THREE USES
First import completedStable ID · account · actor · occurrence time
PRODUCT ANALYSISPostHog

Activation and behavior

LIFECYCLE ACTIONCustomer.io

Eligible, timely communication

HISTORICAL REPORTINGRedshift

Account metrics and reconciliation

Destination adapters preserve the business meaning while applying different identity, delivery, and replay rules.

Let each destination own its responsibility

For PostHog, define how the actor and account map to the identity model used for analysis. Make the event useful for an activation question rather than collecting it simply because the integration makes collection easy. Decide whether repeated imports are separate events and whether “first import” is computed transactionally or derived later. The answer affects both the event producer and the resulting metric.

For Customer.io, map the actor to the intended messaging profile and verify whether the event should trigger communication at all. Account activity is not automatically permission to message every account member. The event’s business meaning should remain separate from the eligibility rules that decide who receives a message and when. Customer.io’s source specification distinguishes message identity and timing fields; the adapter needs an explicit mapping rather than relying on similarly named fields.

For Redshift, decide which records support the warehouse model and how they join to billing or account data. PostHog can export data to Redshift through batch exports, so a separate custom exporter may be unnecessary. If both a direct pipeline and an export contain the same business event, define which is authoritative for each model instead of counting both.

Use occurrence time and processing time deliberately

An event can happen on Tuesday and arrive in the warehouse on Wednesday. Product metrics may need Tuesday’s occurrence time, while pipeline monitoring needs Wednesday’s arrival time. Keep both. Late-arriving events should have a documented effect on previously reported periods, especially when teams compare a live dashboard with a scheduled warehouse report.

Client clocks, retries, and backfills can complicate timing. For a backend-confirmed import, use the business operation’s recorded completion time. Preserve an ingestion timestamp separately. Do not rewrite the occurrence time to “now” merely to make a replay look like a fresh event.

Replay analytics without replaying customer messages

Imagine correcting an event adapter and replaying a month of imports. Analytics and warehouse models may need the corrected history. A lifecycle campaign probably should not congratulate users again for an import completed weeks ago. Give replay jobs an explicit mode and route them through destination rules that suppress unintended customer-facing effects.

Use stable event IDs for duplicate handling, and define a separate revision strategy when an event’s facts are corrected. A repeated delivery and a correction are different things. Warehouse staging can reconcile repeated records before merging them into a reporting table. Redshift’s MERGE operation is one available building block, but it does not decide which record is the correct business version for you.

Deliver one event across the destinations before expanding the schema

A bounded implementation can begin with one meaningful event, such as completion of an account setup step. Agree on its authoritative producer, account identity, occurrence time, and allowed destination behavior. The scope should name the PostHog analysis it supports, the Customer.io action it may trigger, and the Redshift representation used for reporting. Avoid treating three successful API calls as acceptance of the business definition.

Ask for the event contract, destination mappings, synthetic fixtures, and a reconciliation view that follows one event ID through the path. Include duplicate delivery, delayed arrival, and a historical replay. The lifecycle acceptance case should demonstrate that replay cannot accidentally contact customers. The reporting case should explain which time window and identity rule produce the expected result, including any intentional difference from the product analytics view.

Start with discovery when teams disagree on what the event means. Move to implementation when ownership and behavior are agreed. A dedicated delivery team can extend the contract as product workflows grow, but every new destination should still have an acceptance owner. We can use the first event as a complete, reviewable example that product, lifecycle, and data teams can all inspect before wider rollout.

Make disagreements diagnosable

Track accepted source events, deliveries by destination, rejected mappings, and the age of undelivered work. Sample individual event IDs across the path. If a funnel count differs from a warehouse report, check identity, time windows, filters, duplicate rules, and late-arrival handling before assuming a tool is broken.

Assign ownership for contract changes. A renamed field can break a lifecycle rule even while the analytics dashboard still works. Test adapters with representative events and review downstream dependencies before changing the producer. Our software implementation services cover these integrations; the messaging architecture guide helps decide how to transport the events.

Before reconciling destinations, establish who and which account each event represents. Read Account identity in B2B product analytics.

FROM INSIGHT TO ACTIONCustom software development

Make the first product event a shared implementation reference.

We can build the producer contract, destination adapters, replay controls, and reconciliation evidence connecting PostHog, Customer.io, and Redshift.

Explore software developmentDiscuss your build

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