10 Best Feature Flag Tools for DevOps Rollouts

Feature flag tools let you deploy code switched off, then release it to a small share of users and widen the rollout without a new deployment. LaunchDarkly, Harness FME (formerly Split), Optimizely and Statsig lead the commercial field. Unleash, Flagsmith, GrowthBook, Flipt and flagd are the main self-hostable options, and OpenFeature keeps your code vendor neutral.

Feature flags are one of several release techniques in CI/CD. If you are new to the idea, start with how feature flags enable safe continuous deployment and our overview of CI/CD deployment rollout types. This page compares the platforms that manage flags, with license, ownership and hosting checked on each vendor's site in November 2026.

Key takeaways

• Ownership has changed across this market. Split is now part of Harness and sold as Harness Feature Management & Experimentation (FME). Statsig was bought by OpenAI in 2025, and since May 2026 Amplitude has taken on the Statsig brand, platform and customers. Datadog bought Eppo in 2025 and now sells Datadog Feature Flags.
• "Open source" means different things. Unleash core is AGPL-3.0, Flagsmith is mostly BSD-3-Clause, GrowthBook and FeatBit are MIT open core, flagd is Apache-2.0, and Flipt v2's server uses the Fair Core License.
• OpenFeature, a CNCF incubating project, gives you one flag API across vendors. Write code against OpenFeature and you can switch providers by changing one line of setup.
• Pick by need: release control and governance (LaunchDarkly, Harness FME, Unleash), experimentation (Optimizely, Statsig, GrowthBook), simple hosted flags (ConfigCat), or Git-based flags with no UI (Flipt v2, flagd).
• Every flag is temporary debt. Give each release flag an owner and a removal date, and delete it once the rollout reaches 100%.

What to compare before you choose

Most platforms can turn a feature on for 10% of users. The differences show up in five places.

• Where flags are evaluated. Server-side SDKs usually download the rules and evaluate locally, which is fast and keeps user data inside your service. Client-side SDKs for browsers and mobile apps either evaluate a pre-computed set of flags or call a proxy. Ask how each tool handles both, and what happens if its service is unreachable.
• SDK coverage and OpenFeature support. Check your languages, including mobile and edge runtimes, and whether an OpenFeature provider exists.
• Governance. Larger teams need role-based access, approvals for production changes, audit logs and environment separation.
• Experimentation. Some tools only switch features. Others run A/B tests with a statistics engine, and some analyse results directly in your data warehouse.
• Hosting and data residency. Decide whether SaaS is acceptable or whether you must self-host, and check the license if you plan to modify or embed the software.

Feature flag tools comparison

Commercial platforms

1. LaunchDarkly

LaunchDarkly is the best known dedicated feature management platform. Its site now groups the product into CodeControl, covering flags, targeting, progressive rollouts, automated rollbacks, observability (errors, logs, traces and session replay) and experimentation, and AgentControl, which applies the same release controls to AI agents and prompts. It has also announced Release Autopilot to automate flagging, rollouts, rollbacks and cleanup.

Choose LaunchDarkly when many teams release independently and you need approvals, audit trails and rollbacks triggered by monitoring. Expect enterprise pricing, and check the vendor's pricing page for the current model.

2. Harness FME (formerly Split)

Harness acquired Split in June 2024, and the split.io site now states that Split is part of Harness. The product is called Harness Feature Management & Experimentation (FME). It covers feature flags with progressive rollouts and kill switches, versioned configs, AI configs for swapping prompts and models at runtime, A/B and multivariate experiments, warehouse-native analysis and release monitoring that can trigger rollbacks. Existing Split accounts are migrated into a Harness organization.

FME fits best if you already run Harness CI/CD, because flag changes and deployments can live in the same pipelines and governance model.

3. Optimizely Feature Experimentation

Optimizely Feature Experimentation combines feature flags, targeted deliveries for gradual rollouts and quick rollbacks, remote configuration and A/B tests analysed by Optimizely's Stats Engine. Open source client-side and server-side SDKs are on GitHub. Optimizely Rollouts is the free plan, with free feature flags and one A/B test.

It suits organisations where product and marketing teams already run experiments in Optimizely and want engineering releases on the same platform.

4. Statsig

Statsig offers experimentation, feature flags, product analytics, session replay and web analytics, with cloud and warehouse-native deployment and a free tier. Its ownership has changed twice. OpenAI announced the acquisition of Statsig in September 2025. On 5 May 2026 Amplitude announced that it was taking on Statsig's brand and customers and would maintain and develop the platform, working with the Statsig team at OpenAI during the transition. Statsig's site now says it is "part of the Amplitude family."

Existing customers should watch the combined roadmap. New buyers should ask about product direction and contract terms before committing.

Open source and self-hosted options

5. Unleash

