End-to-End Marketing Tracking & Measurement System

An end-to-end tracking, CRM, and reporting pipeline for a fictional product launch — instrumented with GTM and GA4, connected to HubSpot, automated with Make.com, and deliberately broken eight different ways to prove the debugging holds up. Built entirely on free-tier tools.

The actual pipeline this page describes — every arrow is a real, tested connection, not a diagram of an intention.

Marketing and CRM teams typically see only half of the customer journey each. Web analytics captures anonymous behavior; the CRM captures identified leads. Without a deliberate architecture connecting the two, neither side can reliably answer the question that actually matters: which campaign produced this lead. I built this system to design and implement that connective architecture end to end, entirely on free-tier tooling.

Governed GA4 event tracking through Google Tag Manager — not hard-coded scripts, not Enhanced-Measurement-only.

A UTM naming convention that survives intact from an ad click through to a CRM record and a report.

Leads captured in HubSpot with real source and campaign attribution, not just a name and an email.

CRM-to-spreadsheet automation with Make.com, so nothing depends on manual copy-paste.

One dashboard answering six specific business questions — and a system I could prove was actually working.

The system runs as two deliberately separate tracks, meeting only at the reporting layer.

The real, live Google Merchandise Store GA4 demo account, used read-only to validate measurement-plan decisions against a mature, production ecommerce implementation. Nothing here was ever edited.

Waypoint Supply Co., an original fictional brand built specifically so every layer — code, tags, CRM, automation — was mine to instrument, test, and break on purpose.

Campaign attribution is joined at the campaign level — shared UTM values — not the user level. GA4 and HubSpot never share a native user identity on this stack, and the architecture was built around that constraint rather than pretending it away.

Seven tags across three folders. Native Click and Element Visibility triggers everywhere one existed, with one deliberate exception: a Custom HTML listener bridging HubSpot's cross-origin iframe submission events into the Data Layer, since no native GTM trigger can read postMessage traffic.

The full tag list — one Custom HTML tag, six native GA4 tags. No stray duplicates.

Enhanced Measurement audited, not just switched on — Form interactions deliberately disabled to avoid a second, unreliable count of form activity. Custom dimensions registered for every event parameter that needed to be reportable, one Key Event, one behavioral audience.

Free CRM, five custom properties mirroring the UTM taxonomy exactly, a two-field form kept deliberately short. Campaign attribution captured via HubSpot's native query-string auto-populate — chosen after confirming HubSpot's current default form architecture blocks the classic JavaScript approach most tutorials still describe.

One scenario: a router that splits incoming leads by whether they carry campaign data, logs both outcomes, and includes an error handler I forced to fail on purpose to confirm it actually catches a failure instead of losing a lead silently.

The router in production — both branches logged, both running on a 15-minute schedule.

A six-tab Google Sheets operational layer feeding a twelve-chart Looker Studio dashboard, structured around six real business questions rather than built to look impressive.

QA happened in two layers: a systematic pass across every system, then eight failures introduced on purpose and diagnosed from their actual symptoms — not from already knowing the cause.

GA4 Realtime, mid-session — teaser_view → teaser_view → form_view, firing in the order the funnel expects.

Mistyped event name — silently created an unrecognized event; caught via a funnel step reading zero. Fixed, verified.

Duplicated trigger on one tag — one click fired the tag twice; caught by counting fires in Preview. Fixed, verified.

Wrong event marked as a Key Event — inflated the conversion count with a funnel-stage signal, not an outcome. Fixed, verified.

Inconsistent UTM casing — split one channel's data into two report rows. Confirmed unrecoverable retroactively; documented as a standing risk of manual tagging.

HubSpot property internal name mismatch — a hidden field stayed silently blank with no error anywhere. Fixed, verified.

Inverted Make.com filter — valid leads were dropped with nothing overtly labeled as an error. Fixed, verified.

Forced automation failure — confirmed the error handler logs a failed run instead of losing the record.

Broken dashboard formula — caught by two independently-sourced totals that should always agree, and didn't. Fixed, verified.

A portion of historical generate_lead events fired without a form ID attached. I ruled out GTM tag duplication and consent-mode interference, and narrowed it most likely to residual noise from an earlier troubleshooting session — but I didn't get a clean, isolated reproduction before mitigating it in the dashboard's reporting window. It's logged as an open item, not quietly patched over.

The actual evidence: 123 fires, 11 users, 112 with no Form ID attached — this is what "not fully resolved" looks like, not a guess.

Measured: every layer of the pipeline is independently checkable — GTM Preview and GA4 DebugView confirm correct event firing with correct parameters, HubSpot contact records show correctly populated campaign attribution, the Make.com scenario runs autonomously on schedule with a working error path, and the dashboard is live and public. All eight deliberately introduced failures were diagnosed and resolved.

This is a live environment rather than a fixed dataset, so exact lead-volume numbers are visible on the dashboard itself at any given time, rather than quoted here as a static figure.

The dashboard itself — headline stats, the Data Quality summary, and the QA test log, all live.

On business impact: this is demonstrated capability, not measured business impact — there's no real company or customer base behind Waypoint Supply Co. What's genuinely demonstrated is a system that, applied to a real launch, would attribute leads to specific campaigns and channels, log every submission without manual entry, and surface tracking breakage before it quietly corrupts a quarter of reporting.

The instructive ones weren't the ones I expected going in. HubSpot's current default form architecture broke the JavaScript approach I initially planned for capturing UTM data, forcing a redesign around a native auto-populate mechanism instead. A Make.com field-mapping issue meant most early test submissions logged only a timestamp, not full lead data, until I traced it to an unresolved mapping step.

GA4 and HubSpot share no native user-level identity — attribution works at the campaign level only.

No true "form started" signal exists, since HubSpot's documented callbacks don't expose field-level interaction events.

Campaign traffic is simulated — manually visited tagged links, not real ad spend.

Free-tier ceilings are real: 1,000 HubSpot contacts, 15-minute minimum Make.com polling, ~15-minute Looker Studio data freshness.

Conclusively resolve the open generate_lead anomaly with a clean, monitored reproduction.

Integrate a real ad platform to replace simulated UTM traffic with actual spend data.

Move toward server-side tagging for genuine user-level attribution between GA4 and HubSpot.

Turn the eight failure scenarios into a repeatable regression-test suite.