Attribution

Every Attribution project moves through the same four phases. Know what you produce in each — and know that,

like CPQ, this is a project you win or lose in the Blueprint, then keep winning in Maintain.

• 1
• Blueprint

Get exec buy-in on the questions, map where data enters today, and map it to our standard taxonomy.

• Output Approved taxonomy + model
• 2
• Build

UTMs on everything, the tracking code, the field package, campaigns for multi-touch — then cut over safely.

• Output Every touch tagged
• 3
• Enable

Docs, the brief, the manual motions, and a living change log. This is not set-and-forget.

• Output A team that keeps it true
• 4
• Maintain

Watch the drift, absorb new sources, kill stale values; revisit on events and on a clock.

• Output Attribution you can trust
• Start Here

Don't dig through the GitHub repo. Copy this prompt, drop in the customer name, and send it to your Claude.

It clones the template, reads the AGENTS.md , and walks the Blueprint checklist with you.

• paste into Claude
• Copy prompt
• # Attribution — kick off

Clone the LeanScale Attribution template repo for my customer [Customer Name] .

Then read AGENTS.md and run the Blueprint checklist:

1. Confirm the questions the exec team wants this attribution model to answer (this sets the depth).

2. Map where data enters the CRM today — web forms, lead-list uploads, rep-created contacts, event lists, partner regs.

3. Map their world onto our standard taxonomy — lead sources (what) and channels (where), with AI/AEO sources included.

4. Decide the model — First / MQL / Latest touch, and how multi-touch gets tracked (campaigns).

5. Produce the tagging map — every source & channel, tagged programmatically or by a written manual process.

Ask me anything you need before you start.

What you get

This is the whole game. Before you touch a field, get the exec

team to tell you what decisions this model has to drive — that sizes everything. Then map how data actually enters

their system today, and lay it onto our standard taxonomy. The projects that go sideways are the ones that got the depth

wrong (too much granularity nobody uses, or too little to answer the question) or where a source was defined but no

mechanism ever routed it.

1.1 · The Two Questions

This is the one thing to internalize before anything else. Attribution isn't a single field — it answers two different

questions with two different sets of fields, and people conflate them constantly.

Lead Source — what did they do?

• The action that got them into the CRM
• Registered for a webinar · requested a demo · attended an event · accepted a gift

Answers: which content actually converts?

Drives: do we do more of this ?

Channel — where did they come from?

• The path that drove them to take that action
• LinkedIn ad · sales outbound · organic search · partner · a generative-engine referral

Answers: where should the next dollar go?

Drives: which platform earns more spend?

The house analogy

Think of designing a house. The lead source is the garage — the room they ended up in, the thing they

did. The channel is the door they walked in through — where they came from to get there. Same room,

different doors. That's why they're two fields: one answers what content works , the other answers how to get

more people to it.

• Worked example · one webinar sign-up
• Contact · Lead
• Channel · where LinkedIn Ad →
• Channel · or Sales Invite →
• Channel · or Direct →
• Lead source · what Hosted Webinar

Three people register for the same webinar (one lead source) from three different channels.

Lead source tells you the webinar converts; channel tells you the LinkedIn ad — not the cold outbound — is what to fund next.

1.2 · Three Levels of Granularity

Both dimensions are a set of Russian dolls: a high-level bucket, the value itself, a level of specificity, and a

free-text exact. Depth is a choice — match it to the questions, don't max it out by reflex.

• Lead source · the what , nested
• Grouping — Event (exec-level bucket)
• Lead Source — Hosted Webinar (the action)
• Lead Source Detail — Registered / Attended / No-Show
• Lead Source Exact — "State of GTM · 2026" (free text)
• Channel · the where , nested
• Channel Grouping — Paid Digital (exec-level bucket)
• Channel — Paid Social (the path)
• Subchannel — LinkedIn (the platform)
• Campaign — the UTM campaign name (the specific initiative)
• Rule of thumb

Only add the grouping layer once you're past ~15 lead sources or ~10–15 channels — before that it's

overhead. And restrict source, channel, and subchannel to an agreed pick list , never free text below the exact

field. A hundred spellings of "LinkedIn" makes the whole report undecidable.

1.3 · The Standard Taxonomy