Unleash is one of the most widely used self-hosted flag servers. The open source edition runs on Docker or Node.js, and the repository's license file is AGPL-3.0. The Enterprise edition, hosted or self-managed, adds role-based access, change requests, SSO and SCIM. Rollouts are built from activation strategies: a gradual rollout assigns a percentage of users using a hash of their ID with stickiness, and constraints and reusable segments narrow who is eligible. Unleash Edge sits between SDKs and the server to evaluate flags for frontend clients and reduce load.

git clone https://github.com/Unleash/unleash.git
cd unleash
docker compose up -d
# UI on http://localhost:4242 (change the default admin password immediately)

6. Flagsmith

Flagsmith provides feature flags, remote config, segments and A/B or multivariate tests. Most of the code is BSD-3-Clause, with a few repositories under MIT, and the company says the core will stay open. You can self-host the open source build, buy the Enterprise edition, or use private or hosted cloud. Flagsmith has OpenFeature providers for Go, Java, JavaScript, Kotlin, .NET, Python, Ruby and Rust.

The permissive license makes Flagsmith a good choice when legal teams are wary of AGPL or source-available terms.

7. GrowthBook

GrowthBook is an open core platform: most code is MIT and some directories fall under the GrowthBook Enterprise License. It does feature flags with targeting and gradual rollouts, but its strength is experimentation. The statistics engine supports CUPED, sequential testing, Bayesian analysis and bandits, and metrics are defined in SQL against your own warehouse, such as BigQuery, Snowflake or Databricks. It publishes 24 SDKs and self-hosts with docker compose up -d.

8. ConfigCat

ConfigCat is a hosted flag and remote configuration service with segment targeting, percentage rollouts and A/B testing. Its SDKs are MIT licensed and evaluate flags inside your application, so user data used for targeting does not leave your system; ConfigCat stores only flag values and rules. It has a Forever Free plan and an on-premise option. It is a practical pick for small teams that want flags without running servers.

9. Flipt

Flipt v2 stores flags in your own Git repositories, so flag changes go through branches, pull requests and review like any other code. Version 1 was database-backed (MySQL, PostgreSQL or SQLite). The v2 server is licensed under the Fair Core License 1.0 with an MIT future license, while client code and the Go SDK are MIT. Flipt supports OpenFeature, including the OpenFeature Remote Evaluation Protocol (OFREP).

Flipt suits platform teams that already run GitOps and want flag history in Git rather than in another database.

10. flagd and OpenFeature

flagd is a small, Apache-2.0 licensed flag daemon from the OpenFeature project. It has no UI or database: flag definitions come from files, HTTP endpoints, Kubernetes custom resources or gRPC sync sources, and flagd watches them for changes. Applications talk to it through an OpenFeature SDK and the flagd provider. It is the simplest way to run flags as configuration, and a good way to learn OpenFeature before choosing a vendor.

{
  "$schema": "https://flagd.dev/schema/v0/flags.json",
  "flags": {
    "new-checkout": {
      "state": "ENABLED",
      "variants": {
        "on": true,
        "off": false
      },
      "defaultVariant": "off",
      "targeting": {
        "fractional": [
          { "var": "email" },
          ["on", 10],
          ["off", 90]
        ]
      }
    }
  }
}

The fractional rule buckets each user deterministically by the email value in the evaluation context, so the same user keeps the same variant while you raise the percentage from 10 to 25, 50 and 100. Run flagd with the official container image (ghcr.io/open-feature/flagd) using its start --uri option to point at the file; the evaluation API listens on port 8013 in the quick-start.

Write vendor-neutral code with OpenFeature

OpenFeature is an open specification and set of SDKs for feature flag evaluation, hosted by the CNCF as an incubating project under the Apache 2 license. SDKs exist for Java, Node.js, .NET, Go, Python, PHP, web frameworks, Kotlin, Swift, Ruby, Dart, Rust and C++. Vendors and open source tools supply "providers" that plug into the SDK.

# pip install openfeature-sdk openfeature-provider-flagd
from openfeature import api
from openfeature.contrib.provider.flagd import FlagdProvider
from openfeature.evaluation_context import EvaluationContext

api.set_provider(FlagdProvider())        # connects to flagd on localhost:8013
client = api.get_client()

ctx = EvaluationContext(
    targeting_key="user-4821",
    attributes={"email": "[email protected]", "plan": "pro"},
)
if client.get_boolean_value("new-checkout", False, ctx):
    render_new_checkout()
else:
    render_old_checkout()

The application code only knows the flag key and a default value. To move from flagd to Flagsmith, Unleash or a commercial platform with an OpenFeature provider, you change the set_provider line. The default value (False here) is what users get if the provider cannot be reached, so choose the safe option.

Other tools worth knowing

