Skip to content
Faisal Mahmud TusherDigital marketing, SEO & analytics
with Faisal Tusher

Marketing Analytics › Measurement Planning

Tracking Plans

What a tracking plan is, the columns it needs, event naming, versioning and change control, QA sign-off, and keeping the plan and implementation in sync.
Guideintermediate11 min readUpdated

What a tracking plan is for

The measurement plan decides which questions matter and which metrics answer them. The tracking plan takes each metric's leaf — "form completion rate", "orders", "demo bookings" — and specifies the observation behind it precisely enough that a developer can implement it, a Tag Manager (GTM) owner can configure it and an analyst can test it, none of them needing to ask what was meant. It is a specification, and like any specification it is judged by whether two people reading it would build the same thing.

It also serves three later purposes. It is the reference when a number looks wrong, because it says what the event should do and someone can compare that with what it does. It is the onboarding document for whoever inherits the implementation. And it is the audit baseline: the list the live container and the live reports are checked against. A plan that is written once for launch and never opened again does the first job for a while and the other two not at all.

What it is not: a strategy document, a report design or a tool manual. Strategy lives in the measurement plan; report design lives with the reporting layer; the mechanics of events in GA4 and of the data layer in Tag Manager live in the events and parameters guide and the data layer guide. The tracking plan references them and specifies; it does not teach.

The columns

One row per event. The columns below are the minimum that lets implementation and verification happen without conversation; add columns for your context (market, app platform, consent category) but do not remove these.

ColumnWhat it holdsWhy it is needed
Event nameThe exact string sent, in the agreed case and separator styleThe key everything else hangs on; a typo here is a new event
DescriptionOne sentence: what user action or system state the event recordsPrevents two people reading the name differently
TriggerThe precise condition: element, page, state, response — and what must not trigger itMost QA failures are triggers firing on load, on repeat or on the wrong template
ParametersEach parameter name, type, allowed values and an exampleParameters are where meaning lives; untyped parameters produce unusable reports
SourceData layer push, DOM scrape, server call, platform native eventDecides who implements it and how fragile it is
LocationPage templates or screens where it can fireScopes QA and tells the developer which code to touch
FeedsThe metric or KPI node this event supportsAn event that feeds nothing is a candidate for retirement
DestinationsWhich tools receive it (analytics, ad platforms, CRM) and whether it is a key event or conversionDifferent destinations have different naming and consent constraints
Consent categoryWhich consent state the event depends onMakes the behaviour under declined consent explicit
Owner and verifierNamed people, different from each otherAccountability for the build and for the check
Status and versionProposed, approved, implemented, verified, deprecated; the plan version it changed inThe lifecycle column; without it, nobody knows what is live
NotesEdge cases, known limitations, links to ticketsThe place for everything that would otherwise be a verbal aside

A data layer specification sits beside the parameter column, either inline or in a linked section, so that the developer sees the exact object to push. A push with no digits in it can be shown directly:

dataLayer.push({
  event: "form_submit",
  form_name: "contact",
  form_location: "footer",
  form_type: "enquiry"
});

Every parameter in the push appears in the parameter column with its type and allowed values, and nothing in the push is absent from the plan.

The plan is also the place for the rule that no parameter carries personal data, together with the list of query keys the container strips from page addresses; the guide to keeping personal data out of analytics explains the routes that rule closes.

Event and parameter naming rules

Naming has two sources of rules: what the destination tool allows and what your convention requires. GA4 documents the format for event names and parameter names on its help pages: names are case-sensitive, are built from letters, digits and underscores, must begin with a letter, and must avoid the reserved prefixes and reserved names the documentation lists. The documentation also sets limits on name length and on the number of distinct custom events and parameters a property can register; state the documented limit in the plan by linking to the help page rather than copying a figure that may change.

