Why Clients Should Own Their Event-Level Data

There is an asymmetry at the heart of most advertising relationships. The platform running your campaigns sees everything — every auction, every impression, every click, every conversion, at the level of individual events. You, the advertiser, typically see a dashboard: rolled-up totals, computed the vendor's way, refreshed on the vendor's schedule, and gone the day the contract ends.

A companion piece argues that real transparency is an architecture rather than a dashboard. This one is narrower and more practical. It is the buyer's case: why you should insist on owning the raw, event-level record of your own advertising — and what becomes possible the moment you do.

The data already exists. The only question is who holds it.

This is the part most buyers miss. The event-level data is not something a platform has to invent for you. It is produced as a byproduct of running the campaigns — auction/bid-request events, impression events, click events, and conversion events are generated continuously by the pipeline. The records exist regardless.

So the question was never "can I have event-level data?" It is "who ends up holding it — me, or the vendor?" Owning it is not a premium analytics feature bolted on top. It is a decision about where the byproduct of your own spend lands.

What you can only do with event-level data

Aggregates are a lossy compression of reality. A dashboard that reports impressions, clicks, and conversions by campaign has already thrown away the detail that the most valuable analyses depend on. With event-level records in your own storage, you can:

• Measure incrementality honestly. Lift, holdouts, and causal measurement need event-level exposure data you control — not a vendor's pre-computed "conversions" number from a party with an interest in the answer.
• Feed marketing-mix and attribution models. MMM and custom multi-touch attribution are only as good as their inputs. Event-level exposure and cost data is the raw material.
• Reconcile cost and catch discrepancies. With per-event media_cost and currency, you can reconcile what was delivered against what was billed, rather than trusting a summary.
• Build and suppress audiences from first principles. Conversion and audience events tied to user identity let you construct your own segments and suppression lists, owned by you, portable across vendors.
• Audit quality and fraud yourself. Inventory, device, geo, and context fields let you investigate suspicious patterns directly instead of filing a ticket and waiting for the vendor's verdict.
• Analyze placement, creative, and context. Creative type, position, site/app context, and taxonomy segments support the granular "what actually worked where" analysis aggregates cannot.

Every one of these is a question you simply cannot answer from a dashboard, because the dashboard already discarded the inputs.

The cost of not owning it

The risk of relying on vendor-held aggregates is not hypothetical:

• Lock-in. When your measurement, audiences, and history live inside one platform, switching means starting over. The cost of leaving becomes a feature of the vendor's pricing power.
• Unverifiable numbers. You cannot independently confirm a result whose underlying events you never see. You are measuring the vendor on the vendor's terms.
• History evaporates at churn. When the relationship ends — or the platform sunsets, as several DSPs have — the dashboard goes dark and the record goes with it. Owned data persists.
• Measurement on someone else's calendar and definitions. Aggregations are computed when and how the vendor chooses. You inherit their definitions of "viewable," "conversion," and "attributed."

What "owning it" concretely means

Ownership is specific, not aspirational. In Ad360's data specification it means event-level records — auctions, impressions, clicks, conversions — streamed via Kinesis Data Firehose into the client's own S3 bucket in near real time, delivered as raw and lightly enriched datasets (separated by raw/ and enriched/ prefixes), as newline-delimited JSON or optional Parquet, partitioned by time and demand hierarchy, and joinable by the client on a shared request_id. The platform deliberately does not pre-join the datasets; the buyer reconstructs and verifies the funnel themselves.

The architecture piece covers why that shape is the right one. For the buyer, the headline is simpler: the records land in infrastructure you control, in formats you can use, keyed so you can assemble the whole picture.

It is more usable than it sounds

The reflex objection is that "log-level data is too much to handle." In practice it is more approachable than the phrase suggests:

• The records are flat, scalar-field structures with a documented schema — not an opaque proprietary blob.
• There is essentially one join key to learn (request_id) to assemble auctions, impressions, and clicks into a funnel.
• The data is partitioned for analytics (year/month/day/hour, plus demand hierarchy), so queries scan only what they need.
• Modern cloud warehouses and query engines ingest partitioned S3 NDJSON and Parquet directly, so "owning the data" does not require building a pipeline from scratch.

Data teams do exactly this kind of work routinely. The barrier is usually permission and access, not capability.

Ownership changes the negotiation

The strategic point is the one that rarely makes it into a data spec. When you own the event-level record:

• You can switch vendors without losing your measurement and audience foundation.
• You can combine multiple sources into one warehouse and compare them on equal footing.
• You can hold a platform accountable with your own numbers instead of asking it to grade itself.

Ownership quietly rebalances the relationship. The dashboard keeps the vendor as the source of truth; owned event data makes you the source of truth, with the vendor as one input among several.

Common misconceptions

• "We already get reports, so we have our data." A report is a derived view; the underlying events are the asset.
• "Event-level data is only for huge advertisers." The records are a byproduct of any campaign; the question of who holds them applies at every scale.
• "It's a privacy liability to hold this." Holding your own event data in your own governed storage, with web-safe identifiers where appropriate, is a controllable, auditable posture — often more so than scattering trust across vendor dashboards.
• "Owning data means building a big data platform." Partitioned NDJSON/Parquet in your own bucket is queryable by off-the-shelf tools.
• "The vendor's aggregates are good enough." They are good enough until you need to verify, switch, or measure causally — which is exactly when you need the raw events you no longer have.

What good operation looks like

• Treat event-level data delivery into your own storage as a default requirement, not an upsell.
• Keep raw and enriched separate so you can audit derived fields against originals.
• Land the data in a warehouse you control, and build measurement on it rather than on vendor screens.
• Make data ownership a migration milestone — the moment you change platforms is the moment to fix where the data lands.

Open questions

• What is the minimum event-level dataset a given buyer actually needs to be self-sufficient in measurement?
• How should ownership and identity coexist as privacy regimes tighten — what is the right balance of web-safe identifiers and retention?
• Can buyers and platforms converge on a standard, portable event schema so that "owning your data" means the same thing across vendors?

A vendor dashboard answers the questions the vendor anticipated, in the form the vendor chose. The raw event log answers the questions you have not thought of yet — including the ones you will only have after the vendor is gone. The data is produced either way. Owning it is simply deciding that the record of your own advertising should belong to you.