Daniel Kim

Posted on Aug 12

Statsig's Founders Left for OpenAI. Amplitude Got the Product You're Actually Buying.

#featureflags #experimentation #devtools #ai

If you went looking for a feature-flag vendor in the last twelve months, you probably ran into a headline about Statsig joining OpenAI for $1.1 billion. If you're going looking again today, the honest answer to "what am I buying" has quietly changed out from under that headline. The founder is at OpenAI. The product, the brand, and your support contract are now run by Amplitude, a company most people associate with product analytics, not feature flags.

That's not a footnote. It's the whole story, and it changes how you should read a Statsig vs. everyone-else comparison in 2026. So this isn't a generic "top 5 feature flag tools" roundup. It's a look at four platforms — Statsig (now mid-transition to Amplitude), LaunchDarkly, GrowthBook, and PostHog — through the lens of the one variable most comparison posts skip: who actually owns the thing you're signing a multi-year contract with, and what happens to your workflow when that changes.

Why this comparison matters right now

Feature flags used to be a boring, load-bearing piece of infrastructure: a toggle that let you ship code dark, roll it out gradually, and kill it instantly if it broke something. Then two things happened at once.

First, AI-assisted coding made code volume cheap. Google has said publicly that roughly 30% of its code is now AI-assisted, and whatever the exact number, the direction is not in dispute — teams are generating more variants of more features than they used to be able to review by hand. That doesn't reduce the need for a release-safety net; it increases it. Google's own incident writeup on the June 2025 Cloud outage — a null-pointer exception in a policy change that took down BigQuery, Cloud Run, Gmail, and Meet for millions of users — put it bluntly: "If this had been flag protected, the issue would have been caught in staging." That's a one-line advertisement for why flags aren't optional anymore, and it's from the company that broke, not from a vendor's sales deck.

Second, the market consolidating around flags just got genuinely weird. In September 2025, OpenAI acquired Statsig — an experimentation and feature-flagging platform used by companies like Atlassian, Notion, Brex, and Bloomberg — in an all-stock deal, and installed its founder, Vijaye Raji, as CTO of Applications reporting to Fidji Simo. OpenAI's own announcement said Statsig would "continue operating independently" out of its Seattle office. Eight months later, on May 5, 2026, Amplitude announced a "strategic partnership" under which it took on Statsig's brand, its platform, and its existing customer contracts, while committing to keep developing the product across cloud and data-warehouse deployments. As of Statsig's own June 2026 update, a team of roughly 50 people at Amplitude — not the original Statsig engineers, who stayed at OpenAI — is now running the platform day to day, with the original team advising during the handoff.

None of that makes Statsig a bad product. It might genuinely be a good one. But if you're a developer or engineering lead comparing tools today, you're not evaluating "the company OpenAI bought." You're evaluating a product that changed operational owners twice in under a year, is mid-integration with a second company's data model, and has a roadmap being co-written by two organizations that didn't build the thing. That's a materially different risk profile than the one implied by "OpenAI-backed feature flags," and it's exactly the kind of detail that gets lost between the acquisition headline and the vendor's landing page.

There's a second, quieter reason this comparison matters now: flags and experimentation are starting to wrap AI behavior, not just UI behavior. Statsig's near-term roadmap under Amplitude explicitly includes "AI Configs" for controlling prompts and model parameters without a redeploy, plus evals and LLM traces reaching general availability. PostHog ships an AI Observability product in the same bundle as its flags. That's a real shift: a "feature flag" in 2026 increasingly means the on/off switch and rollout percentage for a specific prompt template or model version, not just a UI element — which raises the stakes on picking a platform whose roadmap and ownership you actually trust for the next two or three years, not just the next quarter.

What each option actually does

LaunchDarkly is the closest thing feature flagging has to an incumbent. It started as a flag-delivery service and grew into a full release-management control plane: targeting rules, percentage rollouts, approval workflows, audit trails, flag lifecycle management (so stale flags get flagged for removal instead of rotting in your codebase forever), and deep integrations across CI/CD and observability tooling. Experimentation exists, but it's built as an extension of the release workflow rather than a first-class statistics engine.

