Attribution-Ready Measurement Blueprint: Events & Properties You Must Capture

Q: Do I need multi-touch attribution to start?

No. Start by capturing clean touchpoints. Even last-touch attribution becomes far more useful once the underlying data is complete.

Q: Should I attach campaign fields to every event?

Not every event, but do attach them to your key conversion events (signup, purchase) — that is where credit is decided.

Q: What if users block cookies?

You will lose some identity resolution. Still capture the landing URL and referrer when you can, and treat the results as directional rather than exact.

Q: What if conversion happens days later?

Store first-touch and last-touch values safely, then attach them to the conversion event when it finally happens.

Q: How do I stop direct from stealing credit?

Do not overwrite the last known campaign with direct returns. Keep direct as a visit type, not a campaign source.

Q: What is the smallest version I can launch in week 1?

Track session_start, page_view and signup/purchase, and capture referrer plus UTMs on landing pages and conversions. Add everything else later.

Attribution is just a way to give credit for a conversion (like a signup or purchase). It answers: “Where did this customer come from?”

The hard part is not the math. The hard part is the data. If you don’t capture the right details at the right time, attribution becomes guesswork.

This article is a simple, practical data tracking plan you can copy and use. It shows the key events to track, plus the properties you need so your reports stay honest.

Why “attribution-ready” is a data problem (not a model problem)

Think of a customer journey like footprints. If you miss footprints, you can’t tell where the person came from.

Common things that break attribution:

People come back later by typing the URL (looks like “direct”).
Your own domain shows up as a referrer (self-referral).
You send users to a payment domain and lose the visitor ID (cross-domain).
UTMs are missing on some landing pages.
Redirects remove parameters.
Events fire twice by mistake.

The 3 building blocks: user, session, event

You need three “levels” of data:

User: who it is (a person or account).
Session: one visit (a chunk of time on your site).
Event: one action (like a page view or a button click).

Event vs user properties (what belongs where)

Properties are small details attached to your data.

Event properties describe this action. Example: page URL, referrer, campaign.
User properties describe this person/account. Example: plan type, signup date.

A common mistake: overwriting “first source” again and again. Then your “first source” becomes “direct” and loses the real origin.

Do this

Save first-touch source once.
Save session source per visit.
Attach the right source to conversion events.

Don’t do this

Rewrite first-touch on every page view.
Store campaign info only on page views and never on conversions.

The minimal event map (what you must track to support attribution)

If you track too little, you lose credit. If you track too much, you drown in noise.

Start with these must-have events:

session_start (or first landing page view)
page_view
cta_click (key button)
form_start (optional but useful)
lead_submit or sign_up
purchase (or your main conversion)

Optional (only if they matter):

cancel / refund
newsletter_subscribe
outbound_click

The attribution context: properties you should capture on key events

Events alone are not enough. You need the “why” and “from where”.

Capture these property groups:

Campaign fields (when a link has UTMs)
Referrer + landing context (where they entered)
Click IDs (for paid ads, store as raw strings)

Keep property names consistent. Lowercase is your friend.

Persistence rules: how attribution survives more than one page

People don’t convert on the first click all the time. So you must keep the source info.

Simple definitions:

First-touch: where the user came from the first time.
Session-touch: where they came from this visit.
Last-touch: the last known source before the conversion.

Good rule: capture on landing, store it, then attach it to conversions.

Identity: how to avoid losing credit when users log in (or switch devices)

Before login, you usually have an anonymous ID (browser-based). After login, you have a user ID.

At login time, link them together. Then earlier touchpoints can still get credit.

If users switch devices, you only connect the journey when they identify themselves (login, email link, etc.).

Cross-domain basics (if you have multiple domains)

Cross-domain means the user moves between domains, like:

site.com → checkout.com

If you lose the visitor ID in the middle, the “source” may reset. Then the checkout domain can look like a brand-new referrer.

Basic rules:

Keep the same visitor ID across domains (when possible).
Avoid self-referrals (don’t let your own domains become “new sources”).
Test the full path: ad → landing → checkout → success.

Data quality checks: how to know your attribution won’t lie

Before you trust your dashboard, run simple tests. This is where tracking data proves itself.

Quick QA matrix (run these and compare expected vs actual):

Paid click with UTMs → browse → convert
Organic search → come back direct → convert
Email click → cross-domain checkout → convert
Internal navigation → source should NOT rewrite

7 red flags:

Your own domain appears as referrer
Many conversions from “direct” right after campaigns
UTMs disappear after redirects
Conversions have no source fields
Duplicate conversion events
Visitor IDs reset on checkout
Bot traffic inflates events

The tracking-spec template (copy/paste)

A tracking spec is a simple document that says:

what fires,
when it fires,
and what properties must be included.

Below is a template you can paste into a doc or sheet. It turns guesswork into a repeatable tracking plan.

Template table

Event name	Trigger (when it fires)	Required properties (minimum)	Example values (tiny)	QA check
session_start	First page load of a visit	landing_url, referrer, ref_domain, utm_source	/pricing, google.com, google, google	Source fields present
page_view	On each page load	page_url, page_title	/pricing, “Pricing”	No duplicates
cta_click	On primary CTA click	page_url, button_name	/pricing, “Start trial”	Fires once per click
sign_up	On successful signup	user_id (if known), page_url, utm_source, referrer	12345, /signup, email, newsletter.com	Has source fields
purchase	On confirmed payment / order success	user_id, order_id, revenue, currency, utm_source	12345, A-999, 49, USD, google	Matches back-end

Governance: keep it clean after version 1

Good attribution dies slowly when naming becomes messy.

Simple governance rules for long-term data tracking:

Use one naming style (snake_case is common).
Don’t use dynamic event names (no “click_button_123”).
Don’t rename events. Deprecate old ones and add new ones.
Write down changes (what changed, when, why).
Assign an owner (one person responsible).

FAQ

Do I need multi-touch attribution to start?
No. Start by capturing clean touchpoints. Even last-touch becomes more useful when the data is complete.

Should I attach campaign fields to every event?
Not every event. But do attach them to your key conversion events (signup, purchase). That’s where credit is decided.

What if users block cookies?
You will lose some identity. Still capture landing URL and referrer when you can. Treat results as “directional”.

What if conversion happens days later?
Store first-touch and last-touch safely. Then attach those values when the conversion happens.

How do I stop “direct” from stealing credit?
Don’t overwrite last known campaign with direct returns. Keep “direct” as a visit type, not a campaign source.

What is the smallest version I can launch in week 1?
Track session_start, page_view, signup/purchase, and capture referrer + UTMs on landing and conversions. Add the rest later.