Skip to content
Faisal Mahmud TusherDigital marketing, SEO & analytics
with Faisal Tusher

Marketing Technology › The Marketing Stack

Data Flow and Integrations

How data flows through a marketing stack: sources and events, identity resolution, the warehouse and CDP roles, and reverse ETL and activation.
Guideadvanced12 min readUpdated

The flow in one picture

The flow has five stages, and each is a place where data can be lost, duplicated or redefined. Reading a stack as this table is the fastest way to find where a problem lives.

StageWhat happensTypical componentsWhat goes wrong
SourcesPeople act on the site, app, email, ads, in sales and supportWeb and app surfaces, email platform, advertising platforms, customer relationship management, commerce and billing systemsEvents undefined or named differently per source
CollectionEvents are captured and sentTag manager, analytics tags (GA4), server-side endpoints, software development kits, connectors and exportsTags blocked, consent not applied, parameters missing
Storage and identityEvents land, are joined and resolved to peopleWarehouse, customer data platform, identity graph, consent storeIdentity resolved differently per tool; joins on unreliable keys
ActivationSegments, attributes and conversions are pushed to channelsReverse-sync tooling, platform conversion interfaces (Conversions API), native connectorsDuplicated conversions, stale segments, suppression failures
MeasurementResults come back and are reportedAnalytics, business intelligence, attributionMetrics defined per tool; results not joined to the people who produced them

The direction is a loop, not a line. Results from activation are themselves events (a send, an open, a conversion the platform reports) that flow back through collection into storage, where they update the profile that the next activation reads. A stack in which that loop is closed can learn; one in which results stay inside each channel's reporting cannot.

Sources and events

Every flow starts with a decision about what counts as an event. An event is a thing that happened, with a name, a time, the identifiers of who did it and parameters describing it. The business needs one list of the events it cares about, with names and parameters fixed, and every source should emit them the same way. That list is the tracking plan, and the tracking plan guide covers writing one.

Sources differ in how they emit. The site and app emit through tags and software development kits, which means the events are only as good as the data layer the developers expose and the consent the visitor gives. The email platform, the advertising platforms and the customer relationship management system emit through exports and programming interfaces, which are reliable but arrive on their own schedule and in their own vocabulary. Commerce and billing systems hold the truth about money and are usually the system of record for a purchase, which makes them the source to reconcile everything else against.

Three rules keep sources manageable. Name events once, in the plan, and map each source's vocabulary to those names at collection rather than downstream. Carry the identifiers the join will need on every event, not just the ones the source finds convenient; a purchase event without the order id cannot be reconciled with billing. And mark the consent state on the event itself, so that storage and activation can respect it without a separate lookup. Documented platform event names such as purchase, add_to_cart and view_item are a good starting vocabulary for commerce because the platforms already understand them.

Identity resolution

Identity resolution is the work of deciding that the records in different sources describe the same person. It is where most stacks quietly fail, because each tool does it its own way and nobody notices until segments disagree.

The raw material is identifiers. A browser cookie or device identifier describes a browser or a device, not a person. An email address, a phone number or a loyalty number describes an account and is shared across devices. A customer id from the commerce or customer relationship management system is the business's own key. Resolution links these by observing them together: a login ties the cookie to the customer id; an email click ties the email address to the cookie; a purchase ties the customer id to the order.

Two approaches exist. Deterministic resolution links only on observed matches: the same email address, the same customer id, a login event. It is accurate and incomplete, because many visitors never identify themselves. Probabilistic resolution infers matches from behaviour and device signals; it is more complete and less certain, and in most jurisdictions it raises consent questions that deterministic matching does not. For marketing activation, deterministic matching on consented identifiers is the usual choice, with hashed email addresses as the bridge to advertising platforms' own matching.

Where resolution happens matters as much as how. It should happen once, in the data layer, with the result (a single person id and the identifiers it links) made available to every tool that needs it. The older model, in which a data management platform (DMP) held cookie-based audiences for advertising while the customer relationship management system held people, has given way to first-party resolution as third-party cookies have become unreliable. A stack in which the email platform, the advertising accounts and the analytics property each hold their own match graph will never reconcile. In Google Analytics, carrying the business's own customer key as the User-ID is what lets the export join behaviour to the CRM, as the guide to User-ID and signed-in users in GA4 describes.

Warehouse and CDP roles

A warehouse and a customer data platform both store customer data, and the question of which to use, or how to use both, is the most common data-layer design decision.