Statsig, as designed by its original team, was built the opposite direction — from experimentation outward. It combined A/B testing, feature gates, dynamic config, product analytics, session replay, and real-time decisioning in one event pipeline, with both a frequentist and Bayesian stats engine, CUPED variance reduction, and sequential testing. Under Amplitude, the near-term roadmap (per Amplitude's own June 2026 post) is aimed at governance and AI-native workflows: MCP governance, tighter API controls, release pipelines for experiments, GA for evals and LLM traces, and — by the stated target of end of Q3 2026 — two-way data integration so Amplitude's behavioral events and Statsig's experiment outcomes show up inside each other's products.

GrowthBook takes a warehouse-native approach: instead of routing your product events through a vendor's pipeline, it queries the metrics you already have in Snowflake, BigQuery, Redshift, or similar, and lets you define experiment measures from your own tables. Feature flags are evaluated locally via SDK, and the entire core product is MIT-licensed and can be fully self-hosted, with a managed cloud option for teams that don't want to run it themselves.

PostHog doesn't compete on flags in isolation — it bundles feature flags, experiments, product analytics, session replay, surveys, error tracking, a data warehouse, and more into one open-core product under a single codebase and a single pricing meter. The pitch is consolidation: instead of stitching together a flag vendor, an analytics vendor, and a replay vendor, you run one system that happens to include flags as one of ten-plus modules.

How each is actually built

The architectural split that matters most here is event-pipeline vs. warehouse-native, because it determines who holds your data and how fast your numbers update.

LaunchDarkly and (pre-Amplitude) Statsig both built proprietary event ingestion pipelines: your app sends flag-evaluation and conversion events to the vendor, the vendor computes results, and you view them in a dashboard. This is fast to set up and requires no data-warehouse expertise, but it means a second copy of your event data lives in someone else's infrastructure, and your experiment results are only as trustworthy as that pipeline's fidelity to your actual product events.

GrowthBook flips this: no duplicate pipeline, because it reads directly from the warehouse you already trust for revenue reporting. That buys inspectability — you can literally open the SQL a metric definition generates — at the cost of needing a working warehouse and someone who can maintain the connection. Statsig has also added warehouse-native options for enterprise customers, and LaunchDarkly has a warehouse-native experimentation mode too, though multiple independent write-ups note it's currently limited to Snowflake and requires elevated account permissions to configure — a narrower on-ramp than GrowthBook's broader warehouse support.

PostHog sits architecturally closer to the event-pipeline camp — it ingests events into its own ClickHouse-backed data warehouse — but because that warehouse is the product (not a side channel to your existing one), and the schema is open, it avoids some of the "black box" criticism aimed at closed SaaS pipelines.

On deployment: GrowthBook is the only one of the four with a genuine full self-hosted option for its core product, data included. PostHog offers self-hosting for its open-source core, though its most advanced features increasingly favor the managed cloud version. LaunchDarkly is vendor-cloud only — there's no self-hosted control plane. Statsig, pre-Amplitude, was cloud-only for most customers with warehouse-native options for enterprise; nothing in the public transition updates so far indicates that's changing.

Developer experience: what it's actually like to use

Comparisons that stop at architecture miss the part developers feel every day — how long it takes to ship a first flag, and how much you have to think about the tool once it's running.

LaunchDarkly's SDK coverage is the widest of the four, with mature libraries across essentially every mainstream server and client language, plus a well-worn CLI and IDE integrations for finding stale flags in your codebase. That breadth is a real advantage on a polyglot team, and it's the product of a decade of being the default choice. The tradeoff is surface area: LaunchDarkly's dashboard has grown to cover governance, approvals, scheduling, and experiment configuration in one interface, and new users often need a ramp-up period to find the right screen for a given task.

GrowthBook's SDKs are thinner in raw language count but the setup path is short if you already have a warehouse connection — point it at your existing tables, define a metric once, and both flags and experiment analysis read from the same source. The self-hosted option adds a real setup cost up front (you're running the app, not just consuming an API), which is the correct tradeoff for a platform team but a poor one for a two-person startup that wants a flag live in an afternoon.

PostHog optimizes hardest for time-to-first-value: a single SDK snippet turns on analytics, session replay, and flags together, and the free tier means there's no procurement step between "we want to try this" and "it's running in production." The cost of that convenience shows up later, not at setup — as you lean on more of the ten-plus bundled products, you're increasingly committed to PostHog's opinions about how analytics, replay, and experimentation should work together, which is a stickier form of lock-in than a single-purpose tool creates.

Statsig's SDKs, under the original team, were consistently rated well for combining flags, experiments, and analytics event tracking in one call — and that engineering quality is exactly what Amplitude's Phase 1 post says it's trying to preserve while rebuilding the surrounding platform. Whether that day-to-day developer experience survives the migration to Amplitude's data layer unchanged is, again, the open question, not a settled one.

What actually changed vs. a year ago

A year ago, "pick a feature flag tool" was a stable, boring decision with four or five mature options and predictable trajectories. Today, three things are different:

