Jake McMahon
Led by Jake McMahon8+ years B2B SaaS · Behavioural Psychology & Big Data

Event taxonomy for product analytics.

Design an event taxonomy in seven steps: list the questions first, fix one naming convention, define the property schema, version changes, assign an owner, and validate before you ship. Includes a worked checkout example and a pre-launch checklist.

Event taxonomy is the structure that makes analytics trustworthy. If the names, properties, and ownership are messy, the dashboards will stay messy too.

This page is for teams trying to answer:

✓ What to name✓ What properties matter✓ How to keep it usable

The structure matters before the dashboard does.

Event Taxonomy, Broken Down

01 - NamingClear event names that the team can understand later
02 - PropertiesThe fields that make each event useful for analysis
03 - OwnershipWho maintains the system when the product changes
04 - QAHow the team keeps instrumentation from drifting
TRACKING QUALITY GAP60–80%

Of SaaS teams have broken or missing events that make their analytics unreliable.

DOUBLE-FIRING RATE20–40%

Of events are fired twice due to overlapping hardcoded snippets and tag manager triggers.

IDENTITY STITCHING GAPS30%+

Of users appear as two separate records — anonymous and identified — breaking funnel analysis.

WHY TAXONOMIES BREAK

"We have 500+ events and nobody knows which ones are still firing"

"Our PostHog instance has events named by three different engineers over two years. We have page_view, PageView, pageViewed, and screen_view all meaning the same thing. Nobody trusts the numbers."

Engineering Lead — B2B SaaS, Series C
"Our analytics team says our data is broken but can't tell us what to fix"

"We have a dashboard with 15 charts but none of them answer the question: are users actually getting value? The data exists but nobody has connected it to decisions."

VP Product — PLG SaaS, $15M ARR
"We can't tell if our new feature is being used or not"

"We shipped a major feature three months ago. The engineering team thinks it's used. The product team isn't sure. The analytics team says the event exists but they don't know if it's reliable."

Product Manager — Enterprise SaaS, $50M ARR
"Our migration created a mess of old and new event names"

"After moving from Mixpanel to PostHog we have two parallel event taxonomies. Half our dashboards use the old names, half use the new. We can't compare before and after."

Head of Data — Healthcare SaaS, Series B

How to design an event taxonomy in seven steps.

An event taxonomy is a defined set of names and properties for the user actions your product records. It fixes three things: what each action is called, what data travels with it, and who is allowed to change it. Start with the questions your team must answer, not with the events your code can already fire.

01

List the questions before the events

Write down the six to ten questions the business has to answer every month. Activation rate, week four retention, which plan upgrades, where support load comes from. Each question names the actions that prove an answer.

  • One page, one owner per question, no dashboard talk.
  • Any event that answers no question is not an event yet. Park it.
  • This step decides scope, which is the part teams skip and then regret.
02

Pick one naming convention and write it down

Object plus past-tense action, in snake case: checkout_completed, report_exported, invoice_failed. The convention belongs in the repo, not in someone's memory.

GoodBadWhy
subscription_cancelledcancelA bare verb does not say what was cancelled
dashboard_viewedview_dash_2The second name encodes a version, so it will always need another one
invite_sentjake_test_inviteTest payloads belong in a dev project, never in production names
  • Keep a short, closed list of allowed actions: created, completed, failed, viewed, clicked, invited, upgraded, cancelled, exported.
  • Never encode context in the name. Context is what properties are for.
03

Define the property schema once

Two tiers. Global properties attached to every event, and properties specific to one event. The global tier is what lets you compare anything to anything later.

global:    user_id  account_id  plan  role  app_version  source
checkout: cart_value  currency  item_count  payment_method  coupon_code
report:   report_type  row_count  export_format  duration_ms
  • Property names are snake case nouns. Units live in the name: duration_ms, not duration.
  • Use closed enums for anything you will group by. Free text becomes a reporting problem in week two.
  • Never send email addresses, names, or message bodies. Hash identifiers where you need to join across systems.
04

Draw the line between event, property, and state

A new event earns its place only when it answers a new question. If the question is the same and only the circumstances differ, it is a property.

SituationRight shapeWrong shape
User moves from Starter to Growthplan_upgraded with from_plan, to_plan, mrr_deltaFive events named for five plans
User views a report in three placesreport_viewed with surfacereport_viewed_mobile, report_viewed_email

The test: if a new pricing tier or a new surface would force you to invent new event names, the taxonomy is wrong. Growth should add rows to a property, never new events.

05

Version and deprecate, never silently rename

Additive changes are free: a new optional property breaks nothing. Breaking changes get a version and a migration window.

  • New shape: checkout_completed_v2, dual fire for one release, then retire the old name on a stated date.
  • Keep a deprecation log: event, date, owner, replacement, last date it fired.
  • Renaming an event in place rewrites history. Every chart built before the rename becomes a lie.
06