Most marketers have some attribution experience but haven't gone deep. Hand them our taxonomy as the starting

point and edit from there — it's far faster than a blank page. Here's the shape of it.

• Lead sources · the what
• Groupings
• Grouping Website
• Grouping Event
• Grouping Email
• Grouping Referral
• Grouping Gifting

Under Website : Demo Request, Community Signup, Website Content (guide / on-demand webinar /

blog), Chatbot. Under Event : Hosted & Third-Party Webinar and In-Person Event, each with a detail of

Registered / Attended / No-Show / Visited Booth. Under Referral : Partner, Customer, Employee, Personal Contact.

• Channels · the where
• Groupings
• Grouping Organic Digital
• Grouping Paid Digital
• Grouping Referral
• Grouping Event
• Grouping Email

Organic Digital : Direct, Organic Search (Google/Bing), Organic Social (LinkedIn/YouTube/…),

Review Sites. Paid Digital : Paid Search, Paid Social, Paid Review (G2). Referral : Web, Partner, Customer,

Employee, Sponsored & PR content — and Generative-Engine Referral . Email : HubSpot, Marketing Outbound,

Sales Outbound.

One caveat on "Event"

Event lives in both dimensions, and that's the tell for the whole model. It's a lead source

(they attended) and a channel (offline). The useful question is rarely "did they come from an

event" — it's what drove them to register: a sales invite, a paid ad, an in-house email. Capture that on the

channel + campaign, and the event ROI question answers itself.

1.4 · AI & AEO Sources

Our old attribution standard was written for a pre-AI world and is missing generative engines entirely. In 2026

that's a hole in the funnel. Answer Engine Optimization traffic is real pipeline, and if it isn't in the taxonomy it

reads as direct. Make it first-class.

• Generative-Engine Referral
• New channel · subchannel
• A dedicated Referral › Generative-Engine Referral subchannel
• Last-referring sites: chatgpt.com, perplexity.ai, gemini.google.com, claude.ai
• UTM medium generative-engine when you can tag it
• "Other" organic search
• Catch the assistants
• Search subchannel "Other" catches ChatGPT, DuckDuckGo, Yahoo as referrers
• Where the tracking code reads the last referring site
• Keeps AI answers out of the "direct" bucket
• Report it separately
• So it earns a budget
• Once it's a value, it shows up in the channel roll-up
• Now AEO can be compared against paid for cost-per-pipeline
• The refresh we fold back into the standard on every build
• 1.5 · Where Data Enters Today

The fastest way in: give the client homework — come to the kickoff with a flowchart of how records enter the system

and where they go. That map hands you the lead sources and channels to account for, and the inflection points where

• you need to answer "where did this come from."
• 1
• List every entry point
• Web forms (HubSpot), lead-list uploads (post-event), onesie-twosie rep creation,

LinkedIn / ZoomInfo imports, partner registration forms, chatbot. Each one is a place attribution can be captured — or lost.

• 2
• Define the high-value actions that mean MQL
• A limited set of actions that should hand a lead to sales. This list changes over

time and must be owned by someone — if you add a source but no mechanism routes it, it silently never reaches sales.

• 3
• Right-size the depth to the questions

First / Latest touch is the floor; MQL touch is optional. Don't over-engineer — some teams just need

"are events producing pipeline?" (LeanScale itself mostly runs on lead source alone). Depth is a decision, not a default.

The Harbinger lesson

Attribution setups morph as the business changes — and break when the client doesn't tell you. Harbinger

changed what sales expected to receive but never told us the model needed to change, so leads routed to the wrong place.

Bake this into the blueprint: who owns changes, and how do they reach us.

The Deliverable

Three artifacts come out of Blueprint, and everything in Build is downstream of them. Get them signed off before

you automate a single tag.

01

The tailored lead-source and channel lists — groupings, values, details, and the restricted

pick lists — with AI/AEO sources included. The agreed vocabulary everything else maps to.

02

Every source & channel with a column for how it gets tagged — programmatic

(form → workflow) or manual (lead-list upload) — and how it lands in a campaign. The manual ones need a written process.

03

First / MQL / Latest depth, how multi-touch is captured (campaigns), opportunity + partner rules —

and, above it all, the questions the exec team signed off on.

Use it