Statsig's ownership is now two steps removed from its founding team, and its roadmap is being written jointly by a company (Amplitude) that didn't build the original product. Amplitude's own transition post is candid about this being early — "Phase 0" work wrapped in June 2026, full interoperability between the Amplitude and Statsig products isn't targeted until a later "Phase 2" with no firm date given.
LaunchDarkly's pricing has caught up with the market it created. Multiple independent buyer write-ups now cite quotes in the $100,000–$150,000/year range for a company around 50,000 monthly active users — a level that used to be enterprise-only pricing and now lands on mid-stage startups doing normal SaaS growth.
The bundled-suite model has gone mainstream. PostHog's pitch — flags as one module in a ten-plus-product suite, priced on usage rather than seats — has pulled enough adoption that "90% of PostHog users pay nothing," according to the company's own pricing page, because they never cross the free monthly allotment (1 million feature-flag requests, 1 million analytics events, and similar limits across each product, reset monthly).

Why developers should actually care

Cost. GrowthBook's cloud pricing and self-hosted option are reported by multiple sources to run at roughly half LaunchDarkly's cost at comparable scale, with GrowthBook's own comparison materials describing its pricing as flag- and traffic-unlimited on paid tiers — worth independently verifying against your own usage before treating that ratio as gospel, since it's partly a vendor's framing of a competitor. PostHog's usage-based free tier means a small team can run flags, experiments, and analytics at zero cost until they have real usage-based revenue to fund it, but usage-based pricing across ten bundled products also means your bill can grow in more directions than a single per-seat SaaS line item — worth modeling before you assume "generous free tier" caps your downside.

Lock-in. This is where the Statsig situation is the sharpest cautionary tale in the category right now. A cloud-only, closed-source platform is always something of a bet on the vendor's continuity — but Statsig customers who signed up under "OpenAI-backed" positioning are now, functionally, Amplitude customers, with a data model that's being actively re-plumbed to connect to Amplitude's analytics product. If you're mid-way through a self-serve trial of Statsig today, ask directly what "Phase 2 full interoperability" means for your existing gate and experiment configurations before you commit. GrowthBook is the only one of the four where lock-in is structurally limited by license — MIT core, full self-host, your data never has to leave your infrastructure.

