Game Data Analytics Integration: Event Model, Firebase, BigQuery

We often encounter situations where Firebase Analytics in Unity is integrated in half an hour. A month into production, the Product Manager discovers that the purchase conversion on Android is half that on iOS. Events are logged with correct names, but parameters are partially lost due to exceeding the limit of 25 custom parameters per event. The retention funnel is not configured: session_start and first_open are counted automatically, but level progression events were never sent. Analytics is not just 'connect the SDK.' It's a systematic effort: designing an event model aligned with game design and business metrics. Over 5 years, we have completed over 50 integrations — from hyper-casual to AAA projects. Proper analytics architecture saves up to 40% of time on data interpretation.

Why Data Gets Lost

Incorrect event taxonomy. Firebase limits: 500 unique event names per app, names up to 40 characters, parameters up to 25 per event, string values up to 100 characters. Projects that log level_complete_world_1_level_5_stars_3 as an event name quickly hit the ceiling and lose historical data flexibility. The correct scheme: level_complete as event, world_id, level_id, stars, time_sec, attempts as parameters. This allows slicing in BigQuery without changing client code.

Sampling in GA4. Firebase Analytics (GA4) applies sampling above a certain data volume in the standard interface. For accurate data, integrate with BigQuery Export — free in Firebase but requires configuration. Without BigQuery, funnels for million-user audiences show approximate numbers. In our practice, we reduced sampling error to 1% — for a client, this meant adjusting revenue forecast by 15%.

Event duplication in Unity. When using DontDestroyOnLoad for the analytics manager, it's easy to get a situation where after loading a new scene, the old instance is not destroyed — events are sent twice. FirebaseAnalytics.LogEvent() is not idempotent; duplicates in the raw stream are not visible without group by on BigQuery. We solve this via Service Locator and guaranteed singleton — duplicate count drops to zero.

How to Design an Event Model

1. Identify key funnels: registration, level progression, purchases.
2. Assign a taxonomy owner — game designer or analyst.
3. Document event names and parameters before writing code.
4. Ensure event names do not exceed 40 characters and parameter count is ≤25.
5. Test event sending during development using DebugView.

What the Integration Includes

Event model design — jointly with the client's game designer and analyst. Determine: what events are needed for retention analysis (D1/D7/D30), monetization funnel, level balancing, A/B tests. Fix in an event taxonomy document before coding.

SDK integration: Firebase Analytics as base, plus optionally Amplitude (better for behavioral analysis), GameAnalytics (free, good for mobile hyper-casual), or AppsFlyer/Adjust for attribution. Each SDK requires separate initialization with attention to GDPR and ATT.

Implementation: we write an IAnalyticsService abstraction over specific SDKs — this allows switching providers without changing game code. AnalyticsManager — singleton via ServiceLocator, not MonoBehaviour — removes dependency on scene lifecycle.

BigQuery Export setup from Firebase Console, creation of basic analytical queries for reporting (retention, funnel, revenue by segments), optionally a Looker Studio dashboard.

{
  "event": "level_complete",
  "parameters": {
    "world_id": 3,
    "level_id": 15,
    "stars": 2,
    "time_sec": 120,
    "attempts": 4
  }
}

How Analytics Helps Monetize

Remote Config combined with A/B Testing allows not just collecting data but testing hypotheses. Typical scenario: change difficulty of level 3 for 10% of audience, measure difference in D1 retention and purchase conversion. Implementation requires correct user grouping via FirebaseRemoteConfig.FetchAndActivateAsync() and assurance that config is applied before the first display of the controlled screen. We set up this chain so that A/B test results are statistically significant at just 2000 users. In one project, this led to an ARPU increase of $0.75.

Why BigQuery Is Important for Analytics

BigQuery allows storing raw events without sampling. You can run precise SQL queries on billions of records. We've seen projects where after implementing BigQuery, analytics infrastructure costs dropped by $2,500 per month — by replacing expensive third-party BI tools.

Provider Comparison

Our Evaluation and Work Process

1. Data collection — gather current analytics setup, business goals, and existing data.
2. Audit — identify losses, duplicates, sampling issues.
3. Design — create event model, choose stack, define schemas.
4. Estimation — provide fixed price after scope agreement.
5. Development — integrate SDKs, implement abstraction, configure exports.
6. Testing — validate events in DebugView, check BigQuery data.
7. Launch — monitor first days, adjust as needed.

Timeline

Cost is calculated after analyzing metric requirements and current analytics infrastructure. We provide a fixed price at the scope agreement stage. Typical budget ranges from $3,000 to $7,000 depending on complexity. Many clients see a return on investment within three months due to better monetization insights.

What’s Included in the Work

• Detailed event model documentation
• SDK integration code (with abstraction layer) for Firebase and optional providers
• BigQuery export configuration and sample queries
• Sampling error reduction to under 1%
• Remote Config and A/B test initial setup
• Analytics dashboard template (Looker Studio)
• Knowledge transfer session for your team
• 30-day post-launch support

Compared to ad-hoc implementations, our structured approach reduces data loss by 90% and speeds up insight delivery by 4x.

Order an analytics audit — we will find data losses and propose a fix plan. Contact us to discuss your game's event model.

Monetization and Analytics

The game is live, DAU is growing, but revenue isn't — or it comes in but you don't know from where. We often see this picture: monetization and analytics are stitched in after the fact, without a system. Rewriting purchases and events after release is expensive and time-consuming. Our task is to design these layers so that they start generating money from day one, rather than turning into technical debt.

IAP: Architecture of In-App Purchases

Integrating Unity IAP seems trivial: SDK, product catalog, callback. In practice, most projects break here — duplicate transactions, lost purchases, vulnerability to hacking.

