Before you start
- Agreed objectives. The strategy guide to building a measurement plan and its companion on objectives produce the inputs: what the business is trying to achieve, in what period, and what evidence it will accept. If those are not written down, stop and write them; this tutorial cannot invent them.
- Access to the systems. GA4Google's event-based analytics platform. (or the analytics tool in use), Tag Manager (GTMTag management system.), the ad platforms, the CRM or order system, and whoever owns the website code.
- An inventory of what already exists. Current events, conversion definitions, UTM rules and dashboards. The plan will reuse, rename or retire each of them, and that is easier when the list is in front of you.
- A working document. A shared spreadsheet or a page in the team wiki, with one tab or section per artefact. The template at the end of this page lists the tabs.
- The people. Whoever owns objectives, whoever will implement tracking and whoever will read the reports. Each step below names who signs off on it.
Write the objectives and the decisions they serve
Copy each objective from the strategy work into the plan, one row per objective, and add a column that most plans miss: the decision this objective informs. "More qualified leads" informs budget allocation between channels and the sales team's capacity planning; "higher first-purchase conversion" informs the checkout roadmap and the merchandising calendar. Where qualified means a sales-qualified leadA lead that sales has reviewed and accepted as a genuine opportunity to pursue., record who confirms it and against which criteria. Writing the decision down does two things. It exposes objectives that inform no decision, which are vanity and should be removed, and it fixes the audience and cadence for every number that follows, because a decision made monthly does not need a daily metric. Sign-off belongs to the objective owner.
Turn each objective into questions
For each objective, list the questions a reasonable person would ask when it moves. If leads fall, is it fewer visitors, fewer of them converting, or a change in which channel they came from? If revenue rises, is it more orders or larger ones? Write the questions in plain language before any metric is named; this is the step where a plan earns its explanatory power. Three to six questions per objective is usual. Each question will become a branch of the KPI tree in the next step, and a question with no plausible metric behind it is a finding in its own right: either the business needs a new data source or the question needs rewording.
Build the KPI tree
Arrange the objective at the top, the questions beneath it as outputs, and the metrics that answer each question beneath those as drivers. State the arithmetic between levels explicitly — orders equal sessions multiplied by conversion rate (CVRShare of visits or clicks that convert.); leads equal form views multiplied by form completion rate — so that a change at the top can be traced down. The KPI trees guide covers the decomposition method and the input-versus-output distinction in depth; the conversion rate calculator is useful for sanity-checking a branch. For this plan, the output is one tree per objective with every node named, its formula stated and its level marked. The analytics lead signs off that the arithmetic holds.
Define events and parameters
Every leaf of the tree needs an observation behind it, and in event-based analytics that observation is an event with parameters. For each driver, write the event that proves it happened, the parameters that qualify it and the moment it fires. "Form completion rate" needs a
form_startand aform_submitwith a parameter naming the form; "orders" needspurchasewithtransaction_id,valueandcurrency. Prefer documented recommended event names where one fits, because reports and integrations expect them, and reserve custom names for things the recommended list does not cover. The GA4 events and parameters guide explains the mechanics; here, record only the definition, the trigger condition and the parameters. Mark each event as existing, to be changed or new.Define dimensions and segments
Decide how every number will be cut before deciding where it lives, because the cut determines what has to be captured. Channel and campaign (from UTMURL tags identifying traffic source. parameters and auto-tagging), market or language, device category, landing page group, new versus returning, customer type from the CRM, product category — list each dimension, its allowed values, and the event or source that carries it. Then define the segments the objective owners will ask about by name: "paid non-brand", "returning customers", "trial accounts". A segment is a saved filter on dimensions; if it cannot be expressed from the dimension list, the list is incomplete. This step usually surfaces the need for a custom parameter or a user property that the event list did not include; go back and add it.
Map each metric to a platform and a source of truth
For every node in the tree, name the system that reports it and, where more than one does, which is the reference. Spend, impressions and clicks come from the ad platforms; sessions and on-site behaviour from analytics; revenue and customer status from the order system or CRM; platform conversions from the platform and analytics conversions from analytics, and the two will not match. The KPI framework reference lists standard definitions to align to. Record, next to each mapping, the known reasons the alternatives differ, so the reconciliation conversation is answered in the plan rather than rehearsed in a meeting. The output is a platform map with one row per metric.
Decide identity and consent handling
Write down how a person is recognised across sessions and devices (a user identifier passed on login, the analytics client identifier only, or a CRM key), which consent states the site honours, and what the plan promises when consent is declined. This decides what the numbers mean: a conversion rate computed on consented sessions is a different metric from one that includes modelled data, and the plan has to say which one it reports. Involve whoever advises on privacy, because the rules vary by jurisdiction and this tutorial does not give legal advice. The privacy and consent guide covers the design choices; record the decisions here and the implementation detail in the tracking plan.
Assign owners and cadence
Every artefact and every metric gets a name, not a team. The plan itself has an owner and a review date. Each event has an implementer and a verifier, and they should be different people. Each report has an audience and a frequency drawn from the decisions recorded in the first step: a weekly operational view for channel managers, a monthly view for the people who own objectives, a quarterly review of the plan itself. Add a cadence for the data quality check, with its own owner. The point of the table is that when something breaks or drifts, the question "who looks at this?" already has an answer, and the review date stops the plan from being a launch artefact that nobody opens again.
Hand off the tracking spec
Extract the implementation detail into a tracking spec for the developer and the Tag Manager owner: event name, trigger condition, parameters with types and example values, data layer structure, page or template where it fires, consent dependency, and the status of each row. The tracking plan guide describes the columns and the change control around them; the measurement plan links to the tracking plan rather than duplicating it. Walk the developer through the spec once, record the questions they ask, and fix the spec rather than answering verbally. A spec that needed a conversation to be understood will be misread by the next developer who inherits it.
Write the QA criteria
For each event, state what "verified" means: the event appears in the debug view with the expected parameters when the action is performed, it does not fire on page load or on repeat visits where it should not, the parameter values match the data layer, the conversion or key event registers once, and the number in the standard report after a day is plausible against the order system or CRM. Add plan-level criteria: every tree leaf has a working event, every dimension populates, every report pulls from the mapped source, and the consent states behave as documented. Launch is blocked until the verifier signs each row. Keep the criteria; they become the regression checklist for every later release.
Plan template
The finished plan is a short narrative plus the tables below. Keep each as a separate tab or section; they change at different rates and are read by different people.
| Section | Contents | Owner | Reviewed |
|---|---|---|---|
| Objectives and decisions | Objective, period, the decision it informs, the audience for its reports | Objective owner | Quarterly |
| Questions | The questions each objective raises when it moves | Objective owner with analytics | Quarterly |
| KPI tree | Nodes, levels, formulas between levels, the system each node is read from | Analytics lead | Quarterly |
| Events and parameters | Event name, trigger, parameters, status (existing / change / new) | Analytics lead | Every release |
| Dimensions and segments | Dimension, allowed values, carrier (parameter, UTM, user property), named segments | Analytics lead | Every release |
| Platform map | Metric, reference source, other sources, known differences | Analytics lead with channel managers | Quarterly |
| Identity and consent | Identifier strategy, consent states honoured, what is reported under each | Analytics lead with privacy advice | On rule changes |
| Owners and cadence | Artefact or metric, owner, verifier, frequency, next review date | Marketing operations | Monthly |
| Tracking spec link | Pointer to the current version of the tracking plan | Analytics lead | Every release |
| QA criteria | Per-event and plan-level acceptance checks, sign-off column | Verifier | Every release |
A B2B software company's plan in numbers
A software company sells annual licences and runs 2 objectives: 400 sales-qualified leads a quarter and a
demo-to-trial rate above 35%. The questions step produced 9 questions; the tree has 2 outcome nodes, 5
outputs and 12 drivers. The event list runs to 14 rows: 6 existing events kept, 3 renamed to match
recommended names, 5 new, including generate_lead with a lead_type parameter and a demo_booked custom
event. Dimensions: 7, including a plan_tier user property set on login. The platform map names the CRM as
the source of truth for lead counts, GA4 for on-site rates and the ad platforms for spend. The tracking
spec handed to the developer had 14 rows and 3 open questions, all resolved in writing within 2 days; QA took
1 afternoon, and 2 events failed first time because they fired on page load. Launch was 1 week after the
plan was signed.
If the objective is enquiries rather than online sales, the lead generation measurement plan shows how the chain extends from the form into CRM stages and back to ad platforms.
Verify it worked
- Read the objectives table. Every objective should name the decision it informs and an owner who signed it off.
- Trace a change from the top of each KPI tree to its drivers. Every node should have a name, formula, level and reference source.
- Match the event list to the tree leaves. Every leaf should have an event with a trigger and parameters, marked existing, change or new.
- Test each named segment against the dimension list. Each should be a saved filter on listed dimensions.
- Hand the spec to the developer and the verifier. They should work without a meeting, and the verifier should not be the implementer.
If it goes wrong
- An objective informs no decision. It is probably a vanity metric. Rewrite it around a decision or remove it.
- A question has no plausible metric. Either the business lacks a data source or the question needs rewording. Decide which.
- A tree level does not multiply or add up. The decomposition is probably wrong. Restate the arithmetic between levels.
- A segment cannot be expressed from the dimension list. The list is incomplete. Add the custom parameter or user property, then return to the events step.
- An event fails QA, for example by firing on page load. The trigger condition is probably wrong. Fix the spec rather than explaining it aloud, then verify again.
Next steps
- Read the tracking plan guide to see the spec columns and the change control around them.
- Read the KPI trees guide when a branch will not decompose cleanly; it covers inputs versus outputs.
- Read the GA4 events and parameters guide to check recommended event names before you create custom ones.
- Return to the strategy guide to measurement plans when the agreed objectives or accepted evidence change, because this method cannot supply them.
Common mistakes
- Starting with the tool. Opening the analytics interface before the questions are written produces a plan shaped by what the tool shows, not by what the business decides.
- Objectives with no decision attached. A number nobody acts on is a vanity metricMetrics that look impressive but do not inform a decision or track a business outcome. however well it is tracked.
- Skipping the arithmetic. A tree whose levels do not multiply or add up cannot explain a movement.
- One name for an event in the plan and another in the container. The tracking plan exists to prevent this; link to it rather than paraphrasing it.
- Implementer and verifier are the same person. The assumptions that shaped the build shape the test.
- No review date. A plan without a date on it is a launch artefact, not a living document.
- Ignoring consent until QA. Decide what the numbers mean under each consent state before the first report is built, or every report will carry a footnote nobody reads.