A warehouse is a database built for analysis. It holds everything, from every source, with history; it joins across the whole business, not just marketing; and it is where the definitions behind reporting live. It is slow in the sense that queries run on demand and pipelines run on schedules, and it has no native concept of a person or a segment; those are tables and queries the team writes. The metrics layer guide covers turning its tables into shared definitions.

How those tables are laid out for marketing, with facts at their natural grain, shared dimensions and a campaign mapping table, is the subject of the guide to designing a marketing data model.

A customer data platform is built for the marketing use of customer data specifically. It ingests events, resolves identity with its own model, holds profiles, lets marketers build segments without writing queries and pushes them to channels through connectors it maintains. It is fast for activation and opinionated about the customer; its model of a person is the one it offers, and its view of the business stops at the data it was given.

The division that works for most teams is: the warehouse as the system of record for history, joins and definitions; the platform, or a reverse-sync tool playing its activation role, as the system of action for segments and real-time triggers. Data flows from sources into the warehouse (and, for real-time cases, directly into the platform), identity is resolved once and the result shared, and segments are defined where the team can govern them. Running both with separate identity logic and separate segment definitions is the arrangement to avoid, because every discrepancy then has two candidate causes. The designing a marketing stack guide places this decision in the wider design.

Activation and reverse ETL

Activation is the flow from the data layer back to channels. There are three mechanisms, and most stacks use all of them.

Reverse ETL is a pipeline that reads a table or a query result from the warehouse and writes it to a destination tool: a list of customer ids and a segment flag to the email platform, a hashed email list to an advertising account, a computed lifetime value to the customer relationship management system. Its value is that the segment is defined once, in the warehouse, and used everywhere; its cost is latency, since it runs on a schedule, and the care needed to write to tools that treat the upload as a replacement or as an append.

Platform conversion interfaces are the server-side route for sending conversions and events to advertising platforms. They complement the browser tag by sending events the browser could not (offline conversions, back-end purchases, qualified leads from the customer relationship management system) and by surviving blockers. Their condition is deduplication: the browser and the server must send the same event identifier so the platform can recognise the duplicate, and the platforms' help centres document how. The Meta conversions interface guide covers that platform's version, and the connecting the customer relationship management system to ads and analytics guide covers the offline side.

Native connectors are the integrations tools ship with each other: the commerce platform to the email platform, the customer relationship management system to the advertising accounts. They are the easiest to switch on and the hardest to govern, because each carries its own mapping and its own idea of identity. Use them where the data layer is not yet involved, and migrate them to the governed flow as it is.

Illustrative example — not a real result

A software company closes the loop

A business software company with 3,200 trial sign-ups a month sends product usage events to its warehouse, joins them to the customer relationship management record on email address and computes a daily activation score per trial. A reverse-sync job pushes three segments to the email platform (activated, stalled, dormant) and the stalled segment, hashed, to two advertising accounts for a short remarketing campaign. Qualified leads marked by sales are sent to the advertising platforms through their conversion interfaces with the original click identifiers, so bidding can optimise towards qualified leads rather than sign-ups. In the first quarter the stalled-trial sequence is sent to 1,140 trials and 196 of them activate within two weeks, against 61 of a 1,100-trial holdout that received nothing. The event payload below is what one activation event looks like when it leaves the site, with the parameters the plan requires.

{
  "event": "trial_activated",
  "event_id": "7f3a9c2e-1b4d-4e8a-9f2c-5d6e7a8b9c0d",
  "timestamp": "2026-09-14T10:22:31Z",
  "user_id": "cus_48213",
  "email_hash": "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae",
  "consent": { "analytics": true, "marketing": true },
  "params": { "plan": "team", "seats": 5, "days_since_signup": 3 }
}

Integration patterns and failure modes

Integrations fail in a small number of repeatable ways, and recognising the pattern is most of the fix.

Batch versus streaming. Scheduled exports and reverse-sync jobs are simple and robust but late; a segment refreshed nightly cannot drive a message that must arrive within the hour. Streaming connections are timely and fragile; they fail silently when a schema changes. Choose by the use case's latency need, and do not stream what batch can serve.

Push versus pull. A source that pushes events (a webhook, a tag) is timely but can be lost if the receiver is down; a destination that pulls (a scheduled import) is resilient but late. Most robust flows push into a durable queue or storage and let consumers pull from there.

Append versus replace. Many destination tools treat an upload as a replacement for the list it matches; others append. A reverse-sync that appends to a suppression list that should have been replaced grows it forever; one that replaces an append-only audience wipes it. Read the destination's documented behaviour before the first sync.

