Nobody leaves LaunchDarkly because the product is bad. It is the most complete feature flag platform there is, and most of the vocabulary the rest of the category uses came from it.
Teams leave because of the meter. LaunchDarkly bills on monthly active contexts, and a context is any distinct identifier your SDK evaluates a flag against in a billing period. Your user count grows, your bill grows, and the relationship holds whether you added one flag that year or forty. The product got no more expensive to operate and no more valuable to you, and the invoice went up anyway.
That is a legitimate reason to look elsewhere, and it is also a reason to be precise about what you are actually buying and what you would be giving up. The alternatives are not uniformly cheaper. Several of them meter on something else that grows just as fast in your particular shape of business, and the self-hosted ones replace a line item with an operational obligation that has a real cost even though it never appears on an invoice.
So this is two questions, not one. What is driving your bill, and what would you lose by moving.
Key takeaways
- A monthly active context is any distinct identifier evaluated in the period. Multi-context models that key on user, device and organisation separately can count one human more than once.
- Anonymous and unauthenticated traffic is the most common cause of a bill that grew faster than the user base. Check what identifier your client SDK sends when nobody is logged in.
- Alternatives meter on seats, flags, API requests, evaluation volume or impressions. Each of those grows with a different part of your business, so the right choice depends on which of your numbers is growing fastest.
- Self-hosting removes the invoice and adds an availability obligation on the system that controls your kill switches. Price the on-call, not just the compute.
What the monthly active context meter actually counts
The meter is simple to state and surprising in practice. Every distinct context key that an SDK evaluates a flag against, across every environment and every SDK, counts once for the billing period. Four things make that number larger than teams expect.
Multi-context models count each part separately. Modern targeting lets you evaluate against a user, a device, an organisation and a request context in the same call. That is genuinely useful, because targeting a whole account is different from targeting a person. It also means one logged-in human on two devices in one organisation can register several distinct contexts. Teams that migrated to multi-context targeting to improve their rollouts have watched the count rise without any change in traffic.
Anonymous users are contexts too. A browser SDK evaluating flags for a logged-out visitor needs a key, and unless you configure it deliberately it generates one per browser. Every first-time visitor, every private window, every cleared cookie jar is a new context. For a marketing site or a product with a large logged-out surface, anonymous contexts can dominate the count entirely and have nothing to do with your customer base.
Bots and crawlers are indistinguishable from users unless you exclude them before the SDK initialises. Search crawlers, uptime checks, scanners and scrapers all hit client-side code and all get context keys.
Every environment counts. Development, staging, load test and production each evaluate contexts. A load test that simulates a large synthetic user population against a staging environment with real SDK keys is a billing event, and it is the kind of thing that happens once, in a month with a release, and shows up later.
None of this is hidden or dishonest. It is what “active context” means. The point is that the number is decoupled from anything you would intuitively call usage, which is exactly why it is uncomfortable to forecast.
Before you migrate anywhere, work out which of the four is driving your number. If it is anonymous contexts, the cheapest fix may be a stable shared key for logged-out traffic and a filter for bots, not a new vendor. If it is genuine authenticated user growth, then the meter is doing what it says and you need a different meter shape.
Needs first-hand data: Pull your context count broken down by environment, by context kind, and by authenticated versus anonymous. Then compare the authenticated production user count against the total. The ratio between those two numbers tells you whether you have a pricing problem or a configuration problem, and they have completely different fixes.
What you lose by leaving, honestly
A flag migration is not a data export. Five things do not move cleanly, and underestimating them is how a two-week migration becomes a quarter.
Targeting rules do not translate one to one. Rule ordering semantics, how a rule that references a missing attribute behaves, whether an individual override bypasses percentage bucketing, how segments compose. Every platform has answers and they differ in detail. A rule set that behaves identically in the new platform requires reading both evaluation models carefully and testing the edge cases, not a script.
Bucketing changes who is in the rollout. Percentage rollouts hash a stable identifier with a salt that includes the flag key, and the hash function and salting scheme are platform-specific. Move a flag at fifty percent to a new platform and a different fifty percent of your users are in the treatment group. For a release flag that is a shrug. For a long-running experiment or a gradual migration where the treatment group has different data, it is a correctness problem. Plan to finish or reset those flags before migrating rather than during.
Prerequisites and mutual exclusion may not exist. Several alternatives do not implement flag prerequisites at all. If your setup depends on them, you are reimplementing that logic in application code or choosing differently.
Experiment history does not come with you. Past results, exposure data and the statistical state of running experiments stay behind. Any experiment in flight has to be concluded before the move.
Code reference scanning and audit trails reset. The stale flag report that made cleanup tractable starts empty. The audit log that told you who changed what and when starts at the migration date, which matters if you are under a compliance regime that expects continuity.
The migration that works is dull: adopt an abstraction at the call sites first, run both platforms in parallel with the new one shadowing, move flags in batches starting with the ones nobody depends on, finish or reset percentage rollouts rather than porting them, and delete the old platform’s SDK only when the flag count there reaches zero. The full mechanics of the evaluation models involved are covered in the feature flag platform guide.
Unleash

