There is one architectural decision inside a feature flag platform that determines almost everything else about how it behaves in production, and most evaluations never reach it.
The decision is where the flag is evaluated. Either the SDK holds a full copy of the flag rules in memory and computes the answer locally, or it asks a server and waits for the response. Everything you care about follows from that: how long a flag check takes, what happens when the vendor is down, whether user attributes leave your infrastructure, how many flags you can have before it matters, and whether the platform can tell you which users saw which variant.
Teams discover this in the worst way. A flag check goes into a hot path, the SDK is in remote evaluation mode, and a request that used to complete in a few milliseconds now contains a network round trip to another cloud. Or the flag service has a bad hour and every request in the application blocks on a timeout that nobody configured, because the default was generous and the failure mode was never tested.
The second thing worth understanding before you look at products is that a flag platform is a write-mostly system that becomes a permanent part of your codebase. Every flag is a branch in the code that someone has to delete later. Teams reliably create flags and unreliably remove them, and after two years the flag count is a number nobody wants to say out loud. Whether the platform helps you find and remove stale flags is not a nice-to-have feature, it is the difference between a tool that pays for itself and a tool that quietly increases the complexity of every file it touches.
Key takeaways
- Local evaluation means the SDK holds the rules and answers in memory, so a flag check is a function call. Remote evaluation means a network request per check, or per batch, with all the latency and availability consequences that implies.
- Local evaluation ships your targeting rules to every client that holds them, which is fine on a server and a data exposure question in a browser or mobile app.
- Flag debt is the real long-term cost. Ask specifically how the platform detects stale flags and whether it can find the code references, not just the dashboard entry.
- Targeting rule complexity is a slope: percentage rollouts are easy, attribute targeting is manageable, and segment-of-segment logic with mutual exclusion is where teams start needing a person who understands the evaluation order.
Local versus remote evaluation, and why it decides everything
How local evaluation works
The SDK connects to the platform at startup, downloads the full rule set for every flag in the environment, and keeps it in memory. It then subscribes to changes, usually over a streaming connection or by polling. When your code asks for a flag value, the SDK evaluates the rules against the context you pass in and returns an answer without touching the network.
Consequences, all of which follow directly:
Evaluation is a local computation. The cost is rule evaluation plus hashing for percentage rollouts, which is a function call rather than an I/O operation. You can call it in a loop.
A vendor outage does not take you down. The SDK already has the rules. If the streaming connection drops, flags keep evaluating with the last known configuration. What you lose is the ability to change a flag, which matters during an incident but does not break the application.
Your user data stays put. The context, which typically includes user IDs, emails, plan tiers, and whatever else you target on, never leaves your process. For anything regulated this is usually the deciding factor.
Startup has a cold window. Between process start and the first successful rule download, the SDK returns whatever default you passed. On a server that is a moment. On a serverless function that starts fresh per invocation, it can be every invocation, which is why serverless deployments need either a persistent cache layer or a different evaluation mode entirely.
The client holds your rules. This is the sharp edge. A browser SDK in local evaluation mode has downloaded your targeting logic, which can include segment definitions that reveal customer names, unreleased feature names, and business logic. This is why most platforms run mobile and browser SDKs in remote mode by default and reserve local evaluation for server-side SDKs.
How remote evaluation works
The SDK sends the evaluation context to the platform and receives the computed values. Usually it requests all flags for a context at once and caches the result for the session rather than making a call per flag.
Latency is a network round trip, which depends on where the evaluation endpoint is. Platforms that evaluate at the edge reduce this substantially compared to a single region, but it is still I/O and it still belongs off the critical path of a request.
An outage is your outage unless you handle it. The SDK returns defaults when it cannot reach the service, which means every code default in your application becomes live simultaneously. Teams who never tested that path discover that their defaults are a mixture of “off”, “on”, and “whatever was convenient when the flag was written.”
Rules stay on the server. Nothing about your targeting logic reaches the client, which is the correct posture for a browser or a mobile app.
Context leaves your infrastructure. The user attributes you target on are sent to the vendor. Depending on what you target on and where the vendor processes it, that is either a non-event or a compliance conversation.
Change propagation is immediate by definition, since there is no cached rule set to invalidate.
Which one you want
Server-side, local evaluation, almost always. The latency and availability properties are strictly better and the data exposure concern does not apply inside your own process.
Client-side, remote evaluation, with the result cached for the session and a bootstrapped initial value rendered by your server so the first paint does not flicker between variants.
Serverless is the hard case. A function that starts cold cannot afford to download a rule set, and one that stays warm can. The workable patterns are a sidecar or relay process that holds the rules and answers locally over loopback, a shared cache the function reads, or accepting remote evaluation and keeping flag checks out of latency-sensitive paths. Ask any vendor specifically about this, because the generic SDK documentation rarely addresses it.
Needs first-hand data: Measure flag evaluation at the p99, not the mean, from inside your own application with your real flag count and rule complexity, in both modes, including the cold start case. Then measure what happens to request latency when you make the flag endpoint unreachable with your configured timeout. Publish both numbers; they are the two that determine whether a flag check is safe in a hot path.
Targeting rules get complicated faster than you expect
Targeting starts simple and compounds. The progression is consistent across every team I have watched go through it.
Stage one: on or off. A boolean per environment. Nothing to learn.
Stage two: percentage rollout. Ten percent of users get the new path. The mechanic underneath matters: the SDK hashes a stable identifier together with the flag key and maps it into a bucket. Two properties follow. The assignment is sticky, because the same input hashes the same way every time. And two different flags at ten percent do not select the same ten percent, because the flag key is in the hash. That second property is usually what you want and occasionally exactly what you do not, which is why mutual exclusion and shared bucketing keys exist.
Stage three: attribute targeting. Users on the enterprise plan, users in a specific region, users in the beta list. Now the evaluation context needs to carry those attributes at every call site, and a flag check that does not pass plan silently falls through to the default rule. This is a common and confusing bug: the flag works in one part of the application and not another because the context differs.
Stage four: segments and rule ordering. Named reusable groups, rules evaluated top to bottom with first match winning, individual user overrides that bypass everything. At this point the answer to “why did this user get variant B” is not obvious from reading the dashboard, and you need the platform to tell you. A per-user evaluation explanation that names the rule that matched is the single most valuable debugging feature in this category, and not every platform has one.
Stage five: prerequisites and mutual exclusion. Flag A only applies if flag B is on. Experiments that must not overlap because they touch the same surface. This is where a flag system becomes a small rules engine with an execution order that needs documenting, and where the person who set it up becomes a dependency.
Most teams should deliberately stop at stage four. Stage five is real and sometimes necessary, but it is worth reaching on purpose rather than by accretion.
Flag debt is the cost nobody prices in
Every flag is a conditional in your code. A flag that has been at one hundred percent for a year is a conditional that will never take its other branch, plus dead code behind it, plus a test matrix that someone still maintains.
The arithmetic is unforgiving. If a team creates flags steadily and removes them rarely, the flag count grows without bound, and the complexity lands on every engineer who reads those files. Code that is nested three flags deep is code nobody refactors.
What actually works, in order of effectiveness:
Code reference scanning. The platform scans your repositories for flag key occurrences and reports which flags exist in the dashboard but nowhere in code, and which exist in code but were archived. Without this you are guessing. With it, cleanup is a list.
Evaluation telemetry with staleness. The platform records that a flag has returned the same value for every evaluation over a long window, which is the definition of a flag that is done. A flag with no evaluations at all is either dead code or a flag in a service nobody deployed.
Expiry dates at creation. Requiring a removal date when a flag is created, and nagging the owner when it passes, converts cleanup from a quarterly project into an ongoing obligation. It works because the person who created the flag still remembers what it was for.
Temporary versus permanent classification. Some flags are legitimately permanent: kill switches, operational toggles, plan entitlements. Distinguishing those from release flags means the stale flag report is about flags that should have been removed rather than every flag.
Ask any vendor to demonstrate code reference scanning against a real repository during the trial. It is the feature most likely to be described generically in marketing and implemented shallowly in product.
Needs first-hand data: Count your existing flags, then classify each as temporary or permanent and record the creation date of each temporary one. The median age of temporary flags is your real flag debt number, and it is the baseline against which any platform’s cleanup tooling should be judged after six months.
OpenFeature: the standard underneath, not a product
OpenFeature is not one of the platforms below. It is a vendor-neutral specification and set of SDKs that define how application code asks for a flag value, with the actual evaluation delegated to a provider that wraps a specific vendor. There is no dashboard, no targeting UI, no vendor and no bill, so comparing it against LaunchDarkly or Unleash is a category error.
What it changes is the shape of the coupling. Without it, every flag call site in your codebase contains a vendor’s API. With it, call sites use the OpenFeature API and exactly one file configures which provider backs it. Most of the platforms below ship an official provider, and several have made OpenFeature their primary SDK story rather than a compatibility layer.
The related piece worth knowing about is the flag evaluation protocol that lets a provider talk to a local daemon over a standard interface. That is the mechanism behind the sidecar pattern that makes local evaluation workable in serverless and in languages without a mature vendor SDK.
What it gives you
- Call sites stop naming a vendor, so switching platforms becomes a provider swap plus a flag data migration rather than a change to every file that reads a flag
- A consistent evaluation API across languages, which matters in a polyglot estate where each vendor SDK otherwise has its own idioms and its own gotchas
- Hooks for logging, metrics and validation that run on every evaluation regardless of provider, which is where you put the telemetry that tells you a flag is stale
- A neutral place to put a multi-provider setup, for example a local file provider in tests and a hosted provider in production, without branching your application code
What it does not do
- It does not evaluate anything, store anything or show you anything; you still need a platform behind it and that platform is still the thing you pay for
- Provider quality varies significantly, and a thin provider can fail to expose the vendor-specific features you actually bought the vendor for
- The flag data model still differs between vendors, so migrating targeting rules, segments and rollout state remains real work that the standard does not touch
- Adopting it adds an abstraction layer with its own versions and its own bugs, which is a cost worth paying for portability and not worth paying if you have one vendor and no intention of changing
LaunchDarkly