Schema drift. A source renames a parameter, adds a field or changes a type, and every downstream mapping breaks or, worse, silently fills a column with nulls. Versioned event schemas and a contract between the site's data layer and the warehouse are the defence; the data layer guide covers the site side. When either pattern shows up as a CRM value that reverts after every run, the diagnosis for CRM values changing back after a sync separates the connector's behaviour from the other writers that can restore an old value.

Identifier mismatch. The destination keys on an identifier the flow does not carry, so matches fail and the tool creates duplicates. The fix is upstream: carry the identifier on the event, or resolve it in the data layer before the sync.

Consent leakage. An event collected under consent for analytics is activated for marketing, because consent state was not carried through the flow. Store consent on the profile and check it at the point of activation, not only at collection.

Duplication. The same conversion arrives from the browser and the server, or from two connectors, and is counted twice. Shared event identifiers and documented deduplication in the destination are the only reliable cure.

Replacing the email platform tests every one of these patterns at once, which is why the tutorial on migrating to a new email platform records each integration in a register before the old account is switched off. Replacing the CRM tests them too, and the tutorial on moving to a new CRM reconciles a test load against the old system before cutover and reconnects each outcome upload afterwards. Outside a migration, the tutorial on documenting marketing integrations keeps a standing register of every connection, recording which of these patterns each one follows, the identifier it keys on and the check that shows it failing.

Monitoring

A flow that is not monitored is a flow that is broken and nobody knows. Monitoring is cheap relative to the cost of a quarter of decisions made on a broken feed, and the checks are simple.

Freshness: when did each source last deliver, and is that within its expected window? A nightly export that has not run is the most common silent failure. Volume: how many events arrived against the usual range for the day of week, and did any event type drop to nothing or double? A tag removed by a site release shows here first. Completeness: what share of events carry the identifiers and parameters the plan requires? A release that stops populating the order id is invisible in volume and obvious in completeness. Reconciliation: do purchases in the warehouse match orders in the commerce system, and do conversions sent to platforms match what the platforms report receiving? The data quality guide covers these checks in detail, and the discrepancies guide covers the reconciliation between platforms and analytics.

Alerts should go to the owner of the flow, not to a shared inbox, and each should carry the check that failed and the last known good time. Review the alert log at the stack review; a flow that alerts weekly has a design problem, not a monitoring problem. The marketing stack hub sets out who owns each layer, and ownership of the flows follows from it.

Where an older data management platform still holds advertising audiences, the CDP versus DMP comparison explains what each platform is for and what replaces the DMP's role.

Common mistakes

  • Letting each tool resolve identity itself. Segments that disagree and reports that cannot be reconciled follow.
  • Defining segments in the activation tools. The definition then exists in several places and drifts; define once in the data layer and sync out.
  • Streaming what batch could serve. Real-time pipelines are fragile; use them only where the use case needs the latency.
  • Sending server events without deduplication keys. Conversions double and bidding learns from the wrong signal.
  • Carrying consent at collection only. Activation then uses data that consent did not cover.
  • No freshness or volume checks. A feed that stopped weeks ago is still feeding the dashboard.
  • Treating native connectors as the architecture. They are a start; the governed flow through the data layer is the destination.

Frequently asked questions

Do we need both a warehouse and a customer data platform?

Not necessarily, and the answer depends on which jobs need doing. A warehouse is the better home for history, joins across every business system and the definitions reporting depends on. A customer data platform is built for resolving identity in near real time and pushing profiles and segments to channels. Teams with data engineers often use the warehouse for both and add a reverse-sync tool for activation; teams without them often buy the platform and feed it from the warehouse. Having both with overlapping logic is the arrangement to avoid.

What is reverse ETL in plain terms?

Ordinary extract-transform-load pipelines move data from operational tools into the warehouse for analysis. Reverse ETL moves it the other way: a segment or a computed attribute defined in the warehouse is pushed out to the email platform, the advertising accounts or the customer relationship management system so those tools can act on it. It turns the warehouse from a reporting store into the place where activation audiences are defined once and used everywhere.

Why do conversion counts differ between the advertising platform and analytics?

Because they are collected differently, attributed differently and deduplicated differently. The platform counts conversions it can match to its own ads, within its own windows, often from both browser and server events; analytics counts sessions and events under its own model. Server-side integrations such as a conversions interface add matching but also add duplication if browser and server events are not keyed on the same event identifier. The analytics hub's discrepancy guide covers reconciliation; this guide covers designing the flow so the discrepancies are explainable.

Terms used on this page

Where this page is used

Part of these learning paths

Also related

Related