Unleash is the most direct architectural replacement. Server SDKs fetch the full rule set and evaluate locally, an edge component serves client-side SDKs without exposing rules, and activation strategies are extensible so targeting the product does not support is code you write. Self-hosting is the primary story rather than a concession.
Pros
- No per-user meter anywhere in the model, so the bill is a function of your team size rather than your audience size
- Local evaluation on servers matches the LaunchDarkly architecture, so the latency and outage characteristics you are used to carry over
- Custom activation strategies give you an escape hatch for targeting logic no vendor implements, which removes a common reason to stay on a heavier platform
- Self-hosted deployment is the same software as the commercial one, so the open source path is a real production option rather than an evaluation build
Cons
- Prerequisite flags and the more elaborate composition features are thinner than what you are leaving, so complex flag graphs need rework
- Self-hosting puts the availability of your kill switch infrastructure on your own on-call rotation, which is felt most at exactly the wrong moment
- Experimentation and measurement are light, so if you were using LaunchDarkly experiments you need a second tool
Best for: Teams with platform engineering capacity who want the same evaluation architecture without a meter tied to user growth.
Pricing: Open source core free to self-host with no usage meter. Commercial tiers are subscription based on seats and environments rather than active users.
Flagsmith

Flagsmith is open source with a hosted option and a deliberately smaller conceptual model. Flags carry values as well as booleans, so it doubles as a remote configuration service. Remote evaluation is the default with edge serving to keep latency reasonable, and local server-side evaluation is available where you want it.
Pros
- Remote configuration values alongside flags removes a whole class of redeploy-to-change-a-constant work that a boolean-only platform leaves in place
- Metered on API requests rather than users, which is a dial you control through caching and evaluation strategy rather than one your growth controls
- Self-hosting supported and documented, with the hosted service as an option rather than the only real path
- Simple enough data model that the migration reasoning is tractable, which matters when you are translating rule semantics by hand
Cons
- Remote evaluation by default means the evaluation endpoint is on your request path unless you deliberately switch server SDKs to local mode
- Targeting is simpler than what you are leaving, so segment-heavy configurations need flattening
- API request metering punishes chatty clients, so a naive migration that evaluates per flag rather than per context can produce a surprising bill
Best for: Teams who want flags plus runtime configuration in one place and prefer a request-based meter to a user-based one.
Pricing: Open source and free to self-host. Hosted tiers are subscription based with usage metered on API requests and environment count.
PostHog

PostHog is the alternative that changes what you are buying rather than just where you buy it. Flags sit inside a product analytics platform, sharing identity and events with analytics, experiments and session replay. If you were paying LaunchDarkly for flags and something else for analytics, consolidating can be a net reduction even before the meter shape changes.
Pros
- Flags, events and experiments share one identity model, so measuring a rollout is a query rather than an integration project
- Metering on evaluation requests rather than distinct users means anonymous traffic costs what it costs to serve rather than counting as customers
- Self-hostable and open source, so the option of taking it in-house exists if the hosted meter stops making sense
- Cohort targeting benefits from the analytics data already present, giving richer segments than a flag-only tool can build
Cons
- Governance features that enterprise LaunchDarkly users depend on, approval workflows, granular permissions and detailed audit trails, are shallower here
- Consolidating onto one vendor for flags, analytics and replay concentrates risk, and the meter now covers several surfaces that can each grow independently
- Running a full analytics platform to serve flags alone is a poor trade if you already have analytics elsewhere
Best for: Product teams that also want analytics and experimentation, where replacing two subscriptions with one is part of the case.
Pricing: Usage-based per product area, with feature flag evaluation requests metered separately from analytics events and recordings.
GrowthBook