Feed all three to Claude as the reference for what Build produces. Every engagement's version looks a

little different — but the shape of the deliverable is always these three.

• 2
• Phase 2

Build has two halves, and the order matters. First you

capture the data — because a touch that isn't tagged doesn't exist. Then you stamp it into the fields and campaigns

that make it reportable. Get capture wrong and the prettiest field model in the world reports on nothing.

2.1 · The Capture Backbone

This is the backbone of the whole model. Every marketing link, campaign, and channel carries UTMs, drawn from an

agreed set of values so the data comes in clean. Give the team a UTM builder so they can't freelance.

• A UTM builder app
• Restricts source / medium / campaign to accepted values
• Izzy built one on a client instance; another client shipped a builder + channel mapper
• Bundle one into this playbook — every attribution engagement gets it
• Kills the 100-variations problem at the source
• The UTM → Channel translator
• Maps utm_medium + utm_source + last-referring-site → channel & subchannel
• paid-social + linkedin → Paid Social · LinkedIn
• Handles non-digital (events, offline referrals) too
• The one hard-to-maintain piece — keep it in the repo, versioned
• 2.2 · The Tracking Code

The move that gets you close to a 100% model. When a visitor lands with no UTMs , empty data looks like direct

traffic — but they came from somewhere . A small piece of custom JavaScript recovers it.

• 1
• Read the last referring site

On landing with no UTMs, the script checks the previous session / last referring page (via cookie

tracking) and writes utm_source and utm_medium so the form submission captures where they actually came from.

• 2
• Backfill first, then enable going forward

Clean up the historical gap (e.g. an event vendor page that pointed straight at the site with no

UTMs), then switch the code on so anything similar is auto-tagged in the future.

• 3
• Know the ceiling — it relies on cookies

If a visitor denies cookies, the trail breaks — it's not foolproof. It's standard web-dev best

practice, lightly customized to the client's field mapping. It gets you closer to 100%, not all the way.

Provenance

This is the advanced scripting Sean built — it's what let us untangle real direct traffic from fake direct

on the Harbinger build. Keep the snippet and its field-mapping notes in the repo; it's one of the highest-leverage assets

in the whole playbook.

2.3 · The Field Package

Three touch-sets on the contact, each stamping the full picture — lead source (with detail & exact), channel,

subchannel, campaign, and the raw UTMs. The template ships the whole field list for both platforms.

• HubSpot — contact object
• Original · Lead Source / Detail / Exact · Channel / Subchannel / Campaign · UTMs
• MQL · same set, created on the Deal object
• Latest · same set + "Latest Attribution Completed" datetime
• Latest fields are pick lists ; original & MQL are free text stamped at the moment
• Salesforce — same shape
• Lead/Contact carry the same First / MQL / Latest field sets
• Push where there's API surface; otherwise workflow-stamp
• Opportunity gets its own attribution fields (see 2.5)
• Campaigns + campaign members carry the multi-touch (see 2.4)
• 1
• Latest touch is the living value — lock it down
• Every action with a lead-source component updates Latest via workflow. This is the

field that must be a restricted pick list , because everything downstream — MQL, opportunity — stamps off it.

• 2
• Original gets stamped once, when the record is new
• If the record was created recently (one client uses a 2-hour window ), Latest changed,

and Original is empty → write all Latest values into Original. After that it's frozen. First touch, captured.

• 3
• MQL stamps off Latest at the MQL moment

When the person hits the MQL stage, copy their current Latest values onto the MQL fields. It's the

least necessary of the three — it usually equals Latest anyway — so drop it if the team won't use it.

2.4 · Multi-Touch via Campaigns

First and Latest capture the ends. For everything in between, use campaigns — the standard way to hold the whole

multi-touch lifecycle. It's not weighted; it answers "how many things did they interact with before converting."

• 1
• Add to a campaign on every meaningful interaction

Clicked a LinkedIn ad, registered for a webinar, opened a sequence — each adds them to the matching

campaign, automatically where you can.

• 2
• Stamp the campaign-member fields at join time
• Channel, subchannel, campaign, and UTMs get written onto the campaign member at the

moment they join — a snapshot of where that touch came from. Simplify by creating campaigns per lead source and carrying channel/UTMs on the member.

• 3
• Report off membership + membership date