• AWS AppConfig: feature flag and free-form configuration profiles with validators, gradual deployment strategies and automatic rollback when a CloudWatch alarm fires. It now also offers experimentation.
• Datadog Feature Flags: Datadog's flag product, built on the OpenFeature standard and tied to APM, RUM, logs and SLOs. Datadog acquired Eppo in May 2025.
• FeatBit: an MIT open core flag server with Helm, Terraform and Docker Compose deployment options.
• PostHog and Azure App Configuration also include feature flags as part of wider products.

A safe rollout workflow with any tool

1. Deploy dark. Merge the code behind a flag that defaults to off. This supports trunk-based development, because unfinished work can sit in main without affecting users.
2. Enable for internal users. Target your own team by email domain or a segment and test in production.
3. Start a percentage rollout. Go to 1% or 5% with sticky bucketing, and watch error rates, latency and business metrics for that cohort.
4. Automate the stop. Connect the rollout to alerts so a bad signal turns the flag off. LaunchDarkly, Harness FME and AWS AppConfig all support monitoring-driven rollback.
5. Increase in steps. 25%, 50%, 100%, with a pause at each step long enough to see real traffic.
6. Remove the flag. Delete the old code path and the flag in the same sprint. Stale flags make code harder to read and test.

Flags work at the application level. Canary and blue-green deployments work at the infrastructure level, and many teams use both. Read how canary releases reduce risk and Kubernetes rollout strategies with examples to see where each fits, and why feature flags matter for progressive delivery for the bigger picture.

Managing flag debt

Teams that adopt flags quickly often end up with hundreds of forgotten ones. A few rules keep that under control:

• Name flags by type: release-, experiment-, ops- (kill switches) and permission-. Release and experiment flags are short-lived; ops and permission flags may be permanent.
• Record an owner and an expected removal date when the flag is created. Several platforms can mark flags as stale; Harness FME has a cleanup agent that drafts pull requests.
• Test both paths in CI while a flag exists, then remove the losing path.
• Limit who can change production flags, and keep the audit log. A flag change is a production change.

Which tool should you pick?

Whatever you choose, write the code against OpenFeature where a provider exists. It keeps the decision reversible. Flags are one part of a release pipeline; our list of CI/CD tools for deployment pipelines covers the rest.

Learn progressive delivery hands-on

Our DevOps training covers CI/CD pipelines, Kubernetes deployments, canary and blue-green releases and feature flags in practical labs, in our Kharadi, Pune classroom or live online across India.

FAQs

What is a feature flag tool?

It is a service that stores flag rules and lets applications check them at runtime through an SDK. You can turn features on or off, target users or segments, and roll out to a percentage of traffic without deploying new code. Most tools add audit logs, environments and experiments.

Which feature flag tool is open source?

Unleash (AGPL-3.0 core), Flagsmith (mostly BSD-3-Clause), GrowthBook and FeatBit (MIT open core) and flagd (Apache-2.0) are open source. Flipt v2's server uses the Fair Core License, which converts to MIT later. Check each license before you modify or embed the software.

Is Split still available?

Split is now part of Harness and is sold as Harness Feature Management & Experimentation (FME). Existing Split accounts are migrated into Harness organizations, and the split.io site states that Split is part of Harness.

Who owns Statsig now?

OpenAI announced its acquisition of Statsig in September 2025. In May 2026 Amplitude announced it was taking on Statsig's brand, platform and customers, and Statsig's website describes it as part of the Amplitude family.

What is OpenFeature and why use it?

OpenFeature is a CNCF incubating project that defines a vendor-neutral API and SDKs for flag evaluation. Your code calls OpenFeature, and a provider connects it to flagd, Flagsmith, Flipt, Datadog or another backend. Switching vendors then means changing the provider setup, not every flag check.

What is the difference between a feature flag and a canary release?

A canary release sends a share of traffic to a new deployment of the whole service. A feature flag switches one feature inside a single deployment, for chosen users. Flags are finer grained and can be turned off instantly; canaries also catch infrastructure and performance problems.

Are feature flags free?

Self-hosted open source editions are free to run, apart from your infrastructure. ConfigCat has a Forever Free plan, Optimizely offers the free Rollouts plan and Statsig has a free tier. Paid plans add governance, scale and support, so check each vendor's pricing page.

How many feature flags is too many?

There is no fixed number. The problem is stale flags, not total count. If release flags stay in the code after reaching 100%, or nobody knows who owns a flag, you have too many. Track owners and removal dates and clean up every sprint.

References

• LaunchDarkly
• Harness Feature Management & Experimentation
• Harness Developer Hub: Split and Harness
• Split is now part of Harness
• Optimizely Feature Experimentation documentation
• Statsig
• Amplitude: Amplitude and Statsig partnership
• Unleash repository
• Unleash activation strategies
• Flagsmith repository
• GrowthBook repository
• ConfigCat
• Flipt repository
• flagd documentation
• flagd flag definitions
• OpenFeature
• OpenFeature Python SDK
• AWS AppConfig user guide
• Datadog Feature Flags documentation
• Datadog acquires Eppo