Feature management is a genuinely good purchase at this size. Decoupling deploy from release is what lets forty teams ship into one production estate without a release train, and the kill switch on a bad rollout is worth its licence the first time you use it in anger. None of that is in dispute here.
The condition is that LaunchDarkly's published meters have nothing to do with how many engineers you have. Foundation is priced at $10 per service connection per month — one server-side SDK connected to one environment, for a month — and $8.33 per 1,000 client-side monthly active users, with the first five connections included. Neither number appears on your org chart. Both are decided by how many services you run, how many environments you run them in, and how many people or devices use your product.
There is a second condition, and it is the one that ends most evaluations at this size: the governance a 500-person org wants is not on a published price. Custom roles and teams, approvals, scheduled flag changes and release automation are Enterprise features, and LaunchDarkly publishes no Enterprise price at all. So plan on a quote-only negotiation for the tier you will actually end up wanting, and get that number before you migrate a flag estate onto the platform rather than after.
The money, named
What you pay. LaunchDarkly publishes a free Developer tier (unlimited seats, unlimited flags, 5 service connections, 1,000 client-side MAU a month, 5,000 session replays, 5,000 errors, 10 million logs and 10 million traces a month, and 100,000 experimentation MAU) and a pay-as-you-go Foundation tier with no platform fee and no seat fee: billed yearly, $10 per service connection per month and $8.33 per 1,000 client-side MAU per month, with the first five service connections included, 5,000 AI runs a month included and $5 per additional 1,000 AI runs. Enterprise is custom-priced and is therefore absent from every figure below.
LaunchDarkly's own definitions are the important part: a service connection is *one server-side SDK connected to one environment for a month* — so the meter is services × environments, not services — and *each unique client-side user or device counts as one MAU*. Serverless and short-lived processes, LaunchDarkly states, bill fractionally by connection time.
| Estate | Connections (services × envs) | Billable after 5 included | Per year at $10 / connection / mo |
|---|---|---|---|
| 20 services × 3 environments | 60 | 55 | $6,600 |
| 40 services × 4 environments | 160 | 155 | $18,600 |
| 80 services × 4 environments | 320 | 315 | $37,800 |
| 150 services × 4 environments | 600 | 595 | $71,400 |
Read the second column before the fourth. The multiplier is environments, and it is the single most expensive architectural decision on this page. Adding one more environment — a staging tier, a per-region production split, a dedicated load-test estate — across 80 services adds 80 connections, which is $9,600 a year at the published rate. That is a platform-team decision made in a design doc, with a five-figure annual price tag nobody attaches to it at the time.
The client-side meter is the one that can dwarf everything. At $8.33 per 1,000 MAU a month:
| Client-side MAU / month | Per month | Per year |
|---|---|---|
| 100,000 | $833 | $9,996 |
| 500,000 | $4,165 | $49,980 |
| 2,000,000 | $16,660 | $199,920 |
| 5,000,000 | $41,650 | $499,800 |
This is the fork in the road for a B2B SaaS company, and it is good news. If your product has tens of thousands of business users rather than millions of consumers, the MAU meter is a small line and the connection meter is your bill — very manageable, and controllable by counting environments. If you are B2C or freemium-at-scale, client-side MAU is potentially the largest single line in your entire tooling estate, larger than observability, and the correct move is to flag on the server side wherever you can rather than to negotiate a per-MAU discount.
What it has to beat. Take the mid case — 40 services across 4 environments, plus 100,000 client-side MAU:
155 billable connections x $10 x 12 = $18,600 / year
100,000 client-side MAU: 100 units x $8.33 x 12 = $9,996 / year
total = $28,596 / year
$28,596 / $90 per hour ( = $180,000 / 2,000) = 318 engineer-hours / year
One prevented full rollback of a bad release (est. 6 hrs x 20 people) = 120 hoursThree averted bad rollouts a year clears it, on that arithmetic — and an org shipping several times a day across forty teams has more than three. The bar is not the problem. The problem is that the bill is set by architecture decisions taken elsewhere, so it moves without anybody deciding to spend more.
The reason, at this size
1. Unlimited seats is a real gift, and it changes the failure mode.
LaunchDarkly states plainly that there is no per-seat pricing and that pricing is based on usage. In a stack where nearly every other line is billed per person, that is a genuine advantage: every engineer, PM and support lead can hold flags without a licence conversation, and adoption is never rationed by procurement.
But it moves the failure mode rather than removing it. When seats are free and connections are metered, the thing that grows unchecked is infrastructure, and nobody's performance review mentions the connection count. Which is precisely why the control below is an inventory, not a permissions policy.
2. Kubernetes and serverless are explicitly outside the standard rate card.
This is published, and it should change how you evaluate: LaunchDarkly states that Kubernetes, serverless, Python and Ruby architectures *"create a high volume of server-side connections"*, that *"standard per-connection pricing isn't a fair fit"*, and that it will tailor a package to your environment. It also says serverless and short-lived processes bill fractionally by connection time.
Take that at face value — it is a fair thing for a vendor to say — but understand what it means for your evaluation: if you run Kubernetes at scale, the numbers in the table above are not your numbers, and there is no published rate that is. You cannot self-serve an accurate estimate. Ask for the tailored package in writing, ask exactly how a connection is counted for your runtime, and ask what happens to the count when you scale replicas during a traffic spike, before you commit a flag estate to the platform.
3. Environments multiply, and nobody prices them at design time.
Because a connection is one SDK to one environment, your bill is services × environments. A platform team consolidating three staging environments into one is worth $9,600 a year at 80 services on the published rate. A team adding a per-region production split for latency reasons costs the same amount in the other direction — which may well be the right call, but it should be a known cost rather than a surprise on the next invoice.
The fix is not a moratorium on environments. It is putting the connection count on the same page as the design decision, once, so the trade is explicit.
4. Everything you will want for governance is quote-only.
LaunchDarkly's published Enterprise tier — advanced user targeting, custom roles and teams, workflows, scheduling and approvals, release automation — has custom pricing, i.e. no public number. At 100–1,000 engineers those are exactly the features you end up needing: you cannot let forty teams change production flags with no approval path and no role separation for long.
So plan the negotiation before the migration, not after. A flag estate is sticky in the same way an issue tracker is: once thousands of flags are evaluated in production code, your negotiating position at renewal is materially worse than it was on the day you signed. Ask for Enterprise pricing at your current connection count and at next year's, and ask for the year-two uplift in writing, while you are still a prospect.
5. The cheapest flag is the one you delete.
Stale flags do not cost you anything directly on this rate card — the meter is connections and MAU, not flags — but they are the reason the platform's value decays. A codebase with 4,000 flags, most of them permanently true, is a codebase where nobody trusts the flag list, where the approval process gets bypassed because it is noise, and where the audit trail proves nothing.
Which is worth saying on a page about money because it is the real risk to this purchase: not that LaunchDarkly is expensive, but that in eighteen months you are paying $28,596 a year for a system nobody prunes. Flag hygiene — an owner and an expiry date on every temporary flag, a monthly sweep — is what keeps the thing you bought worth what you paid.
What to do instead of just buying it
Four controls. The first one is an inventory and it is the only way to know what this actually costs you.
1. Count services × environments before you sign anything.
That product, minus the five included connections, times $10 a month, is your Foundation floor on the published rate. Do it per environment so you can see what each one costs: at 80 services an environment is $9,600 a year. If you run Kubernetes or serverless at scale, stop and get the tailored package quoted instead — LaunchDarkly says the standard rate card does not fit that shape, and it is right.
2. Count client-side MAU honestly, including devices.
LaunchDarkly counts each unique client-side user or device. For a B2C or multi-device product that number is often several times the user count you quote internally. At $8.33 per 1,000 a month, being wrong by a factor of three at 500,000 MAU is $100,000 a year. Where a flag decision can be made server-side, make it server-side.
3. Get Enterprise quoted while you are still a prospect.
Approvals, custom roles and release automation are the features you will need within a year and they have no published price. Ask for the quote at this year's and next year's connection counts, with the renewal uplift in the same document, before the flag estate makes leaving expensive.
4. Give every temporary flag an owner and an expiry date.
A monthly sweep that deletes finished flags is what keeps the platform trustworthy, and a trustworthy flag list is the entire reason you bought it. This costs nothing and is the difference between a control plane and a graveyard.
What would change our mind
- You ship once a fortnight behind a release train. Then decoupling deploy from release is solving a problem you do not have yet, and a much cheaper flag library plus a config store will hold for another year.
- Your client-side MAU is in the millions. Then the published per-MAU rate is likely the largest line in your tooling estate and this becomes an architecture decision — server-side evaluation, fewer client-side flags — before it becomes a procurement one.
- You run Kubernetes or serverless at scale. LaunchDarkly says the standard per-connection rate card does not fit that shape and offers a tailored package. There is no published price for it, so nothing on this page can tell you your number — only that you must get it in writing before you commit.
- You already run a mature in-house flag system with an approval path. The migration cost is real and the marginal gain is governance you may already have; that comparison is specific to you and we will not guess at it.
- LaunchDarkly publishes an Enterprise price. The moment the governance tier has a list price, the "negotiate before you migrate" argument weakens considerably and this page needs rewriting.
What we checked
Every figure above came from a page we opened, so you can check our work before you forward this to finance.
- LaunchDarkly — Pricing — Developer $0 a month (unlimited seats, unlimited feature flags, 5 service connections, 1,000 client-side MAU a month, 5,000 session replays, 5,000 errors, 10M logs and 10M traces a month, 100,000 experimentation MAU); Foundation billed yearly with no platform or seat fees at $10 per service connection per month and $8.33 per 1,000 client-side MAU per month, first 5 service connections included, 5,000 AI runs a month included and $5 per additional 1,000 runs, 30-day AgentControl retention; Enterprise custom pricing (advanced user targeting, custom roles and teams, workflows/scheduling/approvals, release automation). Definitions quoted: a service connection is "one server-side SDK connected to one environment for a month", serverless and short-lived processes "bill fractionally by connection time", and "each unique client-side user or device counts as one MAU". LaunchDarkly's own note on Kubernetes, serverless, Python and Ruby: those architectures "create a high volume of server-side connections", "standard per-connection pricing isn't a fair fit", and it will tailor a package. Read 30 August 2026.
Provenance. Every rate, included allowance and unit definition on this page was read from LaunchDarkly's own pricing page on 30 August 2026, including its published statement about Kubernetes, serverless, Python and Ruby architectures. The connection counts, the annual totals at 60/160/320/600 connections, the MAU totals at 100k/500k/2M/5M, the $9,600-per-extra-environment figure and the 318-hour break-even (at a $180,000 fully-loaded cost per engineer and 2,000 hours a year) are our arithmetic on those published numbers, and are labelled as ours in each caption. Enterprise pricing and the tailored high-connection packages are deliberately absent because LaunchDarkly publishes no figure for either. No service count, environment count or MAU figure is assumed for your org — those are inputs you have and we do not, and the rollback example in the break-even is explicitly labelled an estimate rather than a measured saving. No sponsorship, no affiliate link, no vendor review of this page. Last reviewed 30 August 2026. Corrections: [email protected].
LaunchDarkly vs the alternatives
Free to read, no email · adopt, pilot or skip on every tool, with the SSO and data-risk line
- GrowthBook vs LaunchDarkly for flags and experiments→
LaunchDarkly if you want the whole product org watching flags — seats are free. GrowthBook if your warehouse must hold the data.
Questions we get asked about this one
Is LaunchDarkly worth it for a 100–1,000 person engineering team?
Yes, if you have counted what it meters first. LaunchDarkly does not charge per seat: its published Foundation pricing is $10 per service connection per month — one server-side SDK connected to one environment — and $8.33 per 1,000 client-side monthly active users, with the first five connections included. Forty services across four environments is $18,600 a year, and 100,000 client-side MAU adds $9,996. That total is about 318 engineer-hours at a $180,000 fully-loaded cost, which three averted bad rollouts a year clears. The condition is that the bill is set by architecture, not headcount, and the governance features you will want are quote-only.
What does LaunchDarkly cost for 500 engineers?
Headcount is not in LaunchDarkly's pricing formula at all — seats are unlimited. The published Foundation meters are $10 per service connection per month and $8.33 per 1,000 client-side MAU per month, so the answer depends on your service and environment counts and your product's user base. Our arithmetic on those published rates: 60 connections is $6,600 a year, 160 is $18,600, 320 is $37,800 and 600 is $71,400; on the client side, 100,000 MAU is $9,996 a year, 500,000 is $49,980 and 2 million is $199,920.
Why did our LaunchDarkly bill go up when we did not add anyone?
Because the meter is service connections and client-side MAU. A service connection is one server-side SDK connected to one environment for a month, so adding an environment multiplies across every service you run — at 80 services that is 80 more connections, or $9,600 a year at the published rate. Scaling out replicas, splitting production by region, or adding a staging tier all move the number. On the client side, growth in unique users or devices moves it too, at $8.33 per 1,000 MAU a month. LaunchDarkly also notes that serverless and short-lived processes bill fractionally by connection time.
How much is LaunchDarkly Enterprise?
LaunchDarkly publishes no price for Enterprise — the pricing page says "custom pricing" — so we do not quote or estimate one. It matters more here than on most tools, because the features an org of 100–1,000 engineers typically needs (custom roles and teams, approvals, scheduled changes, release automation, advanced targeting) are all on that tier. Get the quote at your current and projected connection counts, with the year-two uplift in writing, before you migrate a flag estate onto the platform — afterwards, your negotiating position is worse.
How do we cut a LaunchDarkly bill without losing feature flags?
Count first, then consolidate. Inventory services × environments and ask which environments genuinely need flag connections — at 80 services each environment is $9,600 a year on the published rate. Move flag evaluations server-side wherever the decision does not need to be made in the client, because client-side MAU is metered at $8.33 per 1,000 and is often the bigger number for consumer products. If you run Kubernetes or serverless at scale, ask for the tailored package LaunchDarkly says it offers for those architectures rather than paying the standard per-connection rate. And delete finished flags monthly: that does not cut the invoice directly, but it is what keeps the thing you are paying for worth having.
Tomorrow morning, five tools you haven’t heard of yet.
This verdict is free and always will be. The newsletter is the part you pay for: five new AI tools every weekday morning, one line on what each does, one line on why it matters for a PM, and the link. Start with this morning’s issue, free.
$10/month or $96/year after 7 free days, cancel in one click · a real Adoption Brief, in full · every issue, published free · [email protected]
Other verdicts at this size
- Is Atlassian Jira worth it for a 100–1,000 person engineering team? — Yes, on Standard — the tool is not the decision at this size, the edition is. Jira Cloud Standard is $36,500 a year at 500 users and $68,500 at 1,000, and the Premium step is $26,000 and $42,000 a year for a checkbox that applies to everyone on the site.
- Is New Relic worth it for a 100–1,000 person engineering team? — Yes, if the user-type policy is written before the contract. Full platform users are $349 a month at Pro list against $49 for a core user, so fifty misassigned people cost $180,000 a year — several times the $0.40-per-GB data line everyone actually negotiates.
- Is Okta worth it for a 100–1,000 person engineering team? — Yes — identity is a control, not a convenience, at this size. The money is the suite: Okta publishes $6, $14 and $17 per user per month, so 500 identities is $36,000, $84,000 or $102,000 a year, and the upper suites only pay if somebody staffs the automation.
- Is PagerDuty worth it for a 100–1,000 person engineering team? — Yes, on Professional and billed annually. At 500 responders that is $126,000 a year against $246,000 on Business — and the money leaks through licences held by people who left the rota, at $252 each per year.
- Is Sentry worth it for a 100–1,000 person engineering team? — Yes, and paid plans include unlimited users so hiring does not raise the bill. The money is the rate card: Business re-prices every error at two to three times the Team rate, which is $5,268 a year at two million errors a month and $19,668 at ten million.
- Is Cursor worth it for a 100–1,000 person engineering team? — Yes, on Standard seats billed annually. At 500 engineers that is $192,000 a year against $576,000 for the all-Premium version of the same purchase — and the rework exposure is 4.7x to 38x the licence.
- Is Datadog worth it for a 100–1,000 person engineering team? — Yes, but only on a host count you measured yourself. Infrastructure Pro and APM on the same 500 hosts is $276,000 a year at list — and Datadog's own published retention rate says bills like yours grow about 20% a year.
- Is GitHub Copilot worth it for a 100–1,000 person engineering team? — Yes, on Business at $19 a seat. At 500 engineers that is $114,000 a year against a rework exposure of $900,000 to $7.4m — which is why the three controls matter more than the purchase order.
- Is Snowflake worth it for a 100–1,000 person engineering team? — Yes, on Standard at $2.00 a credit unless somebody can name the Enterprise feature. One X-Large warehouse left running is $280,320 a year — the settings decide this bill, not the contract.
- Do we need a vector database? — The other infrastructure purchase whose meter has nothing to do with headcount.
- Should we buy Devin? — A usage-metered developer tool where the unit is the whole argument.
- Is Cursor worth it for a 10-person engineering team? — The same costing method at a seat count you can hold in your head.
Every published verdict is listed on the verdicts index.