Pull every campaign a contact belongs to, ordered by membership date, and you have the full touch

timeline. HubSpot retains some of this natively; in Salesforce, campaign membership is your multi-touch record.

2.5 · Opportunity & Partner Attribution

Lead attribution feeds opportunity attribution. Keep it simple: attribute the opp off one person, and treat partners

as a channel with a little extra plumbing.

• Opportunity attribution
• Stamp from the primary contact

When the opp is created, copy Original + Latest source and channel from the primary contact

role onto the opportunity — plus a campaign lookup so campaign-influenced reporting works. You can append

every contact's values, but it gets convoluted fast; primary-contact is the standard.

• Partner attribution
• A channel, plus deal-reg plumbing
• Partners sit on channel / subchannel (Partner Referral). Set partners up as accounts with

deal-reg objects and unique tracking links; forms map back via lookup and auto-add to campaigns. Decide the credit rule up

front: net-new leads only, or also deal-regs on opps that already exist? Tools like PartnerStack / Allbound feed this.

Cutover — like every build

Ship quick fixes (a bad UTM mapping, a mis-tagged source) right away. But deep changes — new

workflows, the tracking code, field-model changes — go in after hours, when reps aren't in the system (Friday

afternoon / weekend), with the broader team briefed the Wednesday before.

• 3
• Phase 3

Attribution is the motion that dies fastest without enablement,

because it depends on human behavior every single day. The one message that has to land: this is not

set-it-and-forget-it. Every new source, campaign, or channel needs UTMs and a home in the taxonomy — or you lose visibility.

• 📄 Documentation
• Read
• The taxonomy + the tagging map
• How each source gets tagged, and by whom
• What "high-value action = MQL" means and who changes it
• 🎧 Audio brief
• Listen
• Every enablement gets a brief (ElevenLabs)
• People retain audio they'd skim as text
• This page's brief is the template
• 🗂️ The change log
• Maintain
• A living list of every active value that's live out there
• Deprecate a value → find the links that still use it
• The single artifact that keeps the taxonomy from rotting
• 3.1 · The Manual Motions

Not everything can be automated. A rep who meets someone at a booth and adds them from memory looks like sales

outbound forever. The manual paths need a written process and real buy-in on why it matters.

Give every manual path a template

A lead-list upload template with the required columns — "I talked to this person at this event"

• The rule for rep-created contacts (source, channel, campaign)
• The partner registration form → CRM mapping
• Sell the why, not just the how
• Untracked event leads make it harder to justify the event next year
• Bad tags don't just miss data — they misroute leads
• The team has to want clean attribution, or it won't happen
• 3.2 · Hyper-care Cadence

Same shape as every LeanScale cutover — pre-brief the team, flip it when the system's quiet, then hold office hours

while the first real touches flow through and surface what's missing.

• Wed · before
• Pre-brief

Walk the marketing + sales teams through what's changing and what they now own.

• Fri · 2pm
• Cutover

Flip the workflows & tracking code when reps are logging off.

• Mon · after
• Office hours

Watch the first live touches tag correctly; fix mappings in real time.

• Fri · +1 week
• Office hours

Confirm a full week of data is clean, then hand the change log to the owner.

• 3.3 · Clone the repo into their brain
• We clone this attribution repo for each customer. The taxonomy, the field map, the

tracking-code notes, and the tagging decisions all become part of their agent's context — so the next project on

that account, and every ad-hoc tweak, starts faster.

Name the owner on day one

Attribution without an owner rots in a quarter. Someone on the client side has to own the taxonomy, the change log,

and the "is this a new MQL action?" call.

Enablement isn't a handoff; it's compounding context. Teach the owner enough to add a source and

update the translator without us — and to know when to call us back.

• 4
• Phase 4

Be honest with the client: attribution generates more ongoing

work than almost anything we run. This is why mops teams look flat and bloated — some companies have a whole role just

keeping paid-social attribution correct. Not strategy. Just keeping it true. Maintain is about making that

cheap and, wherever possible, the client's job.

4.1 · Ad-hoc Triggers

None of these throw an error. They just slowly poison the report until nobody trusts it — which is why the change log

and a periodic audit exist.

