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 (GTMTag management system.) 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.
| Column | What it holds | Why it is needed |
|---|---|---|
| Event name | The exact string sent, in the agreed case and separator style | The key everything else hangs on; a typo here is a new event |
| Description | One sentence: what user action or system state the event records | Prevents two people reading the name differently |
| Trigger | The precise condition: element, page, state, response — and what must not trigger it | Most QA failures are triggers firing on load, on repeat or on the wrong template |
| Parameters | Each parameter name, type, allowed values and an example | Parameters are where meaning lives; untyped parameters produce unusable reports |
| Source | Data layer push, DOM scrape, server call, platform native event | Decides who implements it and how fragile it is |
| Location | Page templates or screens where it can fire | Scopes QA and tells the developer which code to touch |
| Feeds | The metric or KPIA metric tied directly to an objective. node this event supports | An event that feeds nothing is a candidate for retirement |
| Destinations | Which tools receive it (analytics, ad platforms, CRM) and whether it is a key event or conversion | Different destinations have different naming and consent constraints |
| Consent category | Which consent state the event depends on | Makes the behaviour under declined consent explicit |
| Owner and verifier | Named people, different from each other | Accountability for the build and for the check |
| Status and version | Proposed, approved, implemented, verified, deprecated; the plan version it changed in | The lifecycle column; without it, nobody knows what is live |
| Notes | Edge cases, known limitations, links to tickets | The 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,loginandview_itemare 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 inventssubmit_formbesideform_submit. - Parameters describe, events announce. One
form_submitevent with aform_nameparameter, 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_heroencodes a location in the name;cta_clickwithcta_location: herois 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 (CVRShare of visits or clicks that convert.) 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.
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:
- 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.
- 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.
- 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.
