# What events to track first in your game

> A starter tracking plan for an indie game: an event table with triggers, properties and the question each event answers, plus code for Unity and Godot.

By Yos Riady. Updated 2026-11-19. Published 2026-11-18. Canonical URL: https://manalens.dev/blog/game-tracking-plan-first-events

Track launches, sessions, the tutorial, levels, errors, updates and purchases first. That is about 10 events, and the Godot and Unity SDKs send 5 of them for you. Google recommends a similar set for games, with tutorial_begin, level_start and level_end (Google Analytics Help). Write each event, its trigger and its properties in one table before you write code.

## Key points

- A first tracking plan needs about 10 events for launches, sessions, tutorial steps, levels, errors, updates and purchases.
- The Godot and Unity SDKs send 5 of the events for you: game_open, session_start, session_end, error and app_unclean_exit.
- Put the level number in a level property, not in the event name, so one funnel and one table cover every level.

## What is a tracking plan?

A tracking plan is a table. Each row is one event: its name, the moment it fires, its properties, and the question it answers. You write it before you write code, and you keep it next to the code. Twilio Segment describes it the same way: a tracking plan clarifies what events to track, where those events live in the code base, and why those events are necessary.

The plan stops two common problems. The first is a dashboard full of events that answer no question. The second is a launch day with no data for the question you suddenly care about, such as "where do new players stop?".

Keep the first plan short. Segment recommends that you start with fewer events that are tied to an objective, and add events later for other questions. You can add events in every build; you cannot add data for players who already left.