• Fake direct traffic
• The #1 leak
• Empty UTMs read as "direct" — hiding the real source
• The tracking code is the antidote; verify it's still firing
• Untracked event leads
• Human element
• Reps adding contacts from memory → looks like outbound
• Enforce the lead-list template after every event
• Cookie denial
• Structural ceiling
• Consent-declined sessions break the trail
• Accept it — the model is "close to 100," not perfect
• Value sprawl
• Report-killer
• Free-text creep → 100 spellings of one channel
• Pick lists + the UTM builder keep it contained
• Stale links
• Silent drift
• A deprecated value still live in an old link
• The change log is how you catch it
• Silent expectation change
• Relationship
• The business evolves; nobody tells the implementer
• Owner + a standing check-in keep you in sync
• 4.3 · When to Revisit

Some maintenance is reactive; some has to be scheduled or it never happens. Do both.

• Event-based
• Revisit when the model changes
• New channel, event, source, or partner program
• A changed MQL definition or routing rule
• A new marketing motion the taxonomy doesn't cover
• Time-based
• Audit the values quarterly

On a clock, reconcile the change log against what's actually live — dedupe values that drifted,

retire what's dead, confirm the tracking code and translator still fire, and re-confirm the questions the exec team is

answering haven't moved. This is the work that keeps the report trustworthy.

What You Hand Over

The team gets this landing page with the brief, a one-paste prompt, and the template repo behind it. The client gets

a taxonomy, a wired field model, a UTM builder, the tracking code, and an owner who keeps it true.

For the team

The restricted UTM builder, the UTM→channel translator, and Sean's tracking-code snippet with its field-mapping notes — the compounding assets.

The bet

Attribution is our most maintenance-heavy motion — and that's exactly why a repeatable, opinionated playbook is

the edge. Anchor on the two questions, tag every touch at the source, include AI/AEO, and enable the client so

well they keep it true themselves. This gets us ~60% of the way — the rest we learn on every close-out and fold back in.

• ✓
• Closeout

When a Attribution engagement wraps, spend sixteen

minutes with the debrief agent. Teamwork already knows what got built and when. This is for the

part none of our systems can see — the call that could have gone either way, the thing the customer

wanted that you refused, the near-miss that never became an incident, and above all the places

this playbook turned out to be wrong. What comes out of it gets written back into this page.

Two minutes of thinking beats sixteen minutes of recall. Have these in your head —

you don't need notes, and you definitely don't need a script.

The taxonomy you actually shipped — how far it drifted from our standard, and what this customer's market forced you to add.

The entry points — how many they really had, and which one you nearly missed.

AI and AEO — whether those values are live and receiving data, or sitting empty waiting for someone to wire them up.

Sixteen minutes, one sitting. It's a voice conversation, so your browser will

ask for microphone access — use headphones or the agent will hear itself. Chrome is the safer bet

over Safari.

It's a craft debrief , feeding straight back into this playbook.

It is not an assessment. Nothing here goes near performance review.

It's attributed — Anthony reads it with your name on it.

"This took two weeks longer than it should have because of X" is the most useful thing

you can say . Say it.

No mic prompt? Check the padlock in the address bar — the browser may have blocked it.

Agent talking over you? Headphones. It's hearing itself through your speakers.

Still stuck? Message Anthony rather than burning fifteen minutes on it.

The transcript takes a moment to generate after you hang up. You'll get a recap

emailed to you.

• The debrief asks what you built that's worth reusing. This is where you actually hand it
• over — dashboards, field maps, flows, templates, scripts, spec docs. Files land in the

project's Drive folder; links go into the artifact register so the next person can find them.

Thirty seconds, and do it while the project is still in your head.

“I'll upload it later” is exactly how assets end up trapped on an account.

• Add an artifact →
• LeanScale · Delivery OS

The Attribution playbook — the internal standard for standing up lead, opportunity, and partner attribution: the

two-questions model, the standard taxonomy (with AI/AEO), the field package, and the tracking that makes every touch

reportable. Blueprint, Build, Enable, Maintain. Cookie-dependent tracking is close-to-100%, not perfect.

• Blueprint — questions, entry map, taxonomy
• Build — UTMs, tracking code, field package
• Enable — docs, manual motions, change log
• Maintain — triggers, drift & the audit
• www.leanscale.team