What I learned building signal integrity across stacks when no one else would prioritize it.
Attribution Was Failing Because the Stack Was Fragmented, and Dev Didn’t Care
We weren’t missing tools. We had GA4, Segment, Webflow, GTM, and Zapier. What we didn’t have was a coherent system. Attribution was breaking because the architecture was split down the middle.
I had full control over Webflow, where I could manage forms, scripts, and Google Tag Manager integration freely. But a significant portion of the frontend was hardcoded, and that’s where things fell apart. Those pages didn’t pass attribution data. They had no storage, no UTM handling, and absolutely no developer interest in fixing it. Attribution was treated as “not a priority.”
This wouldn’t have been urgent if traffic was low. But as I scaled paid campaigns and organic inbound, attribution gaps became a blocker. People were converting, but the source data was vanishing midway. HubSpot defaulted everything to “Direct traffic,” and the stack was blind.
So I stopped escalating tickets and started thinking like a systems engineer. GTM was the only layer consistently present across both environments, and I used that as my entry point to architect a system that would actually hold together.
Attribution Breaks Between the Click and the CRM
Attribution doesn’t usually fail in analytics. It fails in the handoff. Between one stack and another. Between what gets tracked and what gets submitted. Between what’s stored in the browser and what reaches your CRM.
In our case, attribution died in these exact gaps:
- Between hardcoded landing pages and Webflow forms
- Between missing UTM data and fallback referrers
- Between GTM variables and HubSpot’s aggressive default logic
- Between people who click, and systems that forget
No single person caused this. But no one fixed it either. So I did.
I Built Attribution Infrastructure from the Only Layer I Could Control
The solution started with consistency across inconsistency. GTM was embedded across the entire environment, both Webflow and the hardcoded frontend. That made it the only viable backbone.
I wrote a layered attribution script in GTM that:
- Captured UTM parameters, referrer, and timestamp on entry
- Persisted data in both cookies and
localStorage - Followed a strict logic: current > session > fallback to first-touch
Every visitor got a fingerprint. Durable. Trackable. Stack-agnostic.
This wasn’t about elegance. It was about survival.
Webflow Became the Single Source of Truth
I couldn’t touch the hardcoded forms. I could control Webflow. So I made the strategic call: all real attribution would be anchored in Webflow forms.
Even if a user started on a static hardcoded page, their submission had to happen through Webflow. That’s where attribution logic would be injected, captured, and passed along.
Using GTM, I dynamically injected hidden fields into every Webflow form:
utm_source,utm_medium,utm_campaign,utm_term,utm_contentreferrer,first_visit,initial_landing_page
If attribution didn’t show up in Webflow, it was never real to begin with.
I Bypassed HubSpot’s Attribution Logic Completely
HubSpot’s native model was worse than inaccurate, it was dangerous. It labeled valuable leads as “Offline source: Zapier.”
So I threw it out. I passed attribution directly into custom HubSpot fields, routed through Zapier without interpretation. No default rules. No overwrites. Just clean, structured input.
Above that, I used Segment to track user-level traits. I enriched form submissions with identify() and track() events, stitched to the same attribution data. The result: CRM and analytics finally spoke the same language.
Security Reviews Forced Me to Build Like an Engineer
Every script was reviewed. No inline injections. No eval. No dependency bloat. Just scoped JavaScript, clean GTM triggers, and secure data handoffs.
I couldn’t rely on magic. Everything had to be intentional, and built with auditability in mind. The restrictions didn’t limit the work. They made it better.
By the Time It Was Live, Attribution Actually Meant Something
- Attribution survived even the most fragmented journeys
- Webflow became the only submission layer that mattered
- Zapier handed over clean payloads to HubSpot
- Segment stitched user traits without duplication
- Dev was no longer a blocker
- Security had no reason to say no
This wasn’t glamorous work. But it worked.
If You Want Attribution to Work, You Have to Build It Yourself
Attribution doesn’t live in dashboards. It lives in the infrastructure that nobody wants to maintain.
You don’t fix it by asking for reports. You fix it by tracing how data flows through your stack. By understanding what gets lost where. And by building systems that actually carry signal from click to CRM.
That’s not a tracking script. That’s architecture.
And if you want it to work, you better be ready to build it yourself.