LaunchDarkly is the reference implementation of this category and most of the vocabulary comes from it. Server SDKs stream the full rule set and evaluate locally, client SDKs evaluate remotely against an edge network, and the targeting engine handles segments, prerequisites and experimentation in one model. It is the most complete product here and it is priced accordingly.
Pros
- Streaming rule updates with local server-side evaluation, so flag changes propagate quickly while evaluation stays a local function call
- Per-user evaluation explanations that name the specific rule that matched, which is the difference between debugging targeting in minutes and in hours
- Code reference scanning integrated with CI, so stale flags become a report rather than an archaeology project
- Depth in the awkward parts: prerequisites, mutual exclusion, experiment assignment and audit trails are all first-class rather than bolted on
Cons
- Priced on monthly active contexts, which means the bill tracks your user growth rather than your flag usage and can rise sharply without any change in how you use the product
- Feature depth means configuration surface, and a team using it casually will find the targeting model heavier than their needs
- Relay proxy or edge deployment for serverless and restricted-egress environments is an additional component to run and reason about
Best for: Organisations with multiple teams releasing independently, where targeting complexity and audit requirements are real and the per-user meter is affordable.
Pricing: Subscription tiered by seat with usage metered on monthly active contexts, the distinct user or device identifiers evaluated in a billing period. Experimentation and enterprise governance features sit in higher tiers.
Unleash

