Playable‑Demo Instrumentation Cookbook: 12 Events, Naming Conventions, and Dashboards That Prove a Demo Moves MRR
Written by AppWispr editorial
Return to blogPLAYABLE‑DEMO INSTRUMENTATION COOKBOOK: 12 EVENTS, NAMING CONVENTIONS, AND DASHBOARDS THAT PROVE A DEMO MOVES MRR
If your demo is a marketing showpiece but you can’t answer whether it actually increases paid conversion, this cookbook is for you. Designed for founders, indie builders, and product-minded operators running installless/playable demos, it gives a concrete event taxonomy, naming conventions, sampling rules, dashboards and quick acceptance tests so you can run clean A/B experiments and show a causal link from demo interactions to MRR.
Section 1
What success looks like (and the minimum telemetry you need)
Start by defining the causal claim you want to test. Typical claims are: “Watching the playable increases trial starts by X%” or “Interacting with feature X inside the demo improves trial→paid conversion.” The instrumentation below is designed so every experiment produces the three observation layers you need: demo engagement, downstream micro-conversion (signup/trial), and revenue/paid conversion.
Minimum telemetry: record demo lifecycle events, a small set of micro-conversions, and revenue events. Keep the taxonomy lean—only track events that answer the business question for your experiment. Over-instrumentation creates noise and increases the maintenance burden.
- Three event groups: demo interactions, micro-conversions, revenue events.
- Capture identity: a stable user_id (or anonymous_id with later tie-to-user) across demo → signup.
- Record timestamps and a small set of contextual properties (demo_variant, demo_source, step_name).
Sources used in this section
Section 2
The 12 events to instrument (playable-demo-ready)
Instrument twelve events grouped by purpose so you can run funnels and attribution without having to join raw logs. Use simple, high-signal events; avoid capturing every click inside the player unless you need to diagnose UX.
Below are the events and the minimal properties each should carry. These names follow the object-action pattern so they’re portable across analytics stacks and warehouse pipelines.
- demo.start {demo_id, demo_variant, demo_source, anonymous_id}
- demo.step.view {step_name, step_index}
- demo.feature.use {feature_name, feature_context}
- demo.complete {duration_seconds, completion_rate}
- demo.pause {position_seconds}
- demo.replay {count, last_position_seconds}
Section 3
Naming conventions and schema rules that survive changes
Pick a single naming convention and treat event names as immutable once live. Use a consistent object-action style (e.g., demo.start, demo.feature.use). Keep event names stable to preserve historical comparisons; add new events for new behavior instead of renaming old ones.
Standardize property prefixes and types (strings, booleans, numbers), and document them in a single source of truth. Use demo_variant and demo_source consistently so A/B analysis and UTM attribution are straightforward.
- Event name pattern: object.action (lowercase, dot-separated).
- Property naming: snake_case or camelCase—choose one and stick to it.
- Never repurpose an existing event name; create a new event for changed behavior.
- Document schema in a tracking plan (SSOT) that both engineers and analysts reference.
Section 4
Sampling, identity, and consent patterns for installless demos
Installless demos often start anonymous and only later connect to accounts. Emit an anonymous_id for every session and capture an eventual user_id when the visitor signs up or authenticates. Record consent decisions (analytics_allowed true/false) and implement server-side guardrails so revenue events are always tied to a verified user_id.
When you A/B test variants, ensure equal sampling at the demo variant assignment point (server-side or globally seeded client-side) and log variant assignment as a persistent property so downstream joins and cohorting are deterministic.
- Always emit anonymous_id at demo.start; persist it in a secure cookie/localStorage.
- On signup, emit identify {anonymous_id, user_id} to link histories.
- Log consent decisions and respect them in your pipeline; keep revenue events server-side when possible.
- Assign demo_variant at session start and persist across reloads.
Sources used in this section
Section 5
Dashboards, funnels, and acceptance tests that prove causal impact
Build three dashboards for every experiment: (1) Demo engagement funnel (demo.start → demo.feature.use → demo.complete), (2) Demo-to-trial funnel (demo.start → signup_after_demo → trial_start), and (3) Revenue attribution (trial_start → subscription_start → revenue). Use the demo_variant property to split by variant and compute lift in each funnel step.
Add a lightweight acceptance test suite: synthetic events that assert the event pipeline preserves insert_id/unique ids, variant is recorded, timestamps are monotonic, and revenue events are tied to user_id. Run these tests on deploy and before launching an experiment to avoid noisy, unusable data.
- Three canonical charts per experiment: engagement funnel, demo→trial funnel, revenue attribution.
- Use cohort retention and time-to-conversion charts to show durable effects (not just immediate clicks).
- Automated acceptance checks: event arrival, variant recorded, identity linkage, and no duplicate insert_ids.
- Prefer server-side revenue recording as the source of truth for MRR calculations.
FAQ
Common follow-up questions
How do I link anonymous demo sessions to paid conversions?
Emit an anonymous_id at demo.start and persist it on the client. When the visitor signs up or authenticates, emit an identify event that includes both anonymous_id and user_id. This one-to-one linkage lets you attribute downstream trial and revenue events to the original demo session.
Which analytics tool should I use for playable demos?
Amplitude, Mixpanel and Segment are common choices; pick a tool that matches your stack and team skillset. More important than the tool is a clear taxonomy, stable user identifiers, and server-side revenue events. If you plan to warehouse data, ensure the tool integrates cleanly with your pipeline.
What acceptance tests stop bad data before an experiment runs?
Run checks that verify event arrival within expected latency, the demo_variant property is present on every session, identity linkage (anonymous_id → user_id) works, timestamps are sane, and insert_id deduplication prevents duplicates. Failing tests delay the experiment until instrumentation is fixed.
How many demo events are too many?
Track only events that map to analysis questions you expect to ask. Start lean with the 12 events in this cookbook; add finer-grained events when a specific hypothesis or debugging need justifies the cost.
Sources
Research used in this article
Each generated article keeps its own linked source list so the underlying reporting is visible and easy to verify.
AppWispr
90‑Minute Demo‑to‑Conversion Case Study Sprint (AppWispr)
https://www.appwispr.com/blog/the-90-minute-demo-to-case-study-sprint-turn-one-playable-into-a-conversion-engine
AppWispr
Telemetry That Converts — Demo Events & Consent Patterns (AppWispr)
https://www.appwispr.com/blog/telemetry-that-converts-9-demo-events-and-consent-patterns-to-turn-playable-signals-into-paid-users
AppWispr
Demo‑First Sales Playbook — 3‑Touch Playable → Paid Trial (AppWispr)
https://www.appwispr.com/blog/demo-first-sales-playbook-convert-an-installless-playable-into-a-paid-trial-in-3-touches
Amplitude
The Foundation for Great Analytics is a Great Taxonomy (Amplitude Blog)
https://amplitude.com/blog/event-taxonomy
Amplitude
Plan your taxonomy (Amplitude Docs)
https://amplitude.com/docs/data/data-planning-playbook
TrackRaptor
Event Taxonomy Best Practices: A 2026 Naming Framework (TrackRaptor)
https://www.trackraptor.com/blog/event-taxonomy-naming-framework-guide
Amplitude
Choose the right measurement (Amplitude Docs)
https://amplitude.com/docs/analytics/charts/event-segmentation/event-segmentation-choose-measurement
Next step
Turn the idea into a build-ready plan.
AppWispr takes the research and packages it into a product brief, mockups, screenshots, and launch copy you can use right away.