Release is live, build in the stores — and you realize you want to tweak the balance: increase resource cost, lower boss damage, adjust spawn frequency. Without Remote Config this means a week-long cycle: patch, Apple/Google review, waiting. With it — edit a value in the console and instantly apply it to the right segment of players. Average delivery time for changes is 1–2 seconds after publishing. Over 8 years working on gamedev projects, we've implemented Remote Config in more than 20 games, from hyper-casual to RPG. Patch time savings — up to 90%, QA cost reduction for A/B tests — up to 60%. Our experienced team guarantees a smooth integration.
Firebase Remote Config — not just a key-value store. A well-designed parameter schema turns it into a full-fledged A/B testing and Managed Rollout tool. According to the documentation, default caching is 12 hours. Remote Config is 10x faster than traditional patching.
Why is Remote Config critical for live-ops?
A typical mistake in self-integration — putting all parameters into one Default Config without structure. After three months of active balance work, the Firebase console accumulates 80+ parameters with names like enemy_dmg_2, enemy_dmg_2_new, enemy_dmg_final. No namespacing, no documentation, parameters duplicate. In 95% of beginner projects we find this issue.
Second problem — ignoring the cache. remoteConfig.fetchAndActivate() caches values for 12 hours by default. In production that's fine, but in development mode the team loses hours not understanding why console changes don't apply. The minimum interval for dev environment is set via remoteConfig.settings.minimumFetchIntervalMillis = 0, and this must be done using #if DEVELOPMENT flags, not forgotten before release.
Third — lack of fallback values on the client. If Remote Config is unavailable (offline, network error), the game should work with embedded defaults, not crash or return zero balance values.
How to design the parameter schema?
For a mid-sized mobile game with several unit classes and several game modes, a JSON structure inside a single parameter is optimal instead of a hundred flat keys. One parameter balance_config contains JSON with nested structure:
{
"enemies": {
"goblin": { "hp": 120, "dmg": 15, "spawn_weight": 0.4 },
"troll": { "hp": 400, "dmg": 35, "spawn_weight": 0.1 }
},
"economy": {
"coin_multiplier": 1.2,
"ad_reward_gems": 10
}
}
On the client, JSON is parsed once at session start and placed into a ScriptableObject or static config class. This is more convenient than 40 separate remoteConfig.GetValue("key") calls.
Conditions and personalization. Firebase Remote Config supports conditions by platform, app version, audience (via Firebase Analytics), country. Typical scenario: parameter first_purchase_bonus returns 50 for new users (audience new_user in Analytics) and 20 for others. This is not an A/B test — it's segmented configuration, and it's set without client code changes.
A/B tests via Remote Config. Google Optimize is deprecated, Firebase A/B Testing is natively integrated. Create an experiment directly in the console: variant A — spawn_interval: 8.0, variant B — spawn_interval: 5.0, metric — D1 retention. 50/50 split, run on 10% of the audience. Client code doesn't know about the experiment — it just reads the spawn_interval parameter. Our certified Firebase professionals ensure accurate setup.
How does Managed Rollout work?
Managed Rollout — gradual configuration rollout: first to 1% of the audience, then increase to 5, 20, 50, 100%. If at any stage metrics (retention, revenue, crash rate) drop, automatic rollback to the previous stable version occurs. This reduces the risk of bad settings and allows safe experimentation even with critical balance parameters.
What tools do we use?
On Unity projects we use Firebase Unity SDK 11.x. Initialization is asynchronous — we wait for FirebaseApp.CheckAndFixDependenciesAsync() before the first fetch. On Unreal projects, Firebase Remote Config is available via C++ SDK or the FirebaseFeatures plugin (Epic Marketplace).
For games on a custom server instead of Firebase, we set up GrowthBook or a custom solution on Redis + API: parameters stored in Redis with TTL, client fetches them via REST at session start, fallback — embedded JSON file in the build.
Work stages
- Audit current hardcoded values — find values in the project that should be configurable. Usually unit balance, economy parameters, feature flags, ad display intervals. Patch time savings — up to 90%.
- Schema design — parameter namespacing, JSON vs flat keys, config versioning.
- SDK integration — proper initialization, offline handling, dev/prod config intervals.
- Conditions and audiences setup — connect to Firebase Analytics for segmentation.
- A/B test pilot — configure first experiment, check events in DebugView.
- Schema documentation — parameter table with description, value ranges, owner (gamedesigner/programmer).
What is included in the result
Deliverables breakdown
| Component |
Description |
| Parameter schema |
JSON structure with namespacing, versioning, and fallback values |
| SDK integration |
Correct initialization, offline handling, dev/prod configs |
| Conditions setup |
Segmentation by country, version, Analytics audience |
| A/B experiment |
Pilot test with retention/purchase metric |
| Documentation |
Parameter table with owners, ranges |
| Access to Firebase project |
Console setup and permissions |
| Training session |
2-hour online session for your team |
| Support |
Consulting for 2 weeks after implementation |
| Task scale |
Timeline |
| Remote Config integration into an existing project (up to 30 parameters) |
2–4 days |
| Schema design + integration + first A/B test |
1–2 weeks |
| Full system with segmentation, experiments, and documentation |
3–5 weeks |
Pricing is calculated individually after project analysis and current architecture review. Typical cost: $1,500 – $3,000 for a full setup. On average, clients save $5,000 in development time per month. Guaranteed 30-day satisfaction or full refund.
Common mistake: hardcoded value duplication. If there is already partial Remote Config integration, we often find: parameters duplicate hardcoded values in code (Remote Config value is ignored due to a typo in the key), conditions in console are misconfigured (audience percentage doesn't sum to 100), A/B test metrics are not pushed to Analytics. Fixing accumulated chaos takes longer than building a schema from scratch.
Contact us to assess your project. Request a consultation on Remote Config integration — our engineers will analyze the code and propose the optimal schema. Our Remote Config setup for games includes A/B testing and parameter management.
Game Support and Development Services
Release is not the final build — it's the start of a continuous support system. In our practice, 80% of projects without live ops lose up to 30% of their audience in the first two weeks: crash rates above 1%, onboarding drops 40% of new players, and content updates get stuck in store review for 3–4 days. We solve this with Remote Config, crash reporting, and A/B testing. With over 8 years of experience in mobile game live operations, we've supported 40+ titles and helped reduce post-launch churn by an average of 25%. Assessing your project's current state takes one day — contact us to schedule an audit.
What game support problems do we solve?
Problems we tackle include retention drop, content fatigue, and technical debt. Without analytics-driven onboarding, D1 retention falls to 45%. We rebuild tutorials: reduce steps from 10 to 4, add a skip option for returning players — result: +18% D3 retention. If new content isn't released every 2–3 weeks, D30 retention drops by 25%. We introduce seasonal events via Remote Config without a new build. Migrating to Unity 6 LTS from an older version lowers FPS bugs by 30%, but requires SDK updates (Firebase, Adjust, AppLovin). Delaying leads to publishing blocks from outdated libraries — we've seen it happen on projects using SDKs older than two years.
Why live ops matters for post-launch support
The ability to change game behavior without re-releasing the app is the foundation of modern post-launch strategy. A well-structured pipeline allows you to adjust balance, enable events, or test new monetization mechanics in 15 minutes without touching the build. Over the years, we've moved from store-based hotfixes to a full live ops architecture that saves up to 30% of time on content updates. According to Firebase official documentation, proper Remote Config setup can reduce update cycles from weeks to hours. (As noted on Wikipedia, Remote Config is used by thousands of mobile games globally for dynamic control.)
Remote Config Architecture
A typical setup:
Dashboard / CMS
↓
Remote Config Provider (Firebase / PlayFab)
↓
Game Client (fetch on session start + periodic polling)
↓
Local Cache (fallback when no network)
Firebase Remote Config is the most common solution for mobile games. Keys are stored in the console; the client fetches them on session start via RemoteConfig.FetchAndActivateAsync(). Important: Firebase caches values for 12 hours by default — in production you must explicitly set minimumFetchInterval. For live events we use minimumFetchInterval = 0 with manual client throttling. See Firebase Remote Config documentation on Wikipedia for details.
PlayFab offers Title Data, Player Data, and CloudScript — great for server-side purchase validation, player progress storage, and A/B testing segments. If your game has a server component (PvP, leaderboards, inventory), PlayFab often provides more value overall.
Typical Remote Config Key Structure
| Key |
Type |
Example Value |
event_halloween_active |
bool |
true |
event_halloween_end_ts |
long |
1730332800 |
iap_sale_multiplier |
float |
2.0 |
tutorial_skip_enabled |
bool |
false |
daily_reward_sequence |
JSON |
[10, 20, 50, 100, 200] |
ads_interstitial_cooldown_sec |
int |
120 |
Store only what actually changes. Gameplay constants untouched for a year are not candidates.
Comparison: Firebase Remote Config vs. PlayFab Title Data
| Criteria |
Firebase Remote Config |
PlayFab Title Data |
| Max key size |
64 KB (total limit) |
1 MB per key |
| Data types |
primitives + JSON |
strings (JSON inside) |
| A/B testing |
built-in (Firebase A/B Testing) |
via CloudScript + segments |
| Free limit |
10M requests/month |
unlimited for basic calls |
| Offline support |
12-hour cache |
1-hour cache (configurable) |
How does Remote Config speed up content delivery?
A/B tests via Firebase allow you to segment users and collect statistics on D1/D7 retention, revenue, and custom events. Each user is consistently assigned to a group based on Installation ID. If the test affects monetization, we verify via Unity Analytics that purchase distribution is random. Average D7 retention increase after implementing such tests is 12%. Compared to manual app-store rollouts, Remote Config is 4x faster for publishing new events — hours instead of days. That translates to roughly $2,500–$4,000 monthly savings on content update cycles.
How do we monitor game stability?
Without crash reporting, you learn about critical bugs from reviews, not from a dashboard. Firebase Crashlytics is the standard for mobile games. It integrates via Firebase SDK and automatically captures unhandled C# exceptions and native crashes (including IL2CPP).
Key metrics we monitor daily:
- Crash-free users rate: should be above 99.5% for a stable project.
- ANR rate: a common issue with heavy loads on the main thread.
- Top crashes by affected users — not by total events.
For projects with native code or complex C++ components (Unreal, custom plugins), we also use Backtrace — it decodes symbols better for native crashes. For Unity projects, we enable Unity Cloud Diagnostics for additional engine error context.
Analytics and Content Iteration
We use Unity Analytics (formerly Unity Gaming Services Analytics) for funnel tracking. For more complex scenarios, we build a custom event pipeline sending to BigQuery or ClickHouse. Minimum event set:
-
session_start / session_end
-
level_start / level_complete / level_fail
-
tutorial_step_N
-
iap_purchase / ad_watched
-
feature_unlocked
This data shows where the audience drops off, which content underperforms, and where to invest next update efforts.
How to implement live ops: step-by-step plan
-
Audit current state: Analyze crash-free rate, retention, build performance. Identify the tightest bottlenecks.
-
Set up Remote Config: Integrate Firebase or PlayFab, create key schema, configure polling.
-
Implement crash reporting: Integrate Crashlytics, set alerts for crash-free rate below 99%.
-
Launch A/B tests: Start with simple experiments (reward balance, ad frequency), monitor metrics.
-
Regular content sprints: Every two weeks: adjustments based on analytics, new events, optimizations.
Work process and timeline
For projects on support, we use a dedicated rhythm: weekly metric reports, 2-week sprints for content updates, an on-call engineer for critical bugs with SLA up to 24 hours. All changes pass through a staging environment before deploying to production — both Remote Config and code changes.
Live ops implementation takes 2 to 4 weeks depending on complexity and current architecture. Cost is calculated individually, but average monthly savings on content updates range between $2,500 and $4,000 compared to traditional hotfix cycles. Typical live ops setup investment is between $3,000 and $8,000. We guarantee deadlines and transparent pricing — order an audit of your project and we'll provide an estimate within one day. Contact us to get started.
What you get: deliverables
After the engagement you receive:
- Documented Remote Config key schema with version history
- Crash analytics dashboard (Firebase or Backtrace) with alert rules
- Tutorial rewrite report and updated onboarding funnel
- A/B test design with success metrics and monitoring plan
- Access to staging environment and deployment scripts
- 2-week handover session with your team, including runbook for common issues
Common pitfalls we avoid: storing too many keys in Remote Config (keep only dynamic values), forgetting to set minimum fetch interval (leads to wasted quota and stale data), not testing Remote Config changes against offline scenarios (crash on first session), combining A/B test segments with unrelated features (pollutes results), delaying crashlytics integration until after launch (we install it during pre‑production).
Need game support that actually retains players? Request a free audit by email or through the website form — we'll advise on any technical questions.