Unleash is the strongest open source option and the one most credible as a self-hosted production system. Its architecture is explicitly local evaluation: SDKs fetch the rule set and compute results in process, and there is an edge proxy for client-side SDKs so browser code never receives the rules. Activation strategies are extensible, so custom targeting logic is code you write rather than a feature request.
Pros
- Genuinely self-hostable with the same architecture as the hosted version, so the open source path is not a crippled preview of the paid one
- Local evaluation across server SDKs by design, with an edge component that keeps client-side evaluation remote without a round trip to the core service
- Custom activation strategies let you implement targeting the vendor never imagined, which is the escape hatch other platforms lack
- Flag lifecycle and staleness reporting are built into the model rather than treated as a reporting afterthought
Cons
- Self-hosting means you own the availability of the thing that controls your kill switches, and a flag service outage during an incident is the worst possible time to be debugging your own infrastructure
- Experimentation and analytics are thinner than in platforms built around measurement, so you will pair it with something else for that
- The most useful governance and enterprise features sit behind the commercial tiers, so the open source version alone is a smaller product than the comparison suggests
Best for: Teams with a platform function who want flags running inside their own infrastructure with no per-user meter and are prepared to operate it.
Pricing: Open source core free to self-host with no per-user meter. Commercial tiers are subscription based, priced by seat and environment rather than by monthly active users.
Flagsmith