- [Event](https://manalens.dev/glossary/event)

Sources: Twilio Segment documentation, Data Collection Best Practices; Manalens app events documentation.

## Which events should I track on day one?

Start with the events in the table. They cover launch, play time, the first session, progress, money and quality. Every row has the moment to send the event, its properties and the question it answers. If a row answers no question that you have, leave it out.

The names follow the app event conventions, so the Game KPIs and Game health boards read them without setup. tutorial_step is the only name that is not in the conventions: it is the name that the tracking plan generator uses. Send resource only if the game has a currency, and purchase only if it sells something in the game.

- [Game tracking plan generator](https://manalens.dev/tools/game-tracking-plan-generator)

*The starter tracking plan: event, when to fire it, properties, the question it answers and who sends it.*

| Event | When to fire | Properties | Question it answers | Sent by |
| --- | --- | --- | --- | --- |
| game_open | Each launch | is_first_open, first_open_at | How many new installs did I get, and on which day? | The Godot and Unity SDKs |
| session_start | A session starts: at launch, or on return after 30 minutes idle | none | How many sessions does a player have each day? | The Godot and Unity SDKs |
| session_end | The session ends: at quit, or after 30 minutes idle | duration_s | How long do players play, and do they come back? | The Godot and Unity SDKs |
| tutorial_step | The player finishes a tutorial step | step, step_name | Where do new players stop in the first minutes? | Your code |
| level_start | The player starts a level or chapter | level, attempt | How far do players get? | Your code |
| level_complete | The player completes a level | level, attempt, score | How many attempts does each level take? | Your code |
| level_fail | The player fails a level | level, attempt, score | Which level is too hard? | Your code |
| resource | The player gains (source) or spends (sink) an in-game resource | flow, currency, amount, item | Where do players earn and spend currency? | Your code |
| purchase | A real-money purchase, such as DLC | amount_cents, currency, store | Who pays, and after how long? | Your code |
| error | A game error | severity, message, error_type, handled, fingerprint | Which errors happen most, and in which build? | The SDKs, and your code for errors you catch |
| app_unclean_exit | The launch after a crash, in the crashed session | previous_session_id, previous_build | Which build crashes, and how often? | The Godot and Unity SDKs |
| game_updated | The first launch after an update | previous_version, previous_build | Do players move to the new build? | Your code |

Sources: Manalens app events, error tracking and metrics documentation.

## How do other tools name the same moments?

With different names for the same ideas. The table puts the starter plan next to the events that Google recommends for games. Use it when you move a plan from one tool to another, or when you send the same events to two tools.

Unity Analytics records gameStarted at the start of a session, gameRunning every 60 seconds when no other event was recorded, and gameEnded when the player exits. GameAnalytics has 8 event types: Ads, Business, Design, Error, Health, Impression, Progression and Resource. Its Progression type records level attempts with Start, Fail and Complete, and its Resource type records the sink and the source of each virtual currency. A paid PC game with no ads does not need the Ads and Impression types.

*The same moments in the Manalens conventions and in the Google Analytics recommended events for games.*

| Moment | Manalens | Google Analytics (recommended for games) |
| --- | --- | --- |
| Tutorial | tutorial_step with step and step_name | tutorial_begin, tutorial_complete |
| Level | level_start, level_complete, level_fail | level_start, level_end |
| In-game currency | resource with flow source or sink | earn_virtual_currency, spend_virtual_currency |
| Achievement | achievement_unlocked (tracking plan generator, premium games) | unlock_achievement |
| Real-money purchase | purchase | purchase |

Sources: Google Analytics Help, Recommended events; Unity documentation, Analytics standard events; GameAnalytics documentation, Event tracking.

## Which events do the SDKs send for me?

The Godot and Unity SDKs send game_open, session_start and session_end on their own. They also send error events and, at the next launch after a crash, app_unclean_exit. So you write code only for tutorial steps, levels, resources, updates and purchases.

Automatic events are the floor, not the plan: they tell you that people play, not what they do.

The web SDK does not send game events for you. For a browser game, or for an engine without an SDK, such as Unreal or GameMaker, send the same event names yourself. Then the same boards work for every build.

- [Session](https://manalens.dev/glossary/session)

Sources: Manalens Godot SDK, Unity SDK and app events documentation.

## How do I send the events from Unity?

Call Manalens.Track() with a snake_case name and a dictionary of flat properties. Property values are strings, numbers, booleans or null. The SDK drops lists, dictionaries and objects, and logs a warning.

Put every call in one static class, as below. Then each event name is written in one place, and the class is the plan in code. Call Manalens.Init() once before the first call.

- [How to add analytics to a Unity game](https://manalens.dev/blog/unity-analytics-without-gameanalytics)

``` C#
using System.Collections.Generic;
using ManalensSdk;

// One method for each row of the plan that your code sends.
public static class TrackingPlan
{
    public static void TutorialStep(int step, string stepName) =>
        Manalens.Track("tutorial_step", new Dictionary<string, object> { ["step"] = step, ["step_name"] = stepName });

    public static void LevelStart(int level, int attempt) =>
        Manalens.Track("level_start", new Dictionary<string, object> { ["level"] = level, ["attempt"] = attempt });

    public static void LevelComplete(int level, int attempt, int score) =>
        Manalens.Track("level_complete", new Dictionary<string, object> { ["level"] = level, ["attempt"] = attempt, ["score"] = score });

    public static void LevelFail(int level, int attempt, int score) =>
        Manalens.Track("level_fail", new Dictionary<string, object> { ["level"] = level, ["attempt"] = attempt, ["score"] = score });

    public static void Resource(string flow, string currency, int amount, string item) => // flow: "source" or "sink"
        Manalens.Track("resource", new Dictionary<string, object> { ["flow"] = flow, ["currency"] = currency, ["amount"] = amount, ["item"] = item });

    public static void Purchase(int amountCents, string currency, string store) =>
        Manalens.Track("purchase", new Dictionary<string, object> { ["amount_cents"] = amountCents, ["currency"] = currency, ["store"] = store });

    public static void GameUpdated(string previousVersion, string previousBuild) =>
        Manalens.Track("game_updated", new Dictionary<string, object> { ["previous_version"] = previousVersion, ["previous_build"] = previousBuild });

    public static void SaveFailed(string message) =>
        Manalens.TrackError(message, new TrackErrorOptions { ErrorType = "SaveFailed", Severity = "critical", Handled = false });
}

// In gameplay code:
// TrackingPlan.TutorialStep(2, "jump");
// TrackingPlan.LevelComplete(3, 1, 1200);
```

Sources: Manalens Unity SDK documentation.

## How do I send the events from Godot?

Call Manalens.track() with the same names and a dictionary. Manalens is an autoload, so every script can call it after init(). The script below has one function for each row of the plan that your code sends.

Put the level number in a property, not in the event name. One level_complete event with a level property gives you one funnel and one table. Fifty events called level_1_complete to level_50_complete give you fifty rows that you cannot compare.

- [How to add analytics to a Godot game](https://manalens.dev/blog/godot-analytics)

``` GDScript
# tracking_plan.gd: attach it to a node of your game, or copy the calls into your own scripts.
extends Node

func tutorial_step(step: int, step_name: String) -> void:
    Manalens.track("tutorial_step", {"step": step, "step_name": step_name})

func level_start(level: int, attempt: int) -> void:
    Manalens.track("level_start", {"level": level, "attempt": attempt})

func level_complete(level: int, attempt: int, score: int) -> void:
    Manalens.track("level_complete", {"level": level, "attempt": attempt, "score": score})

func level_fail(level: int, attempt: int, score: int) -> void:
    Manalens.track("level_fail", {"level": level, "attempt": attempt, "score": score})

func resource(flow: String, currency: String, amount: int, item: String) -> void:  # flow: "source" or "sink"
    Manalens.track("resource", {"flow": flow, "currency": currency, "amount": amount, "item": item})

func purchase(amount_cents: int, currency: String, store: String) -> void:
    Manalens.track("purchase", {"amount_cents": amount_cents, "currency": currency, "store": store})

func game_updated(previous_version: String, previous_build: String) -> void:
    Manalens.track("game_updated", {"previous_version": previous_version, "previous_build": previous_build})

func save_failed(message: String) -> void:
    Manalens.track_error(message, {"error_type": "SaveFailed", "severity": "critical", "handled": false})
```

Sources: Manalens Godot SDK documentation.

## How do I name events and properties?

Use snake_case, one name for one moment, and values in properties. An event name can have up to 128 characters and a string value up to 1,024. Stay far below both.

Other tools give the same advice. Amplitude says that it captures Song Played and song played as two separate events, so pick one convention and keep it. Segment says not to create events to track properties: do not add a value to an event name when the value can be a property. So send one boss_defeated event with a boss property, not boss_fire_lord_killed.

Use the same property name for the same thing in every event, such as level and attempt. Then one filter works on every chart.

- [Event taxonomy for premium PC games](https://manalens.dev/blog/premium-pc-game-event-taxonomy)

Sources: Manalens events API documentation; Amplitude documentation, Plan your taxonomy; Twilio Segment documentation, Data Collection Best Practices.

## What context comes with every event?

You do not need to add the platform, the build or the store to each event. The SDKs put them in context.app on every event: platform, storefront, app_version, build and engine. Set app_version, build and storefront once when you start the SDK.

These fields are filters and breakdowns in every report. You can compare retention by build, crashes by platform, or funnels by storefront without one extra property. The collector derives the country from the request and does not store the IP address.

Sources: Manalens app events and what we collect documentation.

## How do I write the plan down?

Use a shared sheet, or a CSV or markdown file in your repository. The tracking plan generator exports a CSV with one row for each property and six columns: event, property, type, example, when and sent_by. The table shows three events in that format.

Fill the plan in the order below, and review it before each build that goes to players. Mixpanel gives the same order: define the metrics, map each one to the steps that players take, then turn those steps into events and properties.

1. Write the 3 to 5 questions you need answered in the first month, such as "where do new players quit?" and "which build crashes most?".
2. For each question, write the event that answers it. Reuse a convention name when one fits.
3. Add the properties each event needs. Keep values short: numbers, IDs of levels or items, and short labels.
4. Write the exact moment each event fires, so two people would put it in the same place in code.
5. Add the events to a development build with the SDK turned off in the editor, and check each one in the activity feed.
6. Mark each row as live, with the build number where it started.

- [Game tracking plan generator](https://manalens.dev/tools/game-tracking-plan-generator)

*Rows of a plan file in the CSV format of the tracking plan generator.*

| event | property | type | example | when | sent_by |
| --- | --- | --- | --- | --- | --- |
| tutorial_step | step | number | 2 | The player finishes a tutorial step. Shows where new players stop. | your code |
| tutorial_step | step_name | string | jump | The player finishes a tutorial step. Shows where new players stop. | your code |
| level_complete | level | number | 3 | The player completes a level. | your code |
| level_complete | attempt | number | 1 | The player completes a level. | your code |
| level_complete | score | number | 1200 | The player completes a level. | your code |
| session_end | duration_s | number | 1260 | The session ends: at quit, or after 30 minutes idle. | SDK |

Sources: Mixpanel documentation, Create a Tracking Plan; Manalens app events documentation.

## What questions does the starter plan answer?

With these events, the Game KPIs board shows D1, D7 and D30 retention, DAU, MAU, stickiness, sessions per DAU, session length, a levels table with fail rates and a level funnel. The Game health board shows crash-free sessions and players, errors per session by build and the top errors.

Add a funnel chart from game_open through your tutorial steps to see where the first session breaks. A funnel has two to five steps, so pick the steps that matter most. Add a retention chart with game_open as the entry event and session_start as the returning event to compare builds.

- [D1 retention](https://manalens.dev/glossary/d1-retention)
- [D1, D7, D30 retention calculator](https://manalens.dev/tools/retention-calculator)

Sources: Manalens dashboards, funnels and retention documentation.

## What should I leave out at first?

Leave out events that answer no question in your list. Every button click, every camera move and a position event every second add volume and no answers. Mixpanel warns that tracking everything a user can do leads to unnecessary development effort and unused data. Add such an event later for one question and one build, then remove it.

Leave out personal data. Do not put names, email addresses or chat text in event properties or error messages. If you need to join a player to an account, call identify() with your own player ID.

Leave out values in event names. Names such as boss_fire_lord_killed grow without end.

Sources: Mixpanel documentation, Create a Tracking Plan; Manalens app events documentation.

## How do I start?

Manalens is the analytics and growth engine built for games. Add the Unity or Godot SDK, send the starter events, and open the Game KPIs and Game health boards on the same day.

- [Install game analytics in Unity](https://manalens.dev/integrations/unity)

Sources: Manalens product documentation.

## Frequently asked questions

### How many events should a first tracking plan have?

About 10 is enough for a first build: launches, sessions, tutorial steps, level start, complete and fail, errors, updates and purchases. The Godot and Unity SDKs send several of these for you. Add more events only when you have a question that the current events cannot answer.

### Should the level number be part of the event name?

No. Send one level_complete event with a level property. Then one funnel and one table cover every level, and you can sort and compare them. Event names with numbers or item names grow without end and make reports hard to read and to filter.

### Do I need to track sessions myself?

Not with the Godot or Unity SDK. Both send session_start and session_end with duration_s, and they start a new session after 30 minutes without focus or events. With the web SDK or plain HTTP, send session_start and session_end yourself with a timer that resets on player input.

### Can I change the tracking plan after launch?

Yes. Add events in any build, and note the build number in the plan. Reports can filter by build, so you can compare data from before and after the change. Avoid renaming live events, because the old and the new name then split one metric into two.

### Can I use the same plan in Unity and in Godot?

Yes. The event names and the property names are the same in both SDKs, and both send the same automatic events. Only the call differs: Manalens.Track() with a Dictionary in C#, and Manalens.track() with a dictionary in GDScript. The reports then put both builds in one chart.

## Sources

- [Google Analytics Help: [GA4] Recommended events, section For games (read 19 November 2026)](https://support.google.com/analytics/answer/9267735?hl=en)
- [Unity documentation: Analytics standard events (read 19 November 2026)](https://docs.unity.com/en-us/analytics/events/standard-events)
- [GameAnalytics documentation: Event tracking, GameMaker SDK (read 19 November 2026)](https://docs.gameanalytics.com/event-tracking-and-integrations/sdks-and-collection-api/game-engine-sdks/gamemaker/event-tracking)
- [Twilio Segment documentation: Data Collection Best Practices (read 19 November 2026)](https://www.twilio.com/docs/segment/protocols/tracking-plan/best-practices)
- [Mixpanel documentation: Create A Tracking Plan (read 19 November 2026)](https://docs.mixpanel.com/docs/tracking-best-practices/tracking-plan)
- [Amplitude documentation: Plan your taxonomy (read 19 November 2026)](https://amplitude.com/docs/data/data-planning-playbook)

## Related guides

- [Game marketing measurement guide](https://manalens.dev/blog/game-marketing-measurement-guide)
- [Event taxonomy for premium PC games](https://manalens.dev/blog/premium-pc-game-event-taxonomy)
- [First session funnel and FTUE analysis](https://manalens.dev/blog/first-session-funnel-ftue)
- [Game metrics every indie developer should track](https://manalens.dev/blog/game-metrics-indie-developers)
- [Custom events](https://manalens.dev/features/custom-events)
- [Game tracking plan generator](https://manalens.dev/tools/game-tracking-plan-generator)
- [Player analytics guides](https://manalens.dev/blog/topic/player-analytics)
- [How to add analytics to a Unity game](https://manalens.dev/blog/unity-analytics-without-gameanalytics)
- [How to add analytics to a Godot game](https://manalens.dev/blog/godot-analytics)
- [PostHog, Mixpanel or Amplitude for games?](https://manalens.dev/blog/posthog-mixpanel-amplitude-for-games)
- [D1, D7 and D30 retention benchmarks for PC and indie games](https://manalens.dev/blog/pc-indie-game-retention-benchmarks)
