What is FeatureFlags.app?
FeatureFlags.app is a privacy-first feature flag management platform built specifically for .NET applications. It allows development teams to release, test, and disable features without redeploying their applications, giving you greater control over software releases while keeping your application data private.
Why should I use feature flags?
Feature flags let you separate feature deployment from feature release. Instead of waiting for your next deployment, you can:
- Roll out new features gradually
- Instantly disable problematic functionality
- Test features safely in production
- Release to specific users or groups
- Reduce deployment risk
This gives your team more flexibility and confidence when shipping software.
Who is FeatureFlags.app for?
FeatureFlags.app is ideal for:
- .NET development teams
- Organizations that value data privacy
- Teams looking for a lightweight feature flag solution
- Companies wanting cloud flexibility
- Developers who prefer native Microsoft integrations
- Businesses that want reliable feature management without enterprise complexity
How is FeatureFlags.app different from other feature flag services?
FeatureFlags.app is designed around a few core principles:
- Privacy-first — We don't track your users or collect analytics.
- Cloud agnostic — Host wherever you want.
- Built for .NET — Native support for Microsoft's Feature Management libraries.
- Simple pricing — No unnecessary enterprise complexity for teams that just need reliable feature flags.
Does FeatureFlags.app collect analytics or user tracking data?
No. Unlike many hosted feature flag platforms, FeatureFlags.app does not collect analytics, record user sessions, or monetize usage data. Your application data remains yours.
Does FeatureFlags.app work with Microsoft's Feature Management libraries?
Yes. FeatureFlags.app is designed to integrate naturally with Microsoft's Feature Management libraries, making it easy for .NET developers to adopt without changing familiar development patterns.
Can I release features gradually?
Absolutely. FeatureFlags.app supports percentage-based rollouts so you can safely introduce new functionality to a small percentage of users before expanding availability to everyone. This helps reduce risk and catch issues early. This is useful for:
- Progressive deployments
- Canary releases
- Reducing deployment risk
- Monitoring production behavior before full rollout
Can I target specific users?
Yes. You can create targeting rules that enable features for specific users before rolling out broadly. This is useful for:
- Beta programs
- Early access customers
- Internal testing
- Premium features
Can I change a feature flag without restarting my application?
Yes. One of the primary advantages of FeatureFlags.app is that feature changes are picked up automatically during synchronization. Once the client refreshes its configuration, new feature values become available without redeploying or restarting your application. If an issue occurs, you can disable the affected feature while keeping the rest of your application running normally.
Does FeatureFlags.app support multiple environments?
Yes. You can manage feature flags separately across different environments such as:
- Development
- Testing
- Staging
- Production
This makes it easy to validate features before releasing them to production.
Does FeatureFlags.app keep an audit history?
Yes. FeatureFlags.app includes audit logs so you can see when feature flags were changed and maintain visibility into configuration updates across your team.
Can I migrate from another feature flag platform?
Yes. If you're currently using another feature flag provider, FeatureFlags.app can fit into your existing deployment workflow, allowing you to transition your feature management while continuing to use familiar .NET development practices.
How long does it take to get started?
Most teams can get started in just a few minutes. The typical process is:
- Create your feature flags.
- Integrate the .NET library into your application.
- Configure your API keys.
- Begin managing releases without redeploying.
The Quick Start Guide walks you through the entire setup process.
How are feature flags evaluated?
Feature flag evaluations are designed to be fast and efficient. Rather than making a network request every time a flag is checked, the client maintains a local cache of feature definitions. Your application evaluates flags locally while periodically synchronizing changes from the FeatureFlags.app server. This approach provides:
- Low latency
- High throughput
- Reduced network traffic
- Reliable behavior during temporary network interruptions
What happens if the FeatureFlags.app server becomes unavailable?
Your application continues running. The client uses locally cached feature definitions and falls back to configured default values when necessary. Temporary connectivity issues won't prevent your application from evaluating feature flags.
How often does the client synchronize with the server?
The synchronization interval is configurable. Most applications use a short refresh interval that keeps feature changes current while minimizing network traffic.
Does evaluating a feature flag require an HTTP request?
No. Feature evaluations occur locally using the client's cached configuration. Network requests are only required during periodic synchronization, not during normal application execution. This keeps feature checks extremely fast, even under heavy load.
Is FeatureFlags.app suitable for high-traffic applications?
Yes. Because feature evaluations occur locally using cached data, the runtime overhead is extremely small. Applications can evaluate feature flags thousands of times per second without introducing network latency or placing unnecessary load on the FeatureFlags.app server.
How are API keys used?
API keys authenticate your application with the FeatureFlags.app service. Each application or environment can use its own API key, making it easy to isolate access between development, staging, and production deployments.
Can I use FeatureFlags.app with microservices?
Yes. Each service can use its own API key, feature set, or environment while sharing a common FeatureFlags.app instance. This makes it easy to manage feature releases consistently across distributed systems.
How much overhead does the client add?
Very little. The client is designed so that feature evaluation is effectively an in-memory lookup. Since configuration is cached locally and refreshed in the background, the performance impact on request processing is negligible for most applications.
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.