When Does a Mobile App Need Feature Flags?
Use feature flags for mobile apps when you need to control exposure to a feature independently of a store update. A flag is a setting that selects between behaviours already included in the installed app. It can help you introduce a change gradually or disable an optional feature, provided you plan what happens when settings are missing, outdated or unavailable.
When is a feature flag worth adding?
Start with the decision you need to make after release. “Let selected users try the new search” is a useful reason. “We might want more flexibility” is too vague.
Consider a flag when you want to:
- Introduce a new flow to a selected group before widening access.
- Keep an optional integration disabled until it is ready.
- Return users to an existing flow if its replacement causes problems.
- Separate installing an app update from making a feature available.
Do not add a flag automatically to every feature. Each one creates more states to understand, test and eventually remove.
If the feature itself is still unclear, first work through how to scope an app MVP. A flag should control exposure to a defined feature, rather than become a reason to leave its scope undecided.
What can a flag change without another store update?
A flag can select an existing screen, hide an optional entry point or choose between implementations already present in the app. It cannot supply an implementation that the installed version does not contain.
For example, a flag could select a new booking form if that form shipped in the app update. If the form has not been included, changing a setting cannot make it appear.
Use this distinction when planning:
| Need | Suggested approach |
|---|---|
| Let selected users try an included feature | Use a feature flag with clear eligibility rules |
| Pause an optional feature during a problem | Consider a kill switch and a usable fallback |
| Correct faulty code on the phone | Prepare an app update; assess whether an existing fallback helps meanwhile |
| Decide whether an account may access private data | Enforce permission on the server |
| Change permanent preferences chosen by a user | Use ordinary app settings |
Keep release preparation separate from exposure planning. The release checklist remains relevant even when a feature starts disabled.
What should the safe default be?
Choose a default before connecting the app to remote settings. Ask: what should a fresh installation do if it cannot obtain a valid configuration?
For an optional new flow, the sensible default may be the existing flow. For an unavailable integration, it may be a clear message with another way to continue.
“Off” is not automatically safe. Turning off a new booking form is only helpful if users can still book through a working alternative.
Write down the fallback in user terms:
- What will the person see?
- Can they finish their main task?
- What happens to work already entered?
- Is a useful explanation needed?
Keep essential recovery actions available. A flag should not leave someone unable to sign out, retry a failed action or reach help.
How should cached settings work?
Plan for the app to start without a fresh configuration. Decide whether it should use previously saved settings or return to its built-in defaults.
For each flag, define:
- Fresh-install behaviour: the choice when no saved setting exists.
- Offline behaviour: the choice when the settings service cannot be reached.
- Expiry behaviour: the choice when saved settings are too old.
- Invalid-value behaviour: the choice when a setting is missing or unusable.
- Account-change behaviour: whether saved eligibility must be cleared when someone signs out.
Avoid one blanket rule for every feature. Keeping the last valid setting may suit a harmless layout choice. A feature with stricter eligibility may need a fresh server decision before an action proceeds.
Also specify when new settings take effect. Prefer a stable experience during an active task. Changing a form halfway through entry can make the fallback harder to use than the original problem.
What makes a kill switch useful?
A kill switch is a flag intended to stop an optional feature when something goes wrong. Treat it as a recovery mechanism with a defined scope.
“Disable the new upload flow and show the existing upload screen” is specific. “Make uploads safe” is not.
Document what happens to work already in progress. Should an upload finish, pause or restart through the fallback? Can a repeated attempt create a duplicate? Those decisions belong in the design before release.
Do not promise instant shutdown across every phone. A disconnected app cannot receive a new remote setting until it reconnects.
Where an operation must stop immediately, plan server-side rejection of that operation as well. Test the customer-facing message for that rejection.
How could a controlled rollout work?
Consider an illustrative example: an app is replacing its booking form while retaining the existing form as a fallback.
A practical rollout plan would be:
- Include both forms in a tested app version.
- Keep the existing form as the default.
- Enable the new form for a selected group.
- Check whether bookings complete correctly and whether users need help.
- Widen exposure only after the agreed checks pass.
- Return to the existing form if the new flow fails those checks.
- Remove the temporary choice once the replacement is established.
Keep a person's assigned experience stable where practical. Avoid switching forms between visits without a deliberate reason.
Define success before enabling the feature. “Bookings reach the correct account with the expected details” gives you something concrete to verify. “The rollout looks fine” does not.
If the new form changes saved data, confirm that the fallback can still read and handle it. A switch back is not useful if the old flow cannot work with bookings created by the new one.
Why can flags not replace access controls?
Use flags to decide what experience to show. Use server-side access controls to decide what an account may read or change.
Hiding a screen or button is not sufficient protection for a restricted action. The server must check identity, permissions and relevant account conditions for each protected request. OWASP's guidance on broken access control notes that access control is only effective in trusted server-side code.
For a paid feature, hiding the entry point may improve the interface. The server must still verify entitlement before returning protected information or accepting an action.
Keep passwords, private keys and other secrets out of flag values. Treat configuration delivered to the phone as information the recipient may be able to inspect.
Who should own each flag?
Give every flag a named owner and a recorded purpose. Ownership means someone is responsible for deciding when to enable it, checking the result and removing it.
Keep a short record containing:
- The behaviour it controls.
- Its default and fallback.
- Who may change it.
- Supported app versions.
- The checks required before wider exposure.
- The condition for removal.
Keep related decisions together. If two settings must change together for a flow to work, design one coherent configuration rather than relying on someone to update them in the correct order.
Include flag review in app maintenance after launch, alongside updates and fault fixes.
What common mistakes should you avoid?
Testing only the enabled state. Check enabled, disabled, missing, invalid and stale settings. Include first launch without connectivity and a failed refresh. The guide to testing an Android app before release provides a broader testing checklist.
Assuming every installed version understands every flag. Define which versions support a setting and preserve a compatible fallback.
Switching during unfinished work. Decide how active forms, payments or uploads complete before applying a changed setting.
Leaving temporary flags indefinitely. Once the decision is settled, remove the unused path and its configuration. Check older supported versions before deleting settings they still depend on.
Using flags without a decision to make. A simple feature that should be available to everyone may only need a normal release.
What are the frequently asked questions?
Does every mobile app need feature flags?
No. Add them when controlled exposure or a specific recovery option justifies the extra testing and maintenance. Start with the smallest useful set.
Can a flag fix a broken feature?
It can select a working alternative if that alternative already exists. Repair faulty code through the appropriate app or server change.
Should an app wait for settings before opening?
Prefer a usable default where possible. Only block progress when a fresh decision is necessary, and explain what the user can do if it cannot be obtained.
When should a temporary flag be removed?
Remove it after the rollout decision is complete and supported app versions no longer need the temporary choice. Include removal of unused code, configuration and obsolete tests in the completion plan.