Within those constraints, the convention does the rest. The rules that have held up across many teams:

  • Use the recommended event name when one fits. purchase, add_to_cart, generate_lead, sign_up, login and view_item are read by standard reports and by integrations; a custom synonym is invisible to them.
  • Object then action for custom events, in snake_case: form_submit, video_progress, filter_apply. Keep the vocabulary of objects and actions short and listed in the plan, so that nobody invents submit_form beside form_submit.
  • Parameters describe, events announce. One form_submit event with a form_name parameter, not a separate event per form. The event list stays short and the reports cut by parameter.
  • Lower case everywhere, underscores only. Mixed case and hyphens create duplicates that look identical in a spreadsheet and are different in the tool.
  • No values in names. cta_click_hero encodes a location in the name; cta_click with cta_location: hero is the same information in a usable form.
  • Reserve a prefix for test events and strip them before launch, so test data cannot be mistaken for real data in a report.

The same discipline applies to campaign naming, which the UTM and naming conventions guide covers; the two conventions should share their separator and case rules so that a reader moving between the event list and the campaign list meets one style.

Versioning and change control

A tracking plan changes with every release that touches tracked behaviour, and the changes have to be visible. The minimum is a version number on the plan, a change log that records what changed, why, who approved it and when it went live, and a status column per row that moves through a fixed sequence: proposed, approved, implemented, verified, deprecated.

Change control is the process that moves a row between those states. A proposed change — a new event, a renamed parameter, a retired trigger — is written in the plan first, reviewed by the analytics owner for consistency with the convention and the measurement plan, and only then handed to implementation. Renames deserve particular caution: renaming an event in GA4 breaks the continuity of every report that used the old name, and the documentation describes how modified and created events behave; the plan should record the cut-over date and the old name so that a reader of historical reports can reconcile the two series.

Deprecation is a state, not a deletion. A deprecated row stays in the plan with the version in which it was retired and the reason, because someone will find the event in historical data and need to know what it was. Deleting rows is how plans lose their memory.

Where the plan lives in the same repository as the site code, change control can ride on the code review: the pull request that changes the data layer also changes the plan, and a reviewer can reject a mismatch. Where it lives in a spreadsheet, a release checklist item — "tracking plan updated and version bumped" — does the same job less automatically.

QA and sign-off workflow

A row is not done when it is implemented; it is done when someone other than the implementer has verified it against the plan. The workflow has four stages.

Preview. The implementer tests in the tag manager's preview mode and in the analytics debug view, performs the action, and confirms the event appears once with the expected parameter values. Common failures at this stage: the event fires on page load, fires on every step of a multi-step form, carries an empty parameter or sends a value of the wrong type.

Negative tests. The verifier performs the actions that must not fire the event — reloading the confirmation page, navigating back, submitting an invalid form — and confirms silence. Negative tests are where double counting is caught before it reaches a conversion rate (CVR) report.

Staging to production. The container version is published with a description that names the plan version it implements. The verifier repeats the positive and negative tests on the live site, because production templates, consent banners and caching differ from staging.

Report check. After a day, the verifier confirms the event appears in standard reports with populated parameters and, where it is a key event or conversion, that it registers once per action. The row moves to verified, with the date and the verifier's name.

Illustrative example — not a real result

A release that failed QA and what the plan caught

A retailer's tracking plan version 2.4 added add_to_wishlist with item_id, item_category and value. The implementer's preview showed the event firing with all 3 parameters. The verifier's negative tests found it firing a second time when the mini-basket drawer closed, so a single click produced 2 events, and on 1 of the 4 product templates the value parameter arrived as the string "£24.00" instead of the number 24. Both were trigger and data layer problems the plan's trigger and type columns had specified correctly; the implementation had drifted from them. The row went back to implemented, the fix shipped in container version 31 with the plan version in its description, and the report check a day later showed 212 events for 211 clicks recorded in the site's own logs — within the plan's tolerance. Without the negative test the wishlist rate would have reported at double its true value for as long as nobody questioned it.

Keeping plan and implementation in sync