Assign an owner and a review gate

Taxonomy without ownership drifts within one quarter. Name one owner, usually product analytics or product operations, and make them a required reviewer on instrumentation changes.

  • Every instrumentation pull request carries the event name, its properties, and the question it answers.
  • Run a monthly audit query: events that fired zero times in 30 days, events missing a global property, and near duplicate pairs.
  • Publish the short list of what was retired. Silent removal is how trust in the data dies.
07

Instrument, validate, then document

Instrumentation is code, so it gets the same treatment as code: tested before release, versioned with the repo, and reviewed by someone other than the author.

  • Fire each event in staging and confirm the payload matches the schema exactly, including nulls.
  • Keep the tracking plan in the repository beside the code it describes. A wiki page drifts; a file that ships with the diff does not.
  • A contract test in CI fails the build when an event name or required property is missing.
✓ Each event names the question it answers
✓ Naming follows the written convention, no exceptions in production
✓ Global properties present on 100 percent of events
✓ Enums closed, units in the property name
✓ No PII in any property
✓ Deprecation dates set for anything replaced
✓ Owner named, review gate enforced
✓ Tracking plan in the repo and in CI

Event taxonomy is the naming system that keeps product analytics readable.

It defines what gets tracked, how it is named, which properties are attached, and who owns the structure. When that layer is clean, the rest of analytics gets easier to trust and easier to use.

Good taxonomy is not about tracking everything. It is about tracking the right actions in a way the team can understand months later. That means names that make sense, properties that add context, and a structure that survives product change.

Without that layer, analytics gets noisy fast. Teams end up with the same event represented three different ways, and nobody wants to make decisions from it.

Most event taxonomies grow by accident.

The structure is usually fine early on, then it starts drifting as more teams add tracking on their own.

Names get added without a rule.

One team tracks `clicked_button`, another tracks `button_clicked`, and the same user action ends up fragmented across the stack.

Properties are missing the context that makes analysis useful.

Events exist, but they do not carry the business context the team needs to segment behavior or compare usage properly.

No one owns the system.

When taxonomy ownership is unclear, every new product change makes the tracking more inconsistent.

The QA process is missing.

Broken instrumentation stays broken long enough that the team stops trusting the data altogether.

Events fire in multiple places with no single source of truth.

The same action is tracked by a hardcoded snippet, a tag manager rule, and a third-party integration - producing three different counts for one user behavior.

Identity mapping breaks between anonymous and known users.

Users who sign up after browsing anonymously show up as two separate people, making activation and funnel metrics unreliable from day one.

Three signs the structure is actually working.

01 - Clear names

The team can read the event and know what happened.

If the name makes sense without a tribal explanation, the taxonomy is in better shape.

02 - Useful context

The properties help the team answer real questions.

Good properties make it easier to compare users, accounts, plans, steps, and behaviors in a way the business can use.

03 - Stable ownership

The structure keeps improving instead of decaying.

Someone owns the rules, the QA, and the update path as the product evolves.

Design the event layer before you build the dashboard.

A dashboard is only as good as the structure underneath it.

ProductQuant starts with the business question, then designs the event names and properties that answer it, then defines the QA process that keeps the system stable. That order prevents the usual problem where the stack looks complete but does not answer anything useful.

The goal is a clean, maintained system that helps product, growth, and analytics teams work from the same source of truth.

01 - Map

Which user actions matter?

Track the actions that explain activation, retention, upgrade, or churn behavior.

→
02 - Name

What should each event be called?

Use a naming system the team can apply consistently across the product.

→
03 - Enrich

Which properties make it usable?

Add the context that lets the team segment and compare behavior.

→
04 - Govern

How does it stay clean?

Ownership, QA, and review discipline keep the stack trustworthy.

A good taxonomy gets more useful every time the team uses it correctly.

Go deeper from here.

These are the most relevant ProductQuant assets if you want the implementation details or the surrounding analytics work.

CLIENT WORK

Healthcare SaaS - Taxonomy Design
114
events designed, named, and documented

Taxonomy From Scratch: 114 Events, Zero Naming Collisions

Full event taxonomy design for a healthcare SaaS - 114 custom events with JTBD-aligned naming, property schemas, user identification strategy, and a QA process the engineering team could maintain independently.

Read the case study →
Healthcare SaaS - Migration
4 years
historical data preserved through taxonomy rebuild

Mixpanel Migration: Taxonomy Rebuilt Without Data Loss

Designed a clean PostHog taxonomy alongside a full Mixpanel migration - preserving 4 years of historical event data while establishing naming conventions the new setup could scale on.

Read the case study →
Healthcare SaaS — Analytics Rebuild
90%
analytics cost reduction

Full Analytics Rebuild: 118+ Decision-Ready Dashboards

Full analytics rebuild from scratch. 295+ verified event types. Churn flagged 30–60 days before cancellation. Complete event taxonomy redesign with 118+ decision-ready dashboards built on verified data.

