Mobile Analytics

Event Naming Standard:
  Format: object_action (snake_case)
  Examples: screen_viewed, button_tapped, item_added_to_cart,
            purchase_completed, search_performed, error_displayed

Property Naming:
  Format: snake_case, descriptive, typed
  Examples: screen_name: string, item_price: float,
            currency: string (ISO 4217), result_count: integer

Avoid:
  - Camel case mixing (screenViewed vs screen_viewed)
  - Generic names (click, event, action)
  - PII in event properties (email, phone, full name)
  - Unbounded cardinality (free-text user input as property values)

Core Event Categories:
├── Lifecycle
│   ├── app_opened (source, is_first_launch, app_version)
│   ├── app_backgrounded (session_duration_seconds)
│   └── session_started (session_id, referral_source)
│
├── Navigation
│   ├── screen_viewed (screen_name, screen_class, previous_screen)
│   └── tab_selected (tab_name, tab_index)
│
├── Engagement
│   ├── search_performed (query, result_count, filter_applied)
│   ├── content_viewed (content_id, content_type, duration_seconds)
│   └── feature_used (feature_name, context)
│
├── Commerce
│   ├── item_viewed (item_id, item_name, category, price, currency)
│   ├── item_added_to_cart (item_id, quantity, cart_value)
│   ├── checkout_started (cart_value, item_count)
│   └── purchase_completed (transaction_id, revenue, currency, item_count)
│
├── Onboarding
│   ├── onboarding_started ()
│   ├── onboarding_step_completed (step_number, step_name)
│   ├── onboarding_completed (duration_seconds)
│   └── onboarding_skipped (last_step_completed)
│
└── Notifications
    ├── push_permission_requested (status)
    ├── push_received (campaign_id, message_type)
    └── push_opened (campaign_id, time_to_open_seconds)

protocol AnalyticsProvider {
    func track(event: String, properties: [String: Any])
    func identify(userId: String, traits: [String: Any])
    func screen(name: String, properties: [String: Any])
}

final class AnalyticsManager {
    static let shared = AnalyticsManager()
    private var providers: [AnalyticsProvider] = []

    func register(_ provider: AnalyticsProvider) {
        providers.append(provider)
    }

    func track(_ event: AnalyticsEvent) {
        let properties = event.properties.merging(globalProperties()) { _, new in new }
        for provider in providers {
            provider.track(event: event.name, properties: properties)
        }
    }

    private func globalProperties() -> [String: Any] {
        [
            "app_version": Bundle.main.appVersion,
            "os_version": UIDevice.current.systemVersion,
            "device_model": UIDevice.current.modelName,
            "locale": Locale.current.identifier
        ]
    }
}

// Type-safe event definitions
enum AnalyticsEvent {
    case screenViewed(name: String)
    case purchaseCompleted(transactionId: String, revenue: Double, currency: String)
    case onboardingStepCompleted(step: Int, name: String)
    case searchPerformed(query: String, resultCount: Int)

    var name: String {
        switch self {
        case .screenViewed: return "screen_viewed"
        case .purchaseCompleted: return "purchase_completed"
        case .onboardingStepCompleted: return "onboarding_step_completed"
        case .searchPerformed: return "search_performed"
        }
    }

    var properties: [String: Any] {
        switch self {
        case .screenViewed(let name):
            return ["screen_name": name]
        case .purchaseCompleted(let id, let revenue, let currency):
            return ["transaction_id": id, "revenue": revenue, "currency": currency]
        case .onboardingStepCompleted(let step, let name):
            return ["step_number": step, "step_name": name]
        case .searchPerformed(let query, let count):
            return ["query": query, "result_count": count]
        }
    }
}

Attribution Methods:
├── Deterministic
│   ├── Deep links (most accurate): Universal Links (iOS), App Links (Android)
│   ├── Referrer (Android only): Google Play Install Referrer API
│   └── Click ID matching: Match ad click ID to install event
│
├── Probabilistic
│   ├── Fingerprinting (deprecated on iOS): IP + User Agent + Device model
│   └── Statistical modeling: Aggregated campaign performance inference
│
└── Self-Attributing Networks (SANs)
    ├── Meta, Google, TikTok, Snap
    └── Report their own attributed installs, reconcile with MMP data

SKAdNetwork (SKAN) Implementation:
├── Conversion Value Strategy (6 bits = 0-63)
│   ├── Bit 0-2: Revenue bucket (8 tiers)
│   ├── Bit 3-4: Engagement level (4 tiers)
│   ├── Bit 5: Retention (returned day 2+)
│
├── SKAN 4.0 Enhancements
│   ├── Coarse conversion values: low, medium, high
│   ├── Three postback windows: 0-2 days, 3-7 days, 8-35 days
│   └── Hierarchical source identifiers (2-4 digits based on crowd anonymity)
│
└── Implementation
    ├── Use MMP SDK (Adjust, AppsFlyer, Singular) to manage conversion values
    └── Map postback data to campaign performance in MMP dashboard

Funnel Design Principles:
1. Define clear start and end events
2. Include every meaningful step (not too granular)
3. Set reasonable time window (session-based or N-day window)
4. Segment by user properties (new vs returning, platform, source)