Drift is the default. Containers are edited under pressure, developers rename data layer keys during refactors, and marketing adds a tag for a new platform without telling the analyst. A plan that was accurate at launch becomes fiction within months unless a routine compares it with reality.

Three checks, on a schedule, keep them aligned:

  1. Container against plan. Export the list of tags, triggers and variables from the container and check that every tag maps to a plan row and every plan row that should be live has a tag. Unmapped tags are either undocumented additions or leftovers to remove.
  2. Reports against plan. List the event names seen in analytics over the period and compare with the plan's event column. Names that appear in the data but not in the plan are the most common drift: a developer's test event, a misspelt variant, a platform's automatic event nobody noticed. Names in the plan but absent from the data are broken or never implemented.
  3. Data layer against plan. On each template in the location column, inspect the data layer and confirm the keys and types match the parameter column. Refactors change this silently.

The cadence depends on release frequency: after every release that touches tracked templates, and at least monthly otherwise. The weekly routine in the data quality guide covers the shallower daily-health checks; the three above are the structural ones. Record each check's date and findings in the plan's change log, so that the plan carries its own evidence of being current.

Ownership makes this stick. The plan has one owner whose name is on it, and that person is consulted before any tag, trigger or data layer change — not because they must approve every edit, but because the plan has to be updated by someone who knows it exists. The measurement governance playbook puts these checks, the release gate and the weekly data quality check into one calendar with an owner for each. When the plan's owner or the agency behind it changes, the GA4 property handover checklist makes handing over the plan, with every event and parameter in use, one of its first checks. The measurement planning hub places this routine in the wider sequence of artefacts.

App tracking ships inside releases rather than tag containers, and the measurement plan for app installs explains how that changes event timing, ownership and quality checks. For apps, the release checklist item becomes a check of the build itself, which the tutorial on checking app events on every release walks through against the plan before each version ships.

The plan defines the events; the connections that carry them onwards, from the CRM and the shop into the warehouse and out to ad platforms, belong in a separate register of marketing integrations that points back to the plan's event names.

Common mistakes

  • Treating the plan as a launch deliverable. It is a living specification; the version column and the sync checks are what make it one.
  • Writing the trigger vaguely. "On form submit" is not a trigger; "on the success response of the contact form on the enquiry template, not on validation errors" is.
  • Untyped parameters. A parameter without a type and allowed values will arrive as whatever the developer had to hand.
  • Encoding values in event names. One event per button creates a list nobody can report on; one event with a parameter does the job.
  • Implementer verifies their own work. Separate names in the owner and verifier columns, always.
  • Deleting deprecated rows. Historical data references them; keep them with a deprecated status.
  • Letting the container become the plan. The container is the implementation. When it is the only record, nobody can say what the implementation was supposed to be.

Frequently asked questions

Is a tracking plan the same as a measurement plan?

No. The measurement plan says what the business wants to know and which metrics answer it; the tracking plan says exactly which events and parameters produce those metrics and how they are implemented. The measurement plan changes when objectives change; the tracking plan changes with every site release. Keeping them separate lets each be reviewed by the right people at the right rate.

Where should the tracking plan live?

Anywhere the developers, the Tag Manager owner and the analyst all read, with a version history. A shared spreadsheet is the most common choice and works well for small teams. Larger teams often keep it in the same repository as the site code or in a dedicated schema tool, so that a change to the plan can be reviewed alongside the change to the code that implements it.

How many events should a tracking plan contain?

As few as answer the measurement plan's questions, which for most sites is a short list rather than a long one. Every event costs implementation time, QA time and a row in every future audit. A plan that tracks every click because it might be useful later tends to produce data nobody trusts and nobody uses; add events when a question needs them and retire events when nothing reads them.

Terms used on this page

Frameworks

Where this page is used

Also related

Sources

  1. [GA4] About events — Google Analytics Help
  2. The data layer — Google Tag Platform

Related