Flagsmith is an open source platform with a hosted option, positioned close to Unleash but with a different emphasis: remote evaluation is the default and local evaluation is available server-side, and it treats environment-scoped remote configuration as a first-class use case alongside boolean flags. It also offers edge-served evaluation for latency, and self-hosting is a supported path rather than a technicality.
Pros
- Remote configuration values, not just booleans, so it doubles as a runtime config service and removes a category of deploy-to-change-a-value work
- Edge-served remote evaluation reduces the latency penalty of remote mode without shipping rules to clients
- Self-hosting is a maintained, documented path with the same core as the hosted product
- Straightforward data model that a team can understand without a training session, which lowers the barrier to everyone using flags rather than one team
Cons
- Remote evaluation as the default means the availability and latency of the evaluation path is on your critical path unless you deliberately configure otherwise
- Experimentation capability is limited compared to platforms designed around measurement, so statistical rigour will come from elsewhere
- Smaller ecosystem than the market leader, which shows up in SDK maturity for less common languages
Best for: Teams that want flags and runtime configuration in one self-hostable product without adopting a heavy targeting model.
Pricing: Open source and free to self-host. The hosted service is subscription based with usage metered on API requests and environments rather than on active users.
PostHog

PostHog bundles feature flags with product analytics, session replay and experimentation in one platform, and the integration is the point. A flag rollout and the metrics measuring its effect share the same event stream and the same user identity, which removes the join that is otherwise the hardest part of running an experiment. Flags evaluate remotely by default with a local evaluation mode available server-side.
Pros
- Flags, events, experiments and session replay share one identity model, so measuring the effect of a rollout does not require stitching two systems together
- Experiment analysis is built in with the statistics handled, which is a meaningfully different product from a flag tool that reports variant counts
- Self-hostable and open source, with the same feature set rather than a reduced one
- Because analytics is the core product, the cohort and property targeting available to flags is richer than most flag-first tools offer
Cons
- Flags are one module in a large platform, so the depth of targeting governance, approval workflows and audit trails is below what dedicated flag platforms provide
- Pricing is metered across several product surfaces at once, which makes it harder to reason about the marginal cost of adding flags to more services
- Adopting it for flags alone means running a large analytics platform for a small part of its function
Best for: Product teams that want rollouts and their measurement in one place, particularly where experimentation matters more than release governance.
Pricing: Usage-based metering per product area, with feature flag requests metered separately from analytics events and session recordings. Generous entry tier, with cost scaling on evaluation volume rather than user count.
GrowthBook

