Mobile feature flagging

To remotely toggle features and manage user segments without submitting a new app store build, you need to implement Remote Config combined with User Segmentation/Targeting.

Here is a breakdown of how this works and the standard tools used to achieve it:

1. Core Concepts

• Remote Config: A cloud-hosted key-value store (or JSON configuration) that your mobile app fetches upon startup or periodically. Instead of hardcoding feature states in your binary, your app checks a value like is_dark_mode_enabled: true and behaves accordingly.
• User Segmentation: Grouping your users on the server side based on attributes like user ID, app version, country, custom traits (e.g., "beta tester", "premium subscriber"), or random percentage rollouts.

2. Industry-Standard Tools & Platforms

Instead of building this infrastructure from scratch, you can use established Backend-as-a-Service (BaaS) or Feature Flag management platforms:

• Firebase Remote Config: A free (with generous limits) and widely used tool by Google. It allows you-to define parameters, set conditional rules based on user properties, and target specific percentages or audiences. Learn more in the Firebase Remote Config Documentation.
• LaunchDarkly: An enterprise-grade feature management platform specialized in real-time feature flags, robust user targeting, and multi-variate testing. Check out details on LaunchDarkly Feature Management.
• PostHog: An open-source product analytics and feature flagging platform that lets you target specific cohorts with feature flags. Explore capabilities via PostHog Feature Flags.
• AWS AppConfig / AWS Systems Manager: If your backend infrastructure is hosted on Amazon Web Services, you can use AWS AppConfig to validate and securely deliver feature toggles to your mobile application. Read the overview on AWS AppConfig.

3. High-Level Implementation Steps

1. Integrate the SDK: Add the chosen provider's SDK (e.g., Firebase SDK) into your iOS and Android codebase.
2. Define Default Values: Set fallback values locally in your app code in case the user is offline when the app first launches.
3. Fetch and Activate: Configure your app to fetch the latest configuration from the remote server during app launch or resume.
4. Implement Feature Flags in Code: Wrap your UI components or logic blocks with conditional checks:
   • Example: if (remoteConfig.getBoolean("new_checkout_flow")) { renderNewCheckout(); } else { renderOldCheckout(); }
5. Set Up Targeting Rules on the Dashboard: Go to your provider's web console, create a condition (e.g., User ID ends with 0-5 or Custom Property 'isBetaUser' == true ), and toggle the flag on or off for that specific group.

Would you like to explore how to implement this using Firebase specifically, or are you interested in comparing open-source vs. commercial feature flagging tools for your team?

The standard way to remotely toggle features in a mobile app for specific user groups—without releasing a new version through the App Store or Google Play—is to use feature flags (also called feature toggles) combined with a remote configuration service.

This lets you turn features on or off, roll them out gradually, run A/B tests, and target particular groups of users while keeping a single app binary installed on users’ devices.

How it works

1. Admin dashboard

You enable a feature for a group, such as beta testers or premium subscribers.

2. Feature flag service

Stores rules, targeting conditions, rollout percentages, and default values.

3. Mobile app evaluates the flag

The app fetches or receives configuration and changes its behavior without an app store update.

For example, you could enable a redesigned checkout screen for 10% of users, expand it to all premium subscribers, and instantly disable it if a problem appears.

Recommended tools

Here are three good options, depending on how much control you need.

1. Firebase Remote Config

(Best starting point)

A good fit for iOS, Android, Flutter, and Unity apps. Supports remote parameters, audience targeting, percentage rollouts, and rollback workflows. It also supports real-time configuration updates.firebase.google.com+1

Official documentation

2. LaunchDarkly

Worth evaluating when you need a dedicated feature management platform, sophisticated targeting rules, team workflows, and feature lifecycle management.

Official website

3. Statsig

A strong candidate if you want feature gates alongside experimentation and product analytics. Its feature gates support targeting individual users or cohorts and controlling gradual releases.docs.statsig.com

Feature flags documentation

How to implement it

For most apps, I'd start with a simple feature flag architecture.

1. Define flags in your code. For example, new_checkout_enabled, dark_mode_enabled, or beta_dashboard_enabled.
2. Assign users to groups. Use authenticated user attributes, account plans, organization IDs, or a beta-tester cohort.
3. Fetch remote configuration. Load the current values when the app starts and refresh them periodically or when the service supports a real-time update.
4. Evaluate flags before displaying functionality. Hide or enable the relevant UI and behavior based on the current flag value.
5. Add a kill switch. If a feature causes problems, disable it remotely and have the app apply the new value.
6. Use safe defaults. If the network is unavailable, use cached configuration or an embedded default value.

For example, a flag configuration could look like this:

{
  "new_checkout_enabled": true,
  "beta_dashboard_enabled": false
}

The service can supply different values to different groups. The JSON above is just an illustrative configuration; your app still needs code that reads these flags and implements both feature states.

Important limitations

Feature flags can change only functionality that is already present in the installed app. They cannot magically add new compiled code or arbitrary new native screens. If you build a completely new feature, you generally still need to ship the code in an app update first, then activate it remotely.launchdarkly.com+1