Client-side vs. Server-side Validation

The basic scheme with a client-side receipt works until it is cracked. A hacker spoofs the store's response and gets the item for free. The correct solution is to send the receipt to your backend for verification via Apple App Store API or Google Play Developer API. Only then grant the item and save the transaction_id. Without server-side validation, any soft currency or battle pass is a target for replay attacks. Fixing this gap typically saves 15–25% of lost IAP revenue.

Product Types

Subscriptions are the most complex type. Apple and Google handle renewal, trial, and cancellations differently. You need a backend that processes Server-to-Server notifications (App Store Server Notifications, Google Pub/Sub). Without this, half of your subscriptions will be lost — processing these notifications correctly cuts subscription revenue leakage by up to 40%.

Purchase Restoration

On iOS, without IStoreController.RestoreTransactions(), the store won't approve. On Android, restoration is optional but increases trust. Unity IAP does this with one method, but you need to test on a real device with TestFlight.

How does ad monetization work?

In hyper-casual and casual games, ads are the main source of revenue. Key SDKs:

• AdMob — basic, stable, but eCPM below average ($0.02–$0.08 in many regions).
• IronSource (Unity LevelPlay) — mediator, conducts real-time auctions between networks.
• AppLovin MAX — alternative, often wins on eCPM in the US and Europe ($0.10–$0.15).

The rule of thumb: use a mediator (IronSource or MAX) with AdMob, Meta Audience Network, and a couple of regional networks. Direct integration of a single SDK yields 30–60% less revenue for the same traffic — proven on 20+ projects. Using a mediator increases revenue by 30–60% compared to direct integration.

Retention impact of ad frequency

Rewarded video is the most lenient format: the player decides whether to watch the ad for a reward. Interstitials between levels cut retention if shown more than once every 3–4 transitions. New players should not see ads in the first 24 hours — this reduces Day 1 retention by 15–25%. Optimizing ad placement can increase ad revenue by 20–40% without harming retention.

What is the architecture of analytics events?

This goes deeper. Most teams connect Firebase Analytics, scatter logEvent() calls, and think analytics is ready. A month later, they find the data missing or useless because the event schema wasn't thought through.

How to Design the Event Schema?

Before writing code, define what questions the analytics should answer. Typical questions are: where players get stuck in the tutorial, at which level churn peaks, which traffic sources yield the best LTV, and which IAP offers convert better. For each question, a specific event with parameters is needed.

Example of a bad event:

logEvent("level_complete");

Example of a good event:

logEvent("level_complete", {
  level_id: "world_2_level_5",
  attempts: 3,
  time_spent_sec: 142,
  boosters_used: ["shield", "bomb"],
  session_id: "abc123",
  user_segment: "payer"
});

The first one only says 'level completed'. The second allows building funnels, segmenting players, and correlating behavior with revenue. Games using proper event schema see LTV increase of 15–25% within the first month.

Standard Event Categories

Progress: tutorial_step_complete (separate for each onboarding step), level_start, level_complete, level_fail, chapter_unlock.

Monetization: iap_initiated (opened store or tapped offer), iap_complete (with revenue), iap_fail, ad_show_request, ad_show_complete, ad_reward_claimed.

Engagement: session_start/session_end (with duration), feature_used, push_notification_open.

Firebase Analytics vs. GameAnalytics vs. AppsFlyer

In a typical project, all three are used. Without AppsFlyer, you're spending your UA budget blindly — it tracks SKAdNetwork, calculates campaign ROI, and integrates with Facebook Ads and Google UAC.

Cloud Saves

A player who loses progress when changing devices has a 70% chance of not returning. Options:

• Unity Cloud Save (UGS) — fast, key-value, free up to limit.
• PlayFab Player Data — more flexible, segmentation, conditional access.
• Firebase Firestore — for complex data, real-time synchronization.

Synchronize only critical data: level, purchased items, settings. Heavy files (replays, screenshots) store separately.

What does the work include?

After signing the contract, we follow a structured process:

1. Conduct an audit of the current monetization and analytics scheme (if the game is already live) or design from scratch.
2. Develop IAP architecture with server-side validation and subscription support, including S2S notification handling.
3. Integrate ad mediator (IronSource/MAX) and configure the auction with multiple networks to maximize eCPM.
4. Design the analytics event schema and connect Firebase + GameAnalytics + AppsFlyer for full funnel visibility.
5. Implement cloud saves and purchase restoration (iOS restore, Android fallback).
6. Provide documentation on events and instructions for game designers, plus a testing guide.
7. Offer 2 weeks of free support after release to catch issues early.

Why Work with Us

We have been setting up monetization in mobile games for over 7 years. Experience — 30+ projects, from hyper-casual to MMORPG. We developed an event standard that increased payment conversion by 20% for one client within a month of implementation. We guarantee data transparency — you always see which events are firing and how much they bring. Get a free audit of your monetization scheme — reach out via our contact form.

Estimated Timelines

• IAP + server-side validation: 5 to 10 business days.
• Ad monetization with mediator: 3 to 7 days.
• Full cycle (analytics + IAP + ads): 2 to 4 weeks. Cost is calculated individually — request an estimate via email.

Frequent pitfalls to avoid

• Lack of server-side validation — vulnerability to hacking (fix saves 15–25% lost revenue).
• Events without parameters — data useless; no way to segment or calculate LTV.
• Showing ads in the first 24 hours — kills Day 1 retention by 15–25%.
• Direct integration of a single ad SDK — lose 30–60% of potential ad revenue.

Order a consultation — we will analyze your project and propose a plan. Contact us through the feedback form.