GrowthBook is built around experimentation and the statistics that make it trustworthy, with feature flags as the delivery mechanism. Its distinguishing architectural choice is that it does not ingest your event data: it connects to your existing warehouse and runs the analysis queries there, so experiment results are computed against data you already have.
Pros
- Warehouse-native analysis means experiment results come from your own data model rather than a vendor’s event schema, which removes an entire class of metric definition disputes
- Statistical engine supports both frequentist and Bayesian analysis with sequential testing, which is a real difference from tools that report a naive p-value
- Open source and self-hostable, with the SDK evaluating locally from a cached rule payload
- No event ingestion means no per-event bill and no data residency question about behavioural data leaving your infrastructure
Cons
- Requires a warehouse with clean, modelled event data already in it; without that, the core value proposition does not function
- Feature flag governance, approvals and audit capability are lighter than dedicated flag platforms, reflecting where the product’s attention is
- Analysis runs on your warehouse, so query cost and freshness are your problem and a heavy experiment programme is a real workload
Best for: Teams with an existing data warehouse and a genuine experimentation practice who want statistical rigour without shipping their event data to another vendor.
Pricing: Open source and free to self-host. Cloud tiers are subscription based by seat, with the warehouse compute for analysis billed by your own data platform.
Split
Split is built around the measurement side of flag rollouts, specifically attributing metric movements to individual feature releases. It records every evaluation as an impression, joins those impressions to your metric events, and computes whether the exposed group differs from the unexposed one. Flags are the mechanism; release impact measurement is the product.
Pros
- Automatic attribution of metric changes to specific releases, which answers the question teams actually have after a rollout rather than just reporting variant counts
- Statistically defensible experiment analysis rather than raw percentage differences, with guardrail metrics that flag unintended regressions
- Local server-side evaluation with a streaming rule set, so the measurement layer does not come at the cost of evaluation latency
- Impression-level data makes it possible to reconstruct exactly which user saw which variant when, which is valuable during an incident review
Cons
- The measurement machinery requires you to define and wire up metrics properly, and a team that skips that work gets an expensive flag toggle
- Impression volume is a cost dimension, so high-traffic flag evaluation in hot paths has a direct billing consequence
- The product assumes a release measurement practice; teams that just want kill switches will find most of it unused
Best for: Product engineering organisations that want every release measured by default and will invest in defining the metrics that makes that meaningful.
Pricing: Subscription with usage metered on tracked keys and impression volume, so both audience size and evaluation frequency move the bill.
ConfigCat

