The lead that disappeared: following one click from ad to CRM

Most attribution problems get reported the same way: "The ads say we got leads, the CRM says we didn't, and nobody trusts either number." The usual response is to argue about which dashboard is right. I've learned to do something more boring and more useful. I follow one click, by hand, from the ad all the way into the record where the lead lives, and then back to the ad platform.

I've spent years doing lead generation in legal search, including mesothelioma, where clicks are among the most expensive on Google. In a market like that, a lead that loses its source is not a reporting nuisance. It's money you can't account for, and it quietly trains your bidding on bad data. The fix is almost never a new tool. It's finding the one hop where the data falls on the floor.

Here is the path, hop by hop, and where each one tends to break.

Hop 1: the landing URL

When someone clicks a Google Ads ad with auto-tagging on, Google appends a click identifier to the landing URL, the gclid parameter (on some iOS traffic you may see gbraid or wbraid instead). Meta adds fbclid. On top of that, you should be adding your own UTM parameters so every source, not just paid search, is labeled consistently:

https://example.com/free-case-review?utm_source=google&utm_medium=cpc&utm_campaign=brand-core&gclid=EAIaIQ...

The first thing to check is whether that URL survives the trip to the page. It often doesn't:

• Redirects that drop the query string. An old http to https rule, a trailing-slash rule, a vanity URL, or a plugin redirect that rebuilds the URL without its parameters.
• Landing pages that immediately bounce to a different page, such as a geo-redirect or a "thank you for visiting" splash.
• Inconsistent UTMs. Google, google, and google.com become three sources in your reports. Pick a convention and write it down.

Test: click a real ad (or paste a tagged URL), then look at the address bar after the page finishes loading. If the parameters are gone, nothing downstream can recover them.

Hop 2: capturing the source before it's gone

A URL parameter only exists on the page where it arrived. Visitors don't convert on that page as often as we'd like. They read an FAQ, check the about page, come back tomorrow. By the time they fill out a form, the gclid is no longer in the address bar.

So on arrival, a small script should read the parameters and store them first-party: a cookie on your own domain or local storage. Then, when any form loads, the script writes those stored values into hidden fields. A few decisions matter here:

• First touch or last touch? Decide whether a new tagged visit overwrites the stored values. Many teams store both.
• How long to keep them. Match it roughly to your sales cycle, and know that some browsers limit how long script-set cookies persist.
• Consent. If your consent setup says a visitor declined, respect it. That's a legal question as much as a technical one.

Hop 3: the form submission

This is where I find the most breakage. The hidden fields exist, but:

• They were added to one form and not the other four.
• The form builder has its own dynamic-population setting that conflicts with the script.
• A form rebuilt last quarter dropped the hidden fields entirely.
• The form is in an iframe from another domain, so it can't read your cookie at all.

Test: submit a real form from a tagged URL, after visiting two or three other pages first. Then open the entry itself, not an analytics report, and check that the source values are sitting there.

Hop 4: into the CRM or intake system

The form entry has the data. Now it has to arrive in whatever system the business actually works from: a CRM, a legal intake system, a case-management platform. Often there's a connector in between, a native integration or something like Zapier or Pipedream.

The common failure is dull: field mapping. The integration was set up with name, email, phone, and message, and nobody mapped the five hidden fields. Or the CRM has no field to receive gclid, so it got stuffed into a notes blob where it can't be used. Or an intake person creates a new record by hand from a phone call, and the web record with the source data becomes an orphaned duplicate.

Phone leads deserve their own mention. If a large share of your leads call instead of filling a form, and nothing ties the call back to a source, your attribution is missing a whole channel. Call tracking with dynamic numbers is one way to address it; at minimum, intake should ask and record how the caller found you, and you should know that answer is less reliable.

Hop 5: sending the outcome back

The loop isn't closed until the ad platform learns what happened. A form fill is a raw lead. A signed client is the outcome the business cares about. Google Ads lets you import offline conversions tied to the original click, and Meta accepts server-side events. When those imports carry the real outcome, the platforms can optimize toward leads that turn into business instead of leads that merely submit a form.

This hop only works if every hop before it kept the identifier. That's the whole point of walking the chain.

The checklist

When I audit a lead path, this is roughly the list:

1. Every paid destination URL loads with its parameters intact after all redirects.
2. UTM naming is documented and consistent across channels.
3. Source values are stored first-party on arrival and survive a multi-page visit.
4. Every lead form has the hidden fields, populated and tested.
5. A test submission shows the values in the raw form entry.
6. The integration maps each source field to a real CRM field, not a notes blob.
7. Manually created and phone-originated records have a defined source process.
8. Duplicates between web and manual records are merged, not ignored.
9. Qualified and signed outcomes are exported back to the ad platforms.
10. Someone re-runs this test after every form, site, or integration change.

That last item is the one that slips. The chain was correct once, then someone rebuilt a landing page.

Why I start here

I wrote about the broader pattern in every web problem eventually becomes a systems problem. Attribution is the clearest example I know. The ad platform, the website, the form, the connector, and the CRM each look fine in isolation. The failure lives in the handoffs between them.

If it isn't measured, you're guessing. And if you haven't followed a single click through every hop yourself, you don't really know what's being measured. Do it once with a test lead this week. It usually takes less than an hour, and it tends to answer questions that months of dashboard arguments didn't.