Fundamentals

A Measurement Plan Before You Tag: The Template

A Measurement Plan Before You Tag: The TemplateMeasurement planGoalEventParametersgrow revenuepurchasevalue, itemscapture leadsgenerate_leadform_id, valuesite searchsearchsearch_term

The teams with clean analytics almost never started by opening GTM. They started with a measurement plan, a short document that says what the business needs to know, which events answer that, and what data each event carries. Skip it and you get a container full of half-tracked events nobody trusts. Here's the template.

Why plan before you tag

Without a plan

  • Events added ad hoc, named inconsistently
  • No one agrees what a 'conversion' is
  • Reports can't answer the real questions
  • Re-tagging later costs more than planning would have

With a plan

  • Every event traces to a business question
  • Consistent names and parameters
  • Developers get one clear spec
  • Reports are trusted because the data is intentional

Step 1: business goals → events

Start from what the business is trying to achieve, not from what's easy to track. Work down from goal to question to the event that answers it.

  1. Goal: e.g. "grow online revenue."
  2. Question: "where do people drop out of checkout?"
  3. Events: begin_checkout, add_shipping_info, purchase.

Step 2: the measurement plan document

It doesn't need to be fancy, a single table everyone can read. For each event, capture:

  • Event name: the exact string (e.g. generate_lead).
  • Trigger: when it fires (form success, button click, page).
  • Parameters: the data it carries (value, currency, form_id).
  • Priority / owner: is it a conversion, and who needs it.

Keep it living

The plan is the contract between marketing (what to measure) and developers (what to push). Update it as the site changes, a stale plan is how containers drift back into chaos.

Step 3: design the dataLayer schema

Decide the exact shape your site will push, before anyone writes code. Consistent keys and types make every downstream variable trivial.

dataLayer.push({
  event: "purchase",
  transaction_id: "T-1042",      // string, always present
  value: 49.0,                   // number, no currency symbol
  currency: "USD",               // ISO code
  items: [
    { item_id: "SKU_1", item_name: "Cap", price: 49.0, quantity: 1 }
  ]
});

Practice this on a real container

See a measurement plan turn into real tags: the measurement-planning reading walks goals → events → a dataLayer schema → a developer spec, with examples you can copy.

Read: the measurement plan →

Step 4: write the tagging spec for developers

Translate the plan into instructions a developer can implement without guessing: which event to push, on what user action, with exactly which keys and types. A good spec is the difference between "tracking works" and three rounds of back-and-forth.

What a spec row contains

  • The user action ("on successful checkout").
  • The exact dataLayer.push object, with example values.
  • Notes on timing (push before navigation) and edge cases.

Now go practice it

Reading sticks when you do it. These hands-on lessons load your own GTM container and let you debug in Tag Assistant.

Frequently asked questions

What is a measurement plan?

A measurement plan is a short document that maps your business goals to the questions you need answered and the events that answer them. For each event it records the exact name, when it fires, the parameters it carries, and whether it's a conversion, so your tracking is intentional rather than ad hoc.

What events should I track in GA4?

Work down from business goals, not from what's easy. For each goal, write the question you need answered (e.g. 'where do people drop out of checkout?') and the events that answer it (begin_checkout, add_shipping_info, purchase). Track the events that map to decisions you'll actually make.

What goes in a tagging spec for developers?

Each row describes a user action (e.g. 'on successful checkout'), the exact dataLayer.push object with example values and types, and notes on timing and edge cases. It's the contract that lets a developer implement tracking without back-and-forth guessing.

Why plan before building tags in GTM?

Without a plan, events get added ad hoc with inconsistent names, no one agrees what a conversion is, and reports can't answer real questions, so you re-tag later at higher cost. A plan makes every event trace to a business question and keeps names and parameters consistent.

Related posts

About the author

Nathan Gage
Nathan Gage

Analytics & Tag Management Consultant

Nathan Gage got his start in marketing through Google Tag Manager. Seeing how tracking customer behavior could turn raw clicks into insight you can actually act on is what pulled him into the field. Since then he has worked both full time and as a consultant with 15 marketing agencies, supporting brands that spend anywhere from a thousand dollars a month to over a million. Along the way he built a multi-touch attribution app, and he created The Happy Tagger so anyone can practice GTM, GA4 and server-side tracking on a real container instead of a production site.