ConfigCat deliberately does less. It is a flag service with a clear targeting model, SDKs across a wide language range, and a pricing model based on configuration size rather than user count. The design philosophy is that most teams need reliable flags with simple targeting and should not pay a per-user meter for it.
Pros
- Pricing on flags and configurations rather than monthly active users, which decouples cost from audience growth entirely
- Wide SDK language coverage including languages the larger vendors treat as second class
- Simple enough that a small team can adopt it without anyone becoming the flag system expert
- Polling-based rule fetch with local evaluation keeps the evaluation path local and the failure mode predictable
Cons
- Targeting model is deliberately limited, so prerequisite flags, mutual exclusion and complex segment logic are either awkward or absent
- No experimentation or measurement layer, so answering whether a rollout helped requires a separate tool and a manual join
- Change propagation is polling-based by default, so there is a configurable delay between flipping a flag and every client seeing it
Best for: Teams that want dependable flags and kill switches with predictable cost, and have no intention of building an experimentation practice on top.
Pricing: Subscription tiered on the number of flags, environments and products, with no per-user or per-evaluation meter.
How to choose
Decide the evaluation mode per surface first. Server-side local, client-side remote with a server-rendered bootstrap, and a deliberate answer for serverless. Then eliminate any vendor whose SDK cannot do that in your languages. This removes more options than any feature comparison will.
Test the outage path before you test the features. Block the vendor’s endpoints and run your test suite. Every flag will return its code default. If the resulting application state surprises you, fix your defaults before choosing a vendor, because that behaviour is identical across all of them.
Separate flags from experiments in your requirements. They are different products that happen to share a mechanism. A kill switch needs reliability and speed. An experiment needs correct statistics and a clean metric join. Buying one when you need the other is the most common expensive mistake in this category.
Price the meter against your growth curve, not your current size. A per-active-user meter grows with success. A per-flag or per-seat meter does not. If you expect user count to grow much faster than headcount, that difference compounds. The LaunchDarkly alternatives comparison works through that arithmetic in detail.
Demand the cleanup story. Ask to see code reference scanning working against your repository during the trial, and ask what the stale flag report looks like after a year. A platform without a credible answer here is selling you a mechanism for accumulating complexity.
| Platform | Default evaluation | Experimentation | Self-hostable | Meter shape |
|---|---|---|---|---|
| LaunchDarkly | Local server, remote client | Full | No | Monthly active contexts |
| Unleash | Local, edge for clients | Light | Yes | Seats and environments |
| Flagsmith | Remote, local optional | Light | Yes | API requests |
| PostHog | Remote, local optional | Full | Yes | Evaluation volume |
| GrowthBook | Local from cached payload | Full, warehouse-native | Yes | Seats |
| Split | Local server | Full | No | Tracked keys and impressions |
| ConfigCat | Local from polled config | None | No | Flags and environments |
| OpenFeature | (standard, not a product) | n/a | n/a | No vendor, no bill |
The setup I would reach for by default: OpenFeature at the call sites so the vendor is one file, local evaluation on servers, a self-hosted or per-flag-priced platform if flags are mostly operational, and a warehouse-native experimentation tool separately if measurement matters. Feature flags are also one half of a safe release; the other half is the rollout mechanism itself, covered in the deployment orchestration guide, and both sit downstream of whatever runs in the CI/CD platform you already have.
Frequently asked questions
Should flags be evaluated locally or remotely?
Locally on the server, remotely in the browser and on mobile. Local evaluation makes a flag check a function call and keeps working during a vendor outage, but it requires shipping your targeting rules to whatever holds them, which is unacceptable in a client you do not control. Remote evaluation keeps the rules private at the cost of a network round trip. Serverless is the genuinely hard case and usually needs a relay or sidecar holding the rules locally.
What happens to my application if the flag vendor goes down?
With local server-side evaluation, nothing immediate: the SDK has the rules cached and keeps evaluating. You lose the ability to change flags, which matters during an incident. With remote evaluation, every flag call falls back to the default value you passed at the call site, all at once. Test that state deliberately, because a codebase where defaults were chosen carelessly can enter a configuration no one has ever seen.
How many feature flags is too many?
The count matters less than the age distribution. A hundred flags where the temporary ones are days old is healthy. Thirty flags where the oldest temporary ones are years old is not, because each is a permanent conditional in a code path somebody still has to reason about. Classify flags as temporary or permanent at creation, require a removal date on temporary ones, and measure the median age of the temporary set.
Do I need OpenFeature if I only use one vendor?
Not strictly, and adopting it adds a layer. The argument for doing it anyway is that the cost is highest after you have hundreds of call sites, so the cheapest time to adopt it is before you need it. The hooks are also genuinely useful independent of portability: one place to log every evaluation, validate context completeness, and emit the telemetry that tells you which flags are stale.
Can feature flags replace canary deployments?
They complement each other and solve different halves of the problem. A flag controls which users get which behaviour inside a deployed binary, so rollback is instant and does not involve shipping anything. A canary controls how much traffic reaches a new binary, which is the only thing that helps when the problem is in a dependency upgrade, a runtime change or a memory leak rather than in flagged code. Teams that run both use the canary for the deployment and the flag for the feature.
Related reading
- LaunchDarkly alternatives — the per-active-user meter and the exits from it, including honest self-hosting costs.
- Best deployment and release orchestration tools — progressive delivery at the traffic layer rather than the code layer.
- Best CI/CD platforms — where the flag SDK gets configured and where code reference scanning runs.
- Best preview environment tools — per-branch environments and how flag state should differ in them.
- Best incident management tools — the kill switch is only useful if the person paged knows it exists.
- Best RUM tools — measuring what a client-side rollout did to real user experience.
- Best APM tools — catching the latency a flag check in a hot path introduces.