GrowthBook is the right answer if what you actually valued in LaunchDarkly was experimentation. It runs analysis against your existing data warehouse rather than ingesting events, so experiment results are computed from your own modelled data, and flags are the delivery mechanism for the variants.
Pros
- Warehouse-native analysis means no event ingestion meter and no argument about whose definition of a metric is correct
- Statistical engine covers both Bayesian and frequentist approaches with sequential testing, which is stronger than a flag platform’s bolted-on experiment reporting
- SDKs evaluate locally from a cached payload, so the evaluation path has the latency and outage properties you want
- Open source and self-hostable, priced by seat, which decouples cost from both audience and traffic
Cons
- Requires a warehouse with clean modelled event data, and without one the central value proposition does not work at all
- Flag governance, approvals and permissions are lighter than what an enterprise LaunchDarkly configuration relies on
- Analysis compute lands on your warehouse bill, so the cost moves rather than disappearing, and a busy experiment programme is a real query workload
Best for: Teams with a working warehouse and a genuine experimentation practice who want the statistics to be defensible and the flags to be a side effect.
Pricing: Open source and free to self-host. Cloud tiers priced per seat, with analysis compute billed by your own data warehouse provider.
ConfigCat

ConfigCat is the alternative for teams who concluded they were paying for depth they never used. It provides flags with a clear targeting model, broad SDK coverage, and a price based on how many flags and environments you have rather than how many people use your product.
Pros
- Priced on configuration size, so audience growth has literally no effect on the bill, which is the cleanest possible answer to the meter problem
- Broad SDK language coverage, including languages the larger vendors support thinly
- Local evaluation from a polled configuration, so evaluation is in-process and a vendor outage does not stop flags resolving
- Small enough conceptually that nobody needs to become the flag platform expert, which removes an ongoing cost that is easy to forget
Cons
- Targeting is deliberately limited, so prerequisites, mutual exclusion and complex segment composition are not available and migrating those means reimplementing them
- Polling means a configurable delay between flipping a kill switch and every client honouring it, which is a real consideration during an incident
- No experimentation or measurement, so a rollout tells you nothing about its effect without separate tooling
Best for: Teams using flags mainly as release toggles and kill switches who want cost that is completely independent of user growth.
Pricing: Subscription tiered on the number of flags, environments and products, with no per-user or per-evaluation component.
Split
Split is not a cheaper LaunchDarkly, it is a different bet. Its centre of gravity is attributing metric movement to individual releases: every evaluation is recorded as an impression, impressions are joined to your metric events, and the platform reports whether exposed users behaved differently from unexposed ones.
Pros
- Release impact measurement is automatic rather than something you assemble, which answers the question teams ask after every rollout
- Guardrail metrics catch regressions in things you were not looking at, which is the failure mode a manual dashboard check misses
- Local server-side evaluation with streaming updates, so the measurement layer does not cost you evaluation latency
- Impression-level records let you reconstruct exactly which user saw which variant during an incident review
Cons
- Metered partly on impressions, so a flag evaluated in a hot path has a direct billing consequence and evaluation frequency becomes an architectural concern
- Requires real work defining metrics before the product does anything the cheaper alternatives do not, and teams that skip it have bought an expensive toggle
- Not obviously cheaper than what you are leaving, so it is a choice about capability rather than about cost
Best for: Organisations moving for capability rather than price, who want every release measured by default and will define the metrics to make that work.
Pricing: Subscription with usage metered on tracked keys and impression volume, so both audience size and evaluation frequency move the bill.
The honest cost of self-hosting
Three of these can run in your own infrastructure with no licence cost, and the resulting invoice really is close to zero. The total cost is not, and pretending otherwise is how teams end up migrating twice.
The compute is genuinely cheap. A flag service is a small application in front of a database serving a rule set. The instance and database costs are not what makes this decision hard.
Availability is the real cost. The flag service controls your kill switches. It is most needed during an incident, which is precisely when your infrastructure is already having a bad day. Running it means a highly available deployment across zones, a database with a tested restore procedure, and monitoring that pages someone. If it shares a failure domain with the system it is supposed to protect, it will be down when you reach for it. That is an architectural requirement, not a preference.
Upgrades are recurring work. New versions, security patches, schema migrations, SDK compatibility windows. Not difficult, never zero, and always arriving when something else is on fire.
Someone has to own it. Not full time, but named. An unowned internal service becomes an unpatched internal service, and the person who set it up leaves eventually. Budget this the way you would budget any internal platform component. The same reasoning applies to self-hosted build infrastructure, and the self-hosted CI/CD guide covers the same tradeoff in a domain where the failure is more visible.
The mitigating factor is that local evaluation makes outages survivable. If your server SDKs hold the rule set in memory, the flag service being down means you cannot change flags, not that your application breaks. That is a meaningfully softer failure than a remote evaluation architecture would have, and it is the strongest argument for self-hosting a platform whose SDKs evaluate locally.
The honest summary: self-hosting is a good decision if you already run stateful internal services and have an on-call rotation that could absorb one more. It is a bad decision if this would be the first internal service your team operates, because the operational learning curve costs more than the subscription you avoided.
Needs first-hand data: If you self-host, run a game day where you take the flag service offline during business hours and have someone attempt a kill switch flip. Record how long it took to notice, what the SDKs did, and whether anyone could change a flag by another route. That exercise is the actual test of whether the saving was real.
How to choose
Diagnose the meter before shopping. Break your context count into authenticated, anonymous, non-production and bot traffic. If anonymous or non-production traffic dominates, fix that first. A migration that solves a configuration problem is a lot of work for a result you could have had with an SDK config change.
Match the new meter to your slowest-growing number. Seats grow slowly. Flags grow slowly. Active users grow with success. Evaluation volume grows with traffic. API requests grow with how chatty your clients are, which you control. Pick the meter attached to the number that is growing least in your business, not the one with the lowest headline price.
Count what you actually use. Open your current setup and list the flags using prerequisites, mutual exclusion, complex segments or experiments. If that list is short, most of what you are paying for is unused and the simpler alternatives are genuinely equivalent. If it is long, the cheap options will cost you in application code instead.
Decide about experimentation separately. Flags and experiments are different products sharing a mechanism. If you need both, two specialised tools frequently beat one platform, and the flag half is then commodity.
Adopt an abstraction at the call sites before you migrate anything. Doing this first makes the actual switch a configuration change and makes the next switch cheap. It is the single highest-return preparatory step.
| Alternative | Meter shape | Self-hostable | Experimentation | Closest match to what you are leaving |
|---|---|---|---|---|
| Unleash | Seats and environments | Yes | Light | Architecture and evaluation model |
| Flagsmith | API requests | Yes | Light | Flags plus remote config |
| PostHog | Evaluation requests | Yes | Full | Flags plus analytics in one |
| GrowthBook | Seats | Yes | Full, warehouse-native | Experimentation depth |
| ConfigCat | Flags and environments | No | None | Release toggles only |
| Split | Tracked keys and impressions | No | Full | Release measurement |
If your flags are mostly operational toggles and kill switches, ConfigCat or self-hosted Unleash will do everything you need and the meter problem disappears. If you were genuinely using the experimentation, GrowthBook with your own warehouse is the substantive replacement. If you were paying for two subscriptions and one of them was analytics, PostHog is worth modelling properly. And the rollout mechanism itself, the part that shifts traffic rather than code paths, is a separate decision covered in the deployment orchestration guide, running on whatever CI/CD platform you already have.
Frequently asked questions
Why did my LaunchDarkly bill increase when my user count did not?
Most often anonymous contexts or a change in context modelling. A client SDK generates a key per browser for logged-out visitors, so traffic from crawlers, private windows and cleared cookies counts. Adopting multi-context targeting can also register one human as several contexts across user, device and organisation kinds. Non-production environments running load tests with real SDK keys are the third common cause. Break the count down by environment and context kind before concluding the problem is pricing.
Is self-hosting actually cheaper?
The invoice is, the total is only sometimes. Compute for a flag service is small. The real costs are running it highly available across zones so it survives the incident it exists to help with, keeping it patched, and having a named owner. If you already operate internal stateful services, the marginal cost is modest and self-hosting wins. If this would be your first, the operational learning is worth more than the subscription.
Will my percentage rollouts stay the same after migrating?
No. Bucketing hashes a user identifier with a salt derived from the flag key, and each platform does that differently, so a flag at fifty percent will select a different fifty percent after the move. For release flags that is harmless. For anything where the treatment group has accumulated different state, finish the rollout or reset it deliberately before migrating instead of trying to preserve the assignment.
Which alternative is closest to a drop-in replacement?
Unleash architecturally, because server SDKs evaluate locally from a streamed rule set the same way and the edge component covers client-side SDKs without exposing rules. The gaps are prerequisite flags and composition depth, plus experimentation. Nothing is a true drop-in, because the targeting semantics differ everywhere and those differences are where migration time actually goes.
Do I need to migrate at all, or can I just reduce what I use?
Frequently the latter. Excluding bots, using a stable shared context for logged-out traffic, separating non-production SDK keys, and archiving flags nobody evaluates all reduce the count without a migration. Do that work first regardless, because it makes any eventual migration smaller and it gives you an accurate picture of what you are actually paying for.
Related reading
- Best feature flag platforms — the full category with evaluation mechanics and targeting models in depth.
- Best deployment and release orchestration tools — shifting traffic rather than toggling code paths.
- Best CI/CD platforms — where flag configuration and code reference scanning fit into a pipeline.
- Best self-hosted CI/CD tools — the same self-hosting arithmetic applied to build infrastructure.
- Best incident management tools — a kill switch nobody can find during an incident is not a kill switch.
- Best APM tools — detecting the latency a remote evaluation path adds to a request.