FAQs
How flags refresh, what happens during an outage, plan limits, exporting flags, and migrating from Microsoft.FeatureManagement.
What is FeatureFlags.app?
FeatureFlags.app is a hosted dashboard and API for managing feature flags in .NET applications. You check flags in your code with Microsoft's Feature Management library (IFeatureManager, [FeatureGate], and the <feature> tag helper), and you change them in the dashboard instead of editing appsettings.json and redeploying.
Why should I use feature flags?
Feature flags separate deploying code from releasing a feature. With them you can:
- Roll a feature out to a percentage of users
- Turn off a problematic feature without redeploying
- Test a feature in production with specific users first
- Switch a feature on or off at a scheduled time
Who is FeatureFlags.app for?
ASP.NET Core teams on .NET 10 or later who already use Microsoft.FeatureManagement, or want to, and would rather not run their own flag storage or set up an Azure subscription for it. Flags are managed per organization and environment, with no per-user or monthly-active-user pricing.
How is FeatureFlags.app different from other feature flag services?
- It works with the code you already have. Your
IFeatureManager,[FeatureGate], and<feature>code stays the same. Only the package and configuration change. - No Azure subscription required. Your app can run anywhere that can reach the internet.
- Flags are evaluated inside your app. The client downloads flag definitions, so your users' identities and evaluation results are never sent to us.
- No lock-in. You can export any environment as standard Microsoft.FeatureManagement JSON on every plan, and the client is MIT-licensed.
- Pricing is by flag count. Environments, users, and applications are unlimited. See pricing.
It is a hosted service only. You cannot self-host FeatureFlags.app.
Does FeatureFlags.app collect analytics or user tracking data?
The client only downloads your flag definitions. Flag evaluation happens inside your application, so the identities of your users and the results of evaluations are never sent to FeatureFlags.app. The details are in our privacy policy.
Does FeatureFlags.app work with Microsoft's Feature Management libraries?
Yes. builder.AddFeatureFlags() registers Microsoft.FeatureManagement with a provider that reads your flags from FeatureFlags.app. After that, IFeatureManager, IFeatureManagerSnapshot, the [FeatureGate] attribute, and the <feature> tag helper work as they do with any other flag source. Flags use Microsoft's built-in Targeting and TimeWindow filters, so the same definitions also load in a plain appsettings.json.
Can I release features gradually?
Yes. Add a targeting filter and set its rollout percentage, and that share of users gets the feature. Microsoft's Targeting filter places each user in or out of the rollout based on their identity and the flag name, so a user sees the same behavior on every request. Raising the percentage keeps the users who were already in.
Users are identified by User.Identity.Name by default, and their groups come from their role claims. Requests without an identity are all treated the same, so a rollout is all on or all off for anonymous traffic unless you supply your own targeting context.
Can I target specific users?
Yes. A targeting filter lets you list the users and groups a feature is on for, set a rollout percentage for everyone else (and a separate one for each group), and exclude users and groups that should never get it. Groups come from your app's targeting context, which by default uses the user's role claims. You can also combine it with a time window and choose whether a user must match any or all of a flag's filters. For more complex rules, a custom filter written as JSON is passed to a filter class you implement in your app.
Can I change a feature flag without restarting my application?
Yes. The client refreshes flag definitions in the background, so a change reaches your app within your refresh interval (15 minutes by default, configurable) without a restart or redeploy. If a feature misbehaves, turn it off in the dashboard and it goes off in every running instance within that interval. Apps that rely on kill-switch flags should use a shorter interval, down to the minimum of 1 minute. While your flags are unchanged each refresh gets an empty 304 Not Modified response, so a short interval costs little.
Does FeatureFlags.app support multiple environments?
Yes. You can create as many environments as you need, such as development, staging, and production, on every plan. Each flag belongs to one environment, and each API key reads the flags of one environment, so your production app never sees development flags.
Does FeatureFlags.app keep an audit history?
Yes. Audit logs record changes to your flags and other settings, so you can see what changed and when.
Can I migrate from another feature flag platform?
Yes, with a small code change. If your app already uses Microsoft.FeatureManagement, your flag-checking code stays the same: IFeatureManager, IFeatureManagerSnapshot, [FeatureGate], and the <feature> tag helper keep working.
What changes:
- Add the
Acmi.FeatureFlags.Clientpackage and callbuilder.AddFeatureFlags(). - Add a
FeatureFlagsconfiguration section withApiBaseEndpointandApiKey, replacing the flags inappsettings.jsonor your Azure App Configuration setup. - Import your flags into the dashboard from the
feature_managementsection of yourappsettings.json, or recreate them by hand. Flag names must be unique within an environment, and flags beyond your plan's limit are not imported.
If you use another vendor's SDK instead of Microsoft.FeatureManagement, the calls to that SDK need to be rewritten to IFeatureManager.
Can I export my flags?
Yes, on every plan, including the free plan and while you are over your flag limit. Choose an environment and export all of its flags as standard Microsoft.FeatureManagement JSON, as a file download or copied to the clipboard. The output works in a plain appsettings.json without the FeatureFlags.app client. Custom filters are exported as-is, and your app needs matching filter classes. Targeting filters, including their rollout percentages, are exported as Microsoft's Targeting filter, so your app must call .WithTargeting().
How long does it take to get started?
Most teams can get started in a few minutes. The typical process is:
- Create your feature flags.
- Add the .NET library to your ASP.NET Core application (.NET 10 or later).
- Configure your API key.
- Start managing releases without redeploying.
The Quick Start Guide walks you through the setup.
How are feature flags evaluated?
Locally, inside your app. The client keeps an in-memory copy of your flag definitions and refreshes it in the background. Checking a flag reads that copy and never waits on an HTTP call, so evaluation adds no network latency and keeps working when the network does not.
How often does the client synchronize with the server?
The client fetches definitions when your app starts and then every CacheExpirationInMinutes, which is 15 minutes by default and configurable down to a minimum of 1 minute. While healthy and without a manual refresh, each running instance makes one request per interval. Failed fetches are retried with increasing delays. Calling IFeatureFlagClient.ClearCache() tells the background service to refresh now.
Does evaluating a feature flag require an HTTP request?
No. Evaluating a flag reads the in-memory copy of your definitions. HTTP requests happen only in the background refresh.
What happens if the FeatureFlags.app server becomes unavailable?
Your app keeps running with the last definitions it fetched successfully (the last-known-good copy). If a refresh fails because of a timeout, a network error, a server error, or a rejected API key, the client logs a warning, keeps the old copy, and retries with increasing delays capped at the configured refresh interval. After a prolonged outage, recovery can therefore take up to one refresh interval. Long outages are logged once an hour rather than on every retry.
What if my app starts while FeatureFlags.app is unreachable?
Then there is no copy to fall back on yet, so every flag evaluates to off until the first successful fetch. The client waits up to five seconds for the first fetch at startup, then lets your app start and keeps retrying in the background. Nothing is thrown into your request pipeline. If a feature must not be off by default, design it so that off is a safe state.
What happens if I exceed my feature flag limit?
While you are over your plan's limit, the API stops sending your flags: it returns 402 Payment Required, and apps using our client keep the flags they already loaded instead of turning them off. An app that starts while you are over the limit has every flag off until it can load them. You also cannot create, edit, or toggle flags, but you can still delete them and you can still export. Delete flags to get back under the limit, or upgrade your plan, and your flags are served again straight away. See pricing for plan limits.
What happens if my paid subscription ends or a payment fails?
Your organization moves to the free plan. You can still sign in, see and export your flags, and renew from the billing page. If you have more flags than the free plan allows, the over-limit rules above apply until you renew or delete flags. If a renewal payment fails, the same happens until the payment goes through.
How much overhead does the client add?
Very little. A flag check is an in-memory lookup plus Microsoft's filter evaluation, with no network call. The background refresh makes one request per interval for each running instance of your app.
How are API keys used?
API keys authenticate your application with FeatureFlags.app, and each key reads the flags of one environment. Use a separate key for each environment, and for each application if you want to be able to revoke access separately. Keep keys in user secrets or environment variables, not in source control.
Can I use FeatureFlags.app with microservices?
Yes. Each service can have its own API key, and all of them can read the same environment, so a flag defined once applies across services. Applications and service connections are unlimited on every plan.
Need more help?
If you have additional questions, try our issues page or visit our documentation for more information.
Ready to Ship Features More Safely?
Start with the free plan in minutes. Upgrade only when your applications grow.