Event Tracking in Mobile Apps: What It Is, Event Types, and How to Set It Up

What is Event Tracking?

Event Tracking is the process of collecting, storing, and analyzing discrete user actions within an application. Each event consists of a name (event_name) and a set of parameters (event_params). For example, the purchase event has parameters price, currency, product_id, quantity.

Unlike Screen View, which records the fact that a screen was opened, Event Tracking describes what exactly the user does on that screen: clicked the “Buy” button, opened the cart, applied a promo code. Without events, it’s impossible to understand user motivation and context of actions.

Event Structure

Each Analytics Event contains required and optional fields. Required: event_name, event_timestamp, user_id (or device_id). Optional: parameters describing the context.

The revenue parameter is especially important — it is passed to MMP platforms for automatic ROAS and LTV calculation.

Event Types in Mobile Analytics

Events are classified by origin and purpose. This division helps organize the data structure and assign access rights for different teams.

Automatic Events (SDK)

SDKs of analytics platforms automatically collect basic events: app_install, app_remove, session_start, screen_view. Firebase Analytics generates about 20 automatic events without a single line of code. These events cover basic metrics but don’t provide insight into business logic.

Custom Events

Custom events are what makes Event Tracking valuable. They describe business actions: add_to_cart, start_subscription, level_complete, share_content, search_performed. Custom events require explicit sending from the application code.

// Sending a custom event to Firebase
val bundle = Bundle().apply {
    putString(AnalyticsParam.ITEM_ID, "prod_789")
    putString(AnalyticsParam.ITEM_NAME, "Premium Subscription")
    putString(AnalyticsParam.CURRENCY, "USD")
    putDouble(AnalyticsParam.PRICE, 29.99)
    putString(AnalyticsParam.SOURCE, "onboarding_screen")
}
FirebaseAnalytics.getInstance(this)
    .logEvent("subscribe_premium", bundle)

In the example, the subscribe_premium event contains four context parameters. The source parameter helps identify which screen the user subscribed from — onboarding, settings, or paywall.

User Properties and Super Properties

In addition to events, Event Tracking includes User Properties — attributes tied to the user: subscription tier, country, app version. A User Property is sent once and applies to all subsequent session events. This allows analytics segmentation without adding parameters to every event.

Super Properties (Amplitude) or Global Properties (Mixpanel) — attributes tied to a session, not a user. They are used for A/B testing: variant_id as a Super Property is added to all events in a session, and the analyst can see which group the user belongs to.

Revenue Events

Revenue events are a separate class for recording transactions. They contain the amount, currency, and purchase type (subscription, one-time purchase, restoration). MMP platforms (AppsFlyer, Adjust) require revenue events for ROAS calculation.

According to Branch (2024), apps that correctly pass revenue events to MMP obtain 25% more accurate attribution data and can optimize campaigns for LTV rather than CPI.

How to Set Up Event Tracking?

Setting up Event Tracking involves three stages: event schema planning, SDK integration, and data validation.

Stage 1: Event Schema Design

Create an Event Taxonomy — a document describing each event: name, parameters, trigger, and owner. Example for e-commerce: order_completed → parameters: order_id, total_price, items_count, payment_method, shipping_city.

• Each event answers the question: what did the user do?
• Each parameter answers the question: in what context?
• Avoid events without parameters — they are useless for analysis

Stage 2: SDK Integration

Integrate the Analytics SDK into your project. Firebase Analytics, Amplitude, Mixpanel — any SDK requires initialization in Application.onCreate(). Example for Flutter:

import 'package:firebase_analytics/firebase_analytics.dart';

class AnalyticsService {
  final _analytics = FirebaseAnalytics.instance();

  Future<void> logPurchase({
    required String productId,
    required double price,
    required String currency,
  }) async {
    await _analytics.logEvent(
      name: 'purchase_completed',
      parameters: {
        'product_id': productId,
        'price': price,
        'currency': currency,
        'timestamp': DateTime.now().millisecondsSinceEpoch,
      },
    );
  }
}

The AnalyticsService class centralizes sending all events. Each method corresponds to a business action. This simplifies finding the source — if an event doesn’t arrive, you search by method name in the code. As the project scales, the number of methods can grow to 50–100, but the structure remains readable due to grouping by feature.

Stage 3: Validation via DebugView

Firebase DebugView allows you to see events in real-time on a developer device. Enable it: adb shell setprop debug.firebase.analytics.app your.package. All events will appear in the Firebase console with a delay of less than 5 seconds.

After enabling DebugView, open the app and run a test scenario — registration, purchase, catalog browsing. In the console, check: whether all events were sent, whether the correct parameters were passed, whether there is any duplication. Amplitude offers a similar tool — Amplitude Debugger for iOS and Android.

Automatic validation via CI/CD is the next quality level. Add a script to the pipeline that checks whether each event from the schema was sent at least once during the test run. This prevents deploying versions with missing events and saves QA engineers’ time.

Best Practices for Event Naming

Event naming is the most underestimated aspect of Event Tracking. An incorrect name makes analytics useless when the project has more than 50 events.

Object + Action Standard

Use the object_action pattern (lowercase, snake_case): product_added, cart_opened, payment_failed, subscription_cancelled. The object is the entity, the action is the verb in past tense. It reads like a sentence: “product added,” “cart opened.”

• product_viewed, not “tap_on_product_card” (event is a result, not an action)
• order_completed, not “successful_payment_transaction” (short and clear)
• level_started, not “begin_level_with_parameters” (no extra words)

Forbidden Patterns

DO NOT use spaces (“Add to Cart”), CamelCase (“AddToCart”), dots (“add.to.cart”), or hyphens (“add-to-cart”). Most SDKs recommend snake_case. DO NOT use UI element names (“btn_submit_clicked”) — the event should be business-oriented, not technical.

For prefixes, add the feature or screen name: onboarding_step_completed, checkout_payment_selected. This allows filtering events by functionality in reports.

Event Parameter Types

Parameters are divided into three types: string (value), number (for aggregation), boolean (flag). String parameters contain categorical data: country, traffic source, product name. Number parameters serve for metrics: price, quantity, duration. Boolean parameters indicate state: is_trial, is_promo_applied.

Avoid passing objects or arrays in a single parameter — analytics platforms cannot parse them. Instead of a JSON string in one field, pass multiple flat parameters. For example, instead of items_count_total, pass items_count and total_price separately.

Platforms for Event Tracking

Choosing an Event Tracking platform depends on the project scale and team. Let’s look at three options at different levels.

Firebase Analytics (free, up to 500 events)

Firebase is the standard choice for startups. Free limit — 500 different event_names, unlimited parameters. Integration with BigQuery for custom analytics. Downsides: limited segmentation, no automatic event linking within sessions.

Amplitude (Pro from $1,000/month)

Amplitude is a platform for product analytics. Supports Behavioral Cohorts, Funnel Analysis, Pathfinder. Allows creating virtual events from combinations of real ones. Integrates with 50+ tools via Segment.

Segment (from $120/month)

Segment is middleware for managing events. You send events to Segment, and it distributes them to 300+ tools. Useful in enterprise environments where Firebase, Amplitude, Mixpanel, Braze, and Salesforce are used simultaneously.

PostHog (open-source alternative)

PostHog is an open-source product analytics platform with its own Event Tracking. Supports autocapture of events, session recording, and feature flags. Deployed on your own server, which is critical for projects with GDPR or confidential data. Provides a Python-compatible API for ETL pipelines.

For Flutter projects, flutterfire_analytics + Amplitude via the amplitude_flutter plugin is recommended. For React Native — react-native-firebase + mixpanel-react-native.