Also, don't use a client-side feature flag as your only security control. If a feature grants access to protected data, paid functionality, or privileged actions, enforce authorization on your backend too.

Which approach fits your app?

1. What is your mobile app built with?

iOS / Swift

Android / Kotlin

React Native

Flutter

Other

2. Who do you want to target?

Groups such as beta testers, premium users, or organizations

Specific individual users

A percentage of all users

All of the above

3. What's your main priority?

Simple setup and low maintenance

A fast, remotely managed kill switch

Advanced targeting, auditability, and experimentation

Self-hosted or open-source infrastructure

[Recommend my implementation]

For a straightforward implementation, I'd start by evaluating Firebase Remote Config. If you need more advanced user-level targeting and centralized feature management, compare LaunchDarkly and Statsig before choosing.

What you’re looking for is remote feature flags (also called feature toggles), often combined with targeted rollouts and remote configuration.

Instead of releasing a new mobile app build every time you want to enable or disable a feature, you put the feature behind a remotely controlled flag. Your app checks the flag and changes its behavior based on the configuration it receives from your backend or a feature-management service.

How it works

1. Feature management dashboard

Enable a feature for beta testers, a country, a user cohort, or 10% of users.

2. Remote configuration service

Evaluates targeting rules and returns the appropriate flag values.

3. Mobile app evaluates the flags

Shows or hides the feature without downloading a new app version.

For example, you could release a new checkout experience to internal employees first, expand it to 5% of users, then 25%, and finally 100%—all controlled remotely.

Which solution should you use?

Firebase Remote Config

(Best starting point)

Ideal if your app already uses Firebase. Supports conditional feature flags, user segments, percentage rollouts, and rollback workflows, with no new app download required.firebase.google.com+2

Official documentation

LaunchDarkly

Better suited to teams that need a dedicated feature-management platform with sophisticated targeting rules, flag lifecycle management, and release controls.launchdarkly.com+1

Official documentation

How to implement it

1. Ship the feature code behind a flag. For example, new_checkout_enabled, initially set to false.
2. Integrate the SDK for your chosen configuration service into the iOS and/or Android app.
3. Define targeting rules for beta testers, internal employees, specific app versions, countries, or percentage-based cohorts.
4. Evaluate the flag in your UI or business logic and display the feature only when enabled.
5. Publish configuration changes remotely. Increase exposure gradually and disable the flag if problems occur.

Example:

if (featureFlags.new_checkout_enabled) {
  showNewCheckout();
} else {
  showExistingCheckout();
}

This is illustrative pseudocode; the flag lookup depends on your SDK.

Important considerations

• Updates aren't always instantaneous. Configure refresh behavior or real-time updates, and use cached values or safe defaults when offline.
• The code must already be in the app. Remote flags can activate shipped functionality, but cannot add entirely new native code to an installed build.
• Protect sensitive operations on the backend. A client-side flag is not an authorization or security boundary.
• Monitor rollouts. Track crashes, performance, and conversion metrics before increasing exposure.firebase.google.com+1

My recommendation: Start with Firebase Remote Config if you already use Firebase and want a straightforward solution. Choose LaunchDarkly if your team needs more advanced, centralized feature-release management.

One question to help narrow it down: Is your mobile app built with native iOS/Android, React Native, or Flutter? I can outline the implementation for your stack.

What you’re looking for is feature flags (also called feature toggles) combined with remote configuration and user targeting.

This lets you release features in your mobile app gradually, control who can access them, and turn them on or off without requiring users to download a new app version—provided the feature’s code is already included in the installed app.

How it works

1. Define your user segments

Target beta testers, selected countries, subscription tiers, app versions, or a percentage of users.

2. Control features remotely

Enable a feature for 5% of users, expand to 25%, then roll it out to everyone—or disable it immediately if something goes wrong.

3. Update behavior without an app-store release

The installed app evaluates a remotely managed flag and shows or hides the feature according to its targeting rules.

Which tool should you use?

Firebase Remote Config

(Best starting point)

Ideal if you want mobile feature flags, audience targeting, percentage rollouts, and crash monitoring with relatively little setup. Supports Android, iOS, Flutter, and other platforms.firebase.google.com+1

Official documentation

Statsig

Best if you need more advanced user-level targeting, feature gates, experiments, scheduled rollouts, and product analytics in one platform.docs.statsig.com+1

Official documentation

LaunchDarkly

Worth evaluating if you need a dedicated feature-management platform with sophisticated targeting, release controls, and consistent flag management across mobile and backend services.

Official website

Important implementation detail

Remote flags control features that your app already knows how to render or execute. They cannot add arbitrary new native code to an installed app. For example, you can remotely enable a new checkout flow already shipped in the binary, but a new native SDK integration will generally require an app update.

My recommendation: Start with Firebase Remote Config if you already use Firebase or want a straightforward solution. Choose Statsig if experimentation and advanced feature management are central to your workflow.

One question so I can narrow this down: What is your mobile app built with?

Native iOS (Swift)

Native Android (Kotlin/Java)

React Native

Flutter

Other / undecided

Basic on/off switches and percentage rollouts

Specific users, subscription tiers, and custom attributes

Both, plus experimentation and analytics

[Find the best fit]