Read the case study →
Healthcare Forms — Migration
906K
events migrated

906K Events Migrated: $20K–$50K/yr Analytics Bill to $0

Four years of Mixpanel data, 228 event types, complete migration with zero data loss and full HIPAA compliance. Reduced annual analytics bill from $20K–$50K to $0.

Read the case study →
Jake McMahon - event taxonomy consultant

WHO DOES THIS WORK

Jake McMahon

Founder, ProductQuant · MSc Big Data & Business Analytics · BSc Behavioural Psychology · 8+ years B2B SaaS

Jake has designed event taxonomy systems for B2B SaaS products across healthcare, fintech, HR, and developer tools. The JTBD-based approach starts from the user actions that explain activation, retention, and expansion - not from the screens that are easy to track.

Clean taxonomy is one of the most high-leverage investments a product team can make. The naming conventions, property schema, and ownership model designed in week one determine whether the analytics layer stays trustworthy for the next three years, or drifts into data debt that blocks every future analysis.

Event taxonomy design Naming conventions Property schema PostHog instrumentation Analytics QA Data governance B2B SaaS JTBD-based tracking

COMMON QUESTIONS

Event taxonomy: what it is and what it should produce

Questions about your specific situation? Book a call →

What is event taxonomy and why does it matter for product analytics?+
Event taxonomy is the naming and structure system for all product events - defining what actions get tracked, what they are called, which properties are attached, and who owns the system. Bad taxonomy means untrustworthy data: the same user action tracked three different ways produces three conflicting numbers in your dashboards. The naming conventions, property schemas, and ownership model you establish early determine whether your analytics layer stays reliable for years or drifts into data debt that blocks every future analysis.
What is the best naming convention for product events?+
The verb_noun pattern - for example report_exported or dashboard_created - is the most consistent and readable approach for B2B SaaS products. Use past tense, lowercase_snake_case, and consistent prefixes by product area. This makes events self-documenting: anyone reading the name months later can understand what happened without needing tribal knowledge.
Which event properties should every B2B SaaS product track?+
At minimum, every event should carry: user_id, account_id, plan_type, is_trial, feature_name, source, and timestamp. Without these, you can count events but you cannot segment them by the business dimensions that actually matter - plan, account, trial status, and entry path. These properties are what turn raw event counts into decision-ready analytics.
How do you fix a broken event taxonomy without losing historical data?+
Build the clean schema alongside the old one rather than replacing it immediately. Backfill properties where possible. Version new events with a v2_ prefix so teams can distinguish old from new. Freeze old events once the new layer is verified and stable. This approach preserves the historical funnels that exist in dashboards and board reports while giving you a clean foundation going forward.
Who should own the event taxonomy in a B2B SaaS company?+
Product analytics or product operations should own the taxonomy. Engineering executes the instrumentation but cannot own the decisions about what to track - those decisions require business context about which user actions explain activation, retention, and expansion. When engineering owns taxonomy by default, the result is technically implemented events that do not answer the questions the business actually needs to answer.
How do you keep event taxonomy from drifting as the product grows?+
Four mechanisms together: (1) a tracking plan document that defines naming rules and required properties; (2) PR review for new events so instrumentation is checked before it ships; (3) a quarterly schema audit to identify deprecated events and naming drift; (4) a naming linter that flags events violating conventions at the point of implementation. Any one of these helps. All four together keep the taxonomy reliable at scale.
How long does it take to design a clean event taxonomy?+
For a typical B2B SaaS product, initial taxonomy design takes 2–4 weeks depending on product complexity and the number of user actions that need tracking. This includes mapping key behaviors, defining naming conventions, creating property schemas, and documenting the tracking plan. The investment pays off immediately: teams stop wasting hours debugging conflicting dashboard numbers, and every new feature ships with consistent tracking from day one.
Should we track everything users do or only the important actions?+
Track the actions that answer business questions about activation, retention, upgrade, and churn. Tracking everything creates noise, increases costs, and makes the taxonomy harder to maintain. A focused taxonomy with 50–150 well-designed events is far more valuable than 500 events that nobody trusts. Start with the questions the team needs to answer, then design events that provide the data to answer them.
What is the difference between event taxonomy and a tracking plan?+
Event taxonomy is the naming and structural system — the conventions for how events are named, what properties they carry, and how they relate to each other. A tracking plan is the document that captures those conventions in a format the team can reference and enforce. Think of taxonomy as the language and the tracking plan as the dictionary. You need both: a good taxonomy without documentation drifts, and a tracking plan without a coherent taxonomy is just a list of disconnected events.

Pick the step that matches the gap.

If you want help turning the structure into a real working setup, these are the most relevant ProductQuant paths.

Event taxonomy should make analytics easier to trust, not harder to read.

If the names and properties are drifting, start with the builder or the health check before the dashboards get any bigger.