Common Mobile Funnels:
├── Onboarding: app_opened → step_1 → step_2 → step_3 → first_key_action
├── Purchase: item_viewed → added_to_cart → checkout_started → purchase_completed
└── Subscription: paywall_viewed → plan_selected → trial_started → trial_converted

Drop-off Analysis:
  For each step transition:
  - Calculate conversion rate (users reaching step N / users reaching step N-1)
  - Segment by: device, OS version, source, user properties
  - Set alerts when conversion drops below historical baseline
  - Track median time between steps (long waits = friction)

Crash Reporting Setup:
├── Capture
│   ├── Crashes, non-fatal errors, ANRs (Android), watchdog terminations (iOS)
│   └── Out-of-memory events
│
├── Enrich
│   ├── Stack trace with symbolication / deobfuscation
│   ├── Device model, OS version, app version, network state
│   ├── User breadcrumbs (last 50 events before crash)
│   └── Custom keys (current screen, user segment, feature flags)
│
├── Prioritize
│   ├── Crash-free users rate (target: > 99.5%)
│   ├── Sort by impacted users, not occurrence count
│   └── Track crash rate per app version (detect regressions)
│
└── Alert
    ├── New crash type → immediate notification
    ├── Crash-free rate drop → page on-call
    └── Velocity alerts: crash count spikes in short window

A/B Test Lifecycle:
1. Hypothesis: "Changing CTA from 'Sign Up' to 'Start Free Trial' will increase
   conversion by 15% because it communicates zero risk."

2. Design:
   ├── Primary metric: Sign-up conversion rate
   ├── Secondary metrics: Trial-to-paid rate, 7-day retention
   ├── Guardrail metrics: App crash rate, session duration
   └── Sample size: Calculate with MDE, alpha, power

3. Implementation:
   ├── Server-side flag assignment (preferred)
   ├── Consistent bucketing (same user always sees same variant)
   └── Track exposure event when user sees the variant

4. Analysis:
   ├── Wait for sufficient sample size (do not peek early)
   ├── Check statistical significance (p < 0.05)
   ├── Verify no impact on guardrail metrics
   └── Segment results (new vs returning, platform, geo)

5. Decision:
   ├── Ship if statistically significant improvement
   └── Kill if negative impact on primary or guardrail metrics

Required Sample Size Per Variant:
  n = (Z_alpha/2 + Z_beta)^2 * (p1(1-p1) + p2(1-p2)) / (p1 - p2)^2

  Rules of Thumb:
    - Small effects (< 5% relative change): 10,000+ per variant
    - Medium effects (5-15% relative): 2,000-10,000 per variant
    - Large effects (> 15% relative): < 2,000 per variant
    - Always run for at least 1 full week for day-of-week effects

Day-N Retention Analysis:
  Cohort: Users who installed in a given week
  Metric: Percentage who return on Day N

  Industry Benchmarks (varies by category):
  ├── D1: 25-40%   (good > 35%)
  ├── D7: 12-20%   (good > 18%)
  ├── D30: 6-12%   (good > 10%)
  └── D90: 3-8%    (good > 6%)

Retention Curve Shape:
  ├── Flattening curve → healthy: found core users
  ├── Steady decline → problem: no habit formation
  └── Smile curve (uptick) → excellent: reactivation working

Key Engagement Metrics:
├── DAU / MAU Ratio (Stickiness)
│   ├── Social apps: 30-50%, Utility: 15-25%, E-commerce: 8-15%
│
├── Session Metrics
│   ├── Sessions per DAU, session duration, time between sessions
│
├── Feature Adoption
│   ├── % of MAU who use feature X
│   ├── Feature correlation with retention
│   └── Power user feature fingerprint
│
└── Activation Rate
    ├── Define activation event (the "aha" moment)
    ├── Track time-to-activation from install
    └── Optimize onboarding to reach activation faster

Privacy Framework:
├── iOS App Tracking Transparency (ATT)
│   ├── Required for IDFA access (iOS 14.5+)
│   ├── Pre-prompt screen explaining value before system dialog
│   ├── Respect denial: use first-party analytics without IDFA
│   └── Typical opt-in rates: 15-35%
│
├── GDPR / CCPA Compliance
│   ├── Consent before tracking (EU), opt-out mechanism (US/California)
│   ├── Data deletion capability
│   └── Data retention policies (auto-delete after N months)
│
├── Privacy-Safe Alternatives
│   ├── First-party event data (no cross-app tracking)
│   ├── On-device processing where possible
│   ├── Privacy-preserving attribution (SKAN, Privacy Sandbox)
│   └── Server-side analytics (user never sends data to third parties)
│
└── Implementation
    ├── Gate all analytics behind consent check
    ├── Use anonymous IDs, not persistent device IDs
    ├── Strip or hash any quasi-identifiers
    └── Audit event payloads quarterly for PII leakage

Daily Operational Dashboard:
├── Health: Crash-free rate, API error rate, app launch time (p50, p95)
├── Acquisition: New installs (organic vs paid), CPI by channel, activation rate
├── Engagement: DAU/WAU/MAU, sessions per user, feature adoption, push open rate
├── Retention: D1/D7/D30 by cohort, churn rate trend, reactivation rate
└── Revenue: ARPU, ARPPU, LTV by cohort, subscription conversion/renewal rates