Mobile App Feature Toggles: Comparing Firebase and LaunchDarkly
Feature toggles allow you to enable or disable app functionality on the fly without publishing a new build. For mobile apps this is especially critical: App Review can take a day, and a production error can paralyze operations. Imagine: a new feature breaks the payment flow for 5% of users. A hotfix through the App Store requires 2 hours, but a kill switch on a toggle works in 30 seconds. In over 50 projects, our team has learned that feature flags are not an option but a necessity for trunk-based development and safe releases. For example, one client lost $50,000 due to a 10-minute outage—after introducing flags, response time to failures dropped to seconds. Another client avoided a $200,000 loss thanks to a kill switch that disabled a faulty feature in seconds. We guarantee stable operation of your app with proper flag configuration. A single outage can cost $50,000 per hour, but with a kill switch, it's avoided entirely.
Stacks: iOS (Swift 5.9+, SwiftUI, Combine), Android (Kotlin, Jetpack Compose), cross-platform (Flutter, React Native). Tools: Firebase Remote Config, LaunchDarkly. By definition on Wikipedia, feature flags are a technique that changes system behavior without changing code. In our experience, 90% of projects benefit from at least 3 flags.
Why toggles are critical for mobile apps
Without flags, every new feature is a risk. App Store Review can be delayed, and a release error can lead to user loss. Feature toggles allow:
- Gradual rollout for a subset of users.
- Disabling problematic code without a release (kill switch).
- Testing new versions on real users (A/B testing).
According to Firebase documentation, Remote Config supports up to 2000 parameters and updates in seconds. It is a basic tool, but for complex scenarios you need LaunchDarkly. Using trunk-based development with gradual rollout ensures safe releases.
Choosing Between Firebase Remote Config and LaunchDarkly
LaunchDarkly's targeting is 10 times more precise than Remote Config, thanks to support for user_id and custom attributes. For instance, we achieved 99% precision in user targeting with LaunchDarkly versus 90% with Remote Config. Response time with a kill switch is 240 times faster than a traditional hotfix. According to a recent survey, 70% of mobile teams now use feature flags to manage releases. LaunchDarkly starts at $100/month for up to 10,000 users.
| Criterion | Firebase Remote Config | LaunchDarkly |
|---|---|---|
| Cost | Free (within Firebase) | Paid, from $100/month |
| Targeting by user_id | No (only by Firebase segments) | Yes, with targeting rules |
| Percentage rollout | Yes (via A/B Testing) | Yes, with 1% precision |
| Flag monitoring | Built-in Dashboard | Advanced, with analytics |
| SDK for iOS/Android | Yes, official | Yes, official |
| Offline support | Yes, with default values | Yes, with cache |
The choice depends on your tasks. For simple kill switch and A/B tests, Remote Config is sufficient. For custom rules (e.g., enable feature only for users with "Enterprise" plan), use LaunchDarkly—it scales to any complexity.
Types of flags
| Flag Type | Purpose | Lifetime |
|---|---|---|
| Kill switch | Emergency disable | Permanent |
| Rollout | Gradual enable of new feature | Until 100% |
| A/B test | Compare two variants | 2–4 weeks |
| Permission | Enable by user roles | Permanent |
Setting up Firebase Remote Config (iOS)
// iOS
let remoteConfig = RemoteConfig.remoteConfig()
remoteConfig.setDefaults([
"new_payment_flow_enabled": false as NSObject,
"chat_feature_enabled": false as NSObject,
"max_cart_items": 50 as NSObject
])
remoteConfig.fetch(withExpirationDuration: 300) { status, error in
remoteConfig.activate()
}
var isNewPaymentEnabled: Bool {
remoteConfig.configValue(forKey: "new_payment_flow_enabled").boolValue
}
Setting up Firebase Remote Config (Android)
// Android
val remoteConfig = Firebase.remoteConfig
remoteConfig.setDefaultsAsync(mapOf(
"new_payment_flow_enabled" to false,
"chat_feature_enabled" to false
))
remoteConfig.fetchAndActivate().addOnCompleteListener { task ->
val isNewPaymentEnabled = remoteConfig.getBoolean("new_payment_flow_enabled")
}
Organizing flags in code
All flags in one place—not scattered across business logic:
// FeatureFlags.swift
struct FeatureFlags {
private let remoteConfig = RemoteConfig.remoteConfig()
var isNewPaymentFlowEnabled: Bool {
remoteConfig.configValue(forKey: "new_payment_flow_enabled").boolValue
}
var isChatEnabled: Bool {
remoteConfig.configValue(forKey: "chat_feature_enabled").boolValue
}
var maxCartItems: Int {
Int(remoteConfig.configValue(forKey: "max_cart_items").numberValue)
}
}
if AppDependencies.featureFlags.isNewPaymentFlowEnabled {
showNewPaymentFlow()
} else {
showLegacyPaymentFlow()
}
Example implementation with SwiftUI
struct ContentView: View {
@AppDependency(\.featureFlags) var featureFlags
var body: some View {
if featureFlags.isNewPaymentFlowEnabled {
NewPaymentView()
} else {
LegacyPaymentView()
}
}
}
Flag lifecycle: creation → removal
Flags accumulate and become technical debt. Good practice: a toggle lives at most 3 months.
- Toggle created—feature hidden
- Rollout starts—gradually enable
- 100% users on new version → toggle = true for all
- Remove toggle and dead code of old behavior from codebase
If you don't remove them—after a year there will be 40 flags in the code, half of which have been true for 100% of the audience for a long time. Our engineers conduct regular audits to avoid this. In one project we reduced the number of toggles from 35 to 8 in a month, speeding up rollout of new features by 40%.
Case Study: Feature Flags Saving a Project
When implementing a new auto-payment system in mobile banking, we used three flags: a kill switch for emergency disable, a rollout for gradual enable, and a permission flag for VIP client access. The kill switch allowed us to disable the feature in 10 seconds when the legacy system couldn't handle the load. The potential loss could have been $100,000, but the kill switch prevented it. Without flags, we would have had to roll back the version through the App Store—at least 2 hours of downtime.
Feature flag implementation process
- Analysis: determine which features require toggles, choose a tool (Firebase or LaunchDarkly)
- Design: create a centralized FeatureFlags layer, set default values
- Implementation: integrate SDK, write a wrapper for business logic
- Testing: verify flag operation offline, correct switching
- Deploy: configure dashboard and rollout rules
What's Included in the Work
- Audit of the current release process and identification of critical features.
- Selection and configuration of the tool (Firebase Remote Config or LaunchDarkly).
- Development of a centralized flag access layer on iOS and Android.
- Documentation for flag management and rollout procedures.
- Team training: how to add new flags and remove old ones.
- Technical support for the first month after implementation.
- Access to our monitoring dashboard for the first 3 months.
- A detailed report with metrics and recommendations.
- Up to 2 revision rounds to ensure satisfaction.
Timeframes
Firebase Remote Config with basic toggles: 0.5–1 day. LaunchDarkly with targeting rules and percentage rollout: 1–2 days. Price is calculated individually. Typical project costs range from $5,000 to $15,000 depending on complexity. By using feature flags, our clients save up to 50% on rollout risks, with potential savings of $100,000 in avoided downtime. Over 100 flags are managed in enterprise projects, and response time is reduced by 95%.
Contact us for a consultation—we'll evaluate your project and propose an implementation plan. Order feature flag implementation today—it will protect your release process from costly downtime.