Latency and reliability. SDK-local evaluation (LaunchDarkly, GrowthBook, PostHog's flag SDKs) means a flag check is a local lookup against a periodically-synced ruleset, not a network round trip per request — this matters at any real traffic volume, and all three vendors here support it. The bigger reliability question is upstream: what happens to your rollout config if the vendor's control plane has an outage. That's a case for kill-switch discipline regardless of vendor, and it's the exact failure mode Google's June 2025 incident illustrates.

Security and compliance. For regulated environments — healthcare, finance, government contractors — "can we self-host and keep flag-evaluation data off a third party's servers" is often a hard requirement, not a preference. GrowthBook is the only option here that clears that bar completely. LaunchDarkly and Statsig are vendor-cloud by default; PostHog's open-source self-hosted tier covers the core but the company steers its more advanced AI and analytics features toward its managed cloud.

Maintainability. Warehouse-native tools (GrowthBook, and increasingly Statsig's enterprise tier) reduce the "why do our dashboard numbers not match our warehouse numbers" class of bug, because there's one source of truth instead of two pipelines that can drift. Event-pipeline tools trade that inspectability for less operational surface area — nothing to keep running yourself, no warehouse expertise required to get started.

Practical use cases per option

LaunchDarkly fits a mid-to-large engineering org that has already decided flags are a release-engineering primitive, not a growth-team experimentation tool — think a regulated fintech or a company doing frequent canary and ring-based rollouts where an audit trail of who-approved-what matters as much as the flag itself. Its integration breadth (CI/CD, observability, incident tooling) is the strongest of the four when release governance is the actual job to be done.

GrowthBook fits a product or data team that already has a warehouse-centric analytics stack and wants flag rollouts and experiment results measured against the same metrics finance and leadership already trust — and fits especially well anywhere self-hosting is a hard requirement rather than a nice-to-have.

PostHog fits an early-stage startup or a small team that would otherwise be paying for four separate SaaS tools (analytics, replay, flags, surveys) and would rather run one system with one free tier, accepting a less specialized flagging feature set in exchange for not managing four vendor relationships.

Statsig / Amplitude fits a team that specifically wants the technical capabilities the original Statsig team built — the warehouse-native stats engine, dynamic config, the AI-native roadmap items like evals and LLM traces — and is comfortable running that bet through an ownership transition that is, by the vendor's own admission, still in its early phases as of mid-2026.

A concrete way to stress-test the choice: picture a 40-person startup rolling out an AI-generated checkout redesign to 5% of traffic with an automatic kill switch if error rates spike. On LaunchDarkly, that's a percentage rollout plus a metric-based guarded release, backed by an audit trail showing exactly who scheduled it — the governance layer is doing real work even at this size, arguably more than the team needs yet. On GrowthBook, the same rollout reads conversion and error-rate metrics straight from the warehouse the finance team already trusts, so there's no second number to reconcile when someone asks "did it actually work" in a board meeting. On PostHog, the rollout, the session replays of users who hit the new checkout, and the error tracking live in one timeline, which is genuinely fast for debugging but means a PostHog outage takes three workflows down at once instead of one. On Statsig today, the same rollout works largely as it always has — but the team configuring it is now Amplitude's, and the roadmap for how that config interacts with Amplitude's own analytics product is still being written.

What the marketing pages leave out

LaunchDarkly's pricing page won't show you a $100K+ quote — that number only shows up once you're far enough into a sales conversation that switching costs already look painful. Budget for the MAU-based scaling curve before you're locked into it, not after.

Statsig's and Amplitude's public messaging both, understandably, lean on "continuity for existing customers" language. What neither has published is a concrete technical migration guide for what changes in your SDK, your gate configuration, or your data retention once the "Phase 2" full interoperability work lands — because as of this writing, that work hasn't landed. Evaluating the platform today means evaluating a moving target, not the finished product either vendor is describing.

GrowthBook's own comparison content (some of the sourcing behind the pricing and architecture claims above) is, unsurprisingly, framed to favor GrowthBook — treat its head-to-head cost claims as a starting point for your own quote, not a verified number. Self-hosting also isn't free in the way "open source" sometimes implies: you're taking on the operational cost of running and upgrading the service yourself, which is a real line item even if it doesn't show up on an invoice.

PostHog's "90% of users pay nothing" statistic is real, per their pricing page, but it describes usage patterns across their whole customer base across all ten-plus bundled products, not a guarantee about your specific traffic. A team running meaningful experimentation traffic through PostHog's feature-flag and experiments module specifically — which is billed together — will cross free-tier limits faster than the headline stat implies.

Comparison table

Dimension	LaunchDarkly	Statsig (via Amplitude)	GrowthBook	PostHog
Primary framing	Enterprise release management	Managed experimentation + product suite	Open-source, warehouse-native flags & experiments	All-in-one bundled product suite
License	Proprietary	Proprietary	MIT (core)	Open-core (MIT-style core)
Self-hosting	No	No (cloud/warehouse-native enterprise tiers only)	Yes, fully	Yes, for core product
Data architecture	Vendor event pipeline; Snowflake-only warehouse-native mode	Event pipeline + enterprise warehouse-native option, mid-integration with Amplitude	Warehouse-native by default	Own ClickHouse-backed warehouse, open schema
Stats engine	Basic, tied to release workflow	Frequentist + Bayesian, CUPED, sequential	Frequentist + Bayesian, CUPED, sequential, bandits	Frequentist, bundled with product analytics
Pricing model	MAU-based; reported ~$100–150K/yr at 50K MAU	Free entry, event-based Pro, custom enterprise	Free Starter, per-seat Pro, custom Enterprise; reported ~half LaunchDarkly's cost	Usage-based across all products; generous free tier (~90% pay $0)
Governance/audit trail	Strongest of the four	Building out (MCP governance, API controls in progress)	Present, less mature	Present, secondary to analytics focus
Ownership stability (2026)	Independent, stable	Two ownership transitions in under a year; integration ongoing	Independent	Independent
Best fit	Enterprises needing release governance	Teams wanting the original Statsig tech, tolerant of transition risk	Teams needing warehouse-native rigor, self-hosting, or predictable pricing	Startups consolidating multiple tools under one bill

An independent read

Feature flagging is consolidating into something bigger than flags — every vendor here is racing to own "the layer where you decide if a change actually worked," not just "the layer where you turn a change on." LaunchDarkly is doing that by deepening governance. GrowthBook is doing it by staying close to your own data. PostHog is doing it by bundling. And Statsig built genuinely well-regarded technology to do it — but the company that built it no longer runs it, and the company that runs it now is still, by its own account, in the early phase of deciding what it becomes next. That's not a knock on Amplitude's execution so far, which reads as unusually transparent for a company mid-acquisition-integration. It's a statement about timing: evaluating Statsig today means evaluating a platform whose roadmap for the next two quarters is being written in public, in real time, by people who joined it four months ago.

If you need governance and can afford enterprise pricing, LaunchDarkly's maturity is real and worth paying for. If your team already lives in a data warehouse and self-hosting is non-negotiable, GrowthBook is the only one of the four that clears that bar without compromise. If you're small and want to stop paying for four SaaS tools, PostHog's bundle is a legitimately good trade. And if you want Statsig specifically, go in with eyes open about what "Statsig" currently means organizationally — and get a written answer, not a landing-page promise, about what happens to your configuration when Phase 2 lands.

Discussion: If you're currently on Statsig, has Amplitude's migration path (the "Amplitude events inside Statsig, Statsig outcomes inside Amplitude" integration targeted for Q3 2026) actually reached your account yet — and did anything in your SDK or gate configuration change without you asking for it?

Sources:

DEV Community