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

Marketing Analytics › Measurement Planning

Measurement Plan: From KPIs to Tracking Spec

Turn objectives into a measurement plan step by step: KPI tree, event definitions, dimensions, owners and the tracking spec developers implement.
Tutorialintermediate10 min readUpdated

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. GA4 (or the analytics tool in use), Tag Manager (GTM), 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.
  1. 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 lead, 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.

  2. 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.

  3. 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 (CVR); 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.

  4. 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_start and a form_submit with a parameter naming the form; "orders" needs purchase with transaction_id, value and currency. 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.

  5. 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 UTM 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.

  6. 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.

  7. 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.

  8. 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.

  9. 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.

  10. 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.

SectionContentsOwnerReviewed
Objectives and decisionsObjective, period, the decision it informs, the audience for its reportsObjective ownerQuarterly
QuestionsThe questions each objective raises when it movesObjective owner with analyticsQuarterly
KPI treeNodes, levels, formulas between levels, the system each node is read fromAnalytics leadQuarterly
Events and parametersEvent name, trigger, parameters, status (existing / change / new)Analytics leadEvery release
Dimensions and segmentsDimension, allowed values, carrier (parameter, UTM, user property), named segmentsAnalytics leadEvery release
Platform mapMetric, reference source, other sources, known differencesAnalytics lead with channel managersQuarterly
Identity and consentIdentifier strategy, consent states honoured, what is reported under eachAnalytics lead with privacy adviceOn rule changes
Owners and cadenceArtefact or metric, owner, verifier, frequency, next review dateMarketing operationsMonthly
Tracking spec linkPointer to the current version of the tracking planAnalytics leadEvery release
QA criteriaPer-event and plan-level acceptance checks, sign-off columnVerifierEvery release
Illustrative example — not a real result

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

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 metric 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.

Frequently asked questions

How is this different from the strategy guide on measurement plans?

The strategy guide decides what success means and which evidence the business will accept; it is written for the people who own objectives. This tutorial starts after those decisions and produces the working documents: the KPI tree, the event and parameter definitions, the platform mapping and the tracking spec that a developer implements. Read the strategy guide first, then follow the steps here.

How long should a measurement plan be?

Long enough that a developer and an analyst who were not in the room could implement and verify it without asking questions, and no longer. In practice that is a short narrative page plus a few tables: the KPI tree, the event list, the dimension list, the platform map and the owner table. If the document grows beyond what one person can review in a sitting, split the tracking detail into the tracking plan and keep the measurement plan as the summary.

Do I need a KPI tree if there is only one objective?

Yes, because even one objective has drivers, and the drivers are what the team can act on. A single lead target decomposes into traffic, conversion rate and lead quality, and each of those into further levers. Without the tree, the plan measures the outcome but cannot explain why it moved, which is the question the plan exists to answer.

Terms used on this page

Tools to try

Frameworks

Where this page is used

Part of these learning paths

Also related

Sources

  1. Google Analytics Help — Google Analytics Help

Related