Featbit

Open-source feature flag management, honestly reviewed. No marketing fluff, just what you get when you self-host it.

TL;DR

• What it is: Open-source (MIT) feature flag management platform — think LaunchDarkly, but the server lives in your own infrastructure and there’s no per-seat bill waiting to ambush you [4].
• Who it’s for: Engineering teams and technical founders who want production-safe feature releases, A/B testing, and gradual rollouts without paying LaunchDarkly’s enterprise pricing. Also teams building on .NET who appreciate native C# support [3][4].
• Cost savings: LaunchDarkly’s pricing isn’t publicly listed at scale but is broadly reported as $300–$1,000+/month for teams of 20+. Featbit self-hosted runs free on a $6–10/month VPS [4].
• Key strength: Serious performance for the hardware footprint — 1.1k WebSocket connections per second and 22k simultaneous online users on a single vCPU with 1GB memory [4]. That’s surprisingly capable for what ships in a docker compose up.
• Key weakness: 1,772 GitHub stars is modest relative to competitors like Unleash (13,394), GrowthBook (7,666), and Flagsmith (6,304) — meaning smaller community, fewer third-party guides, and more you’ll be on your own when things break [1][4][5].

---

What is Featbit

Featbit is a self-hostable feature flag management service built on .NET (C#) and designed to replace commercial platforms like LaunchDarkly, Statsig, and Hypertune [4]. The core idea is simple: you wrap features in if/else checks against Featbit’s SDK, and then a dashboard lets you toggle those features, target specific user segments, and gradually roll out changes — without touching your code again or redeploying.

The project describes itself as “enterprise-grade” in its GitHub description, which is doing some heavy lifting at 1,772 stars, but the feature set earns the label more than the star count does. The README lists production testing, progressive delivery (1% → 10% → 100% rollouts), instant rollback without redeployment, and A/B experimentation as first-class capabilities [4][README].

What makes Featbit distinct from a basic feature-toggle library is the full service layer: a management dashboard, user targeting rules, SDK support for eight languages, REST APIs, webhooks, SSO, and audit logs. This isn’t just a config file — it’s a proper platform.

The tech stack is notable: .NET backend, Angular frontend, PostgreSQL plus Redis as data stores. If your engineering team is already a .NET shop, Featbit is one of the few open-source options built in the same ecosystem rather than ported into it [2][3].

As of this review: 1,793 stars, 140 forks, last commit within 24 hours [4]. The project is actively maintained.

---

Why people choose it (synthesis from articles)

The short version: teams choose Featbit because they want feature flag management that doesn’t cost four figures per month and doesn’t hand their user data to a third-party SaaS.

Versus LaunchDarkly. This is Featbit’s primary comparison [4]. LaunchDarkly is the category leader — it has the slickest dashboard, the deepest integrations, and the most enterprise polish. It also has enterprise pricing to match. For a startup or small engineering team, spending hundreds per month on flag management is hard to justify when the open-source alternative ships in three Docker commands and handles production-scale traffic on modest hardware.

Versus Unleash. Unleash is the obvious open-source comparison — it has 13,394 stars versus Featbit’s 1,793 and a longer track record [1]. Unleash is probably the safer bet if community size and ecosystem matter to you. Featbit’s edge is performance per hardware dollar (the 22k concurrent user claim on 1 vCPU is notable) and native .NET support, which Unleash doesn’t prioritize [3][4].

Versus GrowthBook. GrowthBook (7,666 stars) positions more heavily as an A/B testing and experimentation platform — it’s the choice when statistical analysis and data science integration are the primary goal. Featbit’s experimentation features exist but they’re more of a secondary concern; feature flagging and safe deployment are the lead story [1].

Versus Flagsmith. Flagsmith (6,304 stars, BSD-3-Clause license) is the closest functional match to Featbit in terms of positioning [5]. Both are self-hostable, both target the LaunchDarkly replacement use case. Featbit’s MIT license is cleaner than Flagsmith’s BSD-3-Clause for teams who care about redistribution rights, though both are meaningfully open-source. Flagsmith has a larger community; Featbit has stronger documented performance benchmarks.

The pattern across the reviews: Featbit is the choice for teams who want LaunchDarkly-grade functionality without LaunchDarkly pricing, are comfortable in .NET, and don’t need the largest possible community for support.

---

Features

Based on the README and third-party descriptions:

Core feature flag management:

• Create, manage, and filter feature flags from a central dashboard [3][4]
• Boolean flags and multivariate flags (multiple string/number/JSON variants) [4]
• Targeting rules based on user attributes, segments, and percentages [3][4]
• Progressive rollouts: release to 1% of users, then expand to 100% without code changes [README]
• Instant flag evaluation updates — no cache lag waiting to bite you in production [4]
• Offline mode support in SDKs for degraded network conditions [4]

Experimentation:

• A/B testing with on-demand experimentation reports [3]
• Conversion tracking and business metric measurement tied to flag variants [README]
• Continuous measurement of feature impact on business value [README]

SDK support:

• .NET (C#), JavaScript, React, React Native, Node.js, Java, Python, Go [README]
• OpenFeature providers — meaning Featbit plugs into the OpenFeature standard interface [README]
• “More to come” per the README [README]

Operations and integrations:

• REST API for programmatic flag management [4]
• Webhooks and triggers for external integrations [4]
• Slack integration [features list]
• Audit logs — who changed what flag and when [3][4]
• SSO support [features list]
• Docker, Docker Compose, Helm/Kubernetes deployment [README][4]

Performance and scale:

• Single vCPU + 1GB memory: 1.1k WebSocket connections/sec, 22k simultaneous online users [4]
• Horizontal and vertical scaling to 50k+ WebSocket connections/sec and 1M+ simultaneous users [4]
• Built-in performance benchmarks — the project ships benchmark tooling in the repo [README]

Notable absence: The README includes an llm/ directory in the repository structure, suggesting LLM integration experiments, but no documented AI-native features appear in the current stable release.

---

Pricing: SaaS vs self-hosted math

LaunchDarkly (the incumbent you’re escaping): Pricing is not public at standard tiers but is widely reported as expensive for teams past the free trial. The platform positions itself for enterprise engineering teams — if you’re paying for it, you know what it costs.

Featbit self-hosted (Community Edition):

• Software: $0 (MIT license) [README][4]
• VPS to run it: $6–10/month (Hetzner CX11 or equivalent — 1 vCPU, 2GB RAM comfortably handles their documented workload)
• Redis and PostgreSQL are bundled in the default Docker Compose — no separate managed database required to start

Featbit cloud (featbit.co): Pricing details were not available in the sources reviewed for this article. The GitHub README links to an online demo at app.featbit.co but doesn’t list public cloud pricing tiers. Check https://www.featbit.co directly for current pricing.

The math that matters:

If your team is on LaunchDarkly or Statsig and paying $200–$500/month, the self-hosted path breaks even in the first month. The engineering cost is: one afternoon of setup, ongoing maintenance of a two-container Docker deployment. For most teams that’s a few hours per quarter maximum.

What you give up: SLA guarantees, managed uptime, and someone else’s on-call rotation. What you gain: zero recurring per-seat cost and your user targeting data stays inside your own infrastructure.

---

Deployment reality check

The README’s install path is genuinely three commands:

git clone https://github.com/featbit/featbit
cd featbit
docker compose up -d

After that, the portal runs at http://localhost:8081 with default credentials test@featbit.com / 123456 [README]. Change those immediately.

What the default Docker Compose includes: The repository ships four separate compose files — docker-compose.yml (standard), docker-compose-standard.yml, docker-compose-pro.yml, and docker-compose-mongodb.yml (MongoDB variant) [README]. The standard setup bundles PostgreSQL and Redis, so you don’t need external managed databases to start.

What you still need to handle yourself:

• A reverse proxy (Caddy or nginx) for HTTPS if this is publicly accessible — the README notes the portal is localhost-only by default and links to an FAQ for public access [README]
• Domain name and DNS if you want team access beyond your local machine
• Changing default credentials (obvious, but worth stating)
• Firewall configuration — the WebSocket port and API port both need to be accessible to your SDK clients

Kubernetes: Helm charts and K8s manifests are in the kubernetes/ and infra/ directories [README]. This is more setup than the Docker Compose path but the files exist.

What can go sideways:

• The four different compose files (standard, pro, mongodb) suggest the project went through some architecture evolution. Read the docs before picking one — docker-compose.yml is the one to start with, but the distinction between standard and pro isn’t immediately obvious from the filenames alone.
• At 1,772 stars and an active-but-small community, debugging obscure issues means reading source code rather than finding a Stack Overflow answer. The Slack community exists but is nowhere near Unleash’s or Flagsmith’s support surface.
• The .NET backend is less familiar territory for Python/Node.js shops — monitoring, custom debugging, and potential contributions all require a .NET lens.

Realistic time for a technical user: 45–90 minutes to a running instance with HTTPS. For a non-technical founder: this is a tool your engineering team deploys, not something you set up yourself over a weekend.

---

Pros and Cons

Pros

• Clean MIT license. Not “fair-code,” not BSL, not “free unless you compete with us” — MIT. You can embed it, fork it, redistribute it, build a product on top of it [README][4]. GrowthBook and Unleash both have similar open licensing, but it’s worth confirming per-tool.
• Impressive performance per hardware dollar. 22k simultaneous users on 1 vCPU is not a common benchmark to publish, and the fact that they ship benchmark tooling in the repo suggests confidence in the numbers [4][README].
• Native .NET/C# support. For teams building on Microsoft’s stack, first-class C# SDK matters — and most competitors in this category are Node.js or Go first, .NET second [2][3].
• Multi-language SDK coverage. .NET, JavaScript, React, React Native, Node.js, Java, Python, Go, OpenFeature — most common stacks covered [README].
• Batteries included Docker Compose. PostgreSQL and Redis bundled, three commands to running instance [README].
• Audit logs and SSO included — these are gated behind commercial plans in some competitors [4].
• Active maintenance. Last commit within 24 hours as of the data snapshot [4]. The project isn’t abandoned.

Cons

• Small community. 1,793 stars against Unleash’s 13,394 and Flagsmith’s 6,304 means fewer community guides, fewer third-party integrations, and a thinner support surface [1][4][5].
• Angular frontend. In a world that has mostly moved to React-based dashboards, the Angular 16 frontend is a signal about the team’s technology preferences that may or may not match yours — and finding frontend contributors is harder [README].
• No documented A/B testing statistical methodology. The platform offers experimentation reports [3] but the sources don’t describe the underlying statistical approach (frequentist? Bayesian? sequential testing?). If statistical rigor in A/B testing matters to you, verify before committing.
• Pricing for managed cloud not publicly documented. The online demo exists, but there’s no public pricing page for the hosted service in the reviewed sources.
• The “enterprise-grade” claim is ahead of the star count. The features are real, but the community and ecosystem aren’t enterprise-scale yet. If you need a vendor with 10 years of production deployments behind it, this isn’t it.
• MongoDB vs PostgreSQL ambiguity. Shipping two different persistence backends (docker-compose.yml vs docker-compose-mongodb.yml) without clear guidance on which is recommended for production adds a decision point that shouldn’t exist.

---

Who should use this / who shouldn’t

Use Featbit if:

• Your team is on .NET/C# and wants an ecosystem-native feature flag service rather than a Node.js tool grafted onto your stack.
• You’re paying for LaunchDarkly, Statsig, or Hypertune and want to eliminate the recurring cost without rebuilding your deployment workflow.
• Your workload is performance-sensitive — WebSocket-based flag evaluation at scale with low hardware requirements is a real differentiator.
• You want MIT-licensed infrastructure you can embed in your own product or run in an air-gapped environment.
• Your team is comfortable operating Docker containers and you have a technical person who can own the deployment.

Consider Unleash instead if:

• Community size and third-party guide availability matter to you — Unleash has 13,394 stars, a larger ecosystem, and more production case studies [1].
• You want a more established open-source option with longer track record.

Consider GrowthBook instead if:

• A/B testing and statistical experimentation are your primary use case, not deployment safety [1].
• You need tight data warehouse integration (GrowthBook has strong BigQuery/Snowflake/Redshift connectors).

Consider Flagsmith instead if:

• You want a slightly larger community with more deployment guides and the BSD-3-Clause license is fine [5].

Stay on LaunchDarkly if:

• You need enterprise SLAs and vendor accountability.
• You’re in a compliance-heavy environment where self-managed infrastructure creates more audit overhead than it saves.
• Your team has zero bandwidth to operate another service.

---

Alternatives worth considering

From the openalternative.co data and feature comparisons:

• Unleash — the most-starred open-source feature flag platform (13,394 stars), Apache-2.0 licensed, mature ecosystem. The default safe choice if you want community coverage [1].
• GrowthBook — 7,666 stars, focused on A/B testing and experimentation with strong analytics integrations. Pick this if experiments and statistics are the primary goal, not deployment control [1].
• Flagsmith — 6,304 stars, BSD-3-Clause, self-hostable, strong feature parity with Featbit. More community resources, slightly less impressive performance claims [5].
• Flipt — 4,772 stars, Git-native feature management for teams who want flags-as-code in their repository workflow [4].
• Featurevisor — 797 stars, GitOps-first approach where flags live as files in your Git repo. More niche but interesting if GitOps is your deployment model [1].
• LaunchDarkly — the commercial incumbent. The right answer if you need enterprise support and can pay for it.

For a technical founder escaping LaunchDarkly bills, the realistic shortlist is Featbit vs Unleash vs Flagsmith. Featbit wins on .NET ecosystem fit and documented performance; Unleash wins on community; Flagsmith splits the difference.

---

Bottom line

Featbit is a solid, actively maintained feature flag platform that does what it says: ships as three Docker commands, handles production-scale WebSocket traffic on modest hardware, covers eight language SDKs, and carries a clean MIT license. For a .NET engineering team tired of LaunchDarkly’s pricing, it’s a serious option worth evaluating. The caveats are honest: a small community means fewer guides and a thinner support surface than Unleash or Flagsmith, the “enterprise-grade” positioning slightly oversells where the project is today by star count, and the managed cloud pricing isn’t transparent enough to make a cost comparison without contacting the team. But the core feature flag management — which is what most teams actually need — is complete, fast, and free to self-host. If your team can own the deployment, the bill savings over a year make the afternoon of setup straightforward math.

If the deployment part is the blocker, that’s exactly the kind of one-time setup that upready.dev handles for teams who’d rather have it running by tomorrow.

---

Sources

1. OpenAlternative — Open Source Projects tagged “Ab Testing” — openalternative.co. https://openalternative.co/tags/ab-testing
2. OpenAlternative — Open Source Projects tagged “Csharp” — openalternative.co. https://openalternative.co/tags/csharp
3. ClickUp Engineering Team — “10 Best Feature Flagging Software for Dev Teams in 2026” (Jan 28, 2025) — clickup.com. https://clickup.com/blog/feature-flagging-software/
4. OpenAlternative — “FeatBit: Open Source Alternative to LaunchDarkly, Statsig and Hypertune” — openalternative.co. https://openalternative.co/featbit
5. OpenAlternative — “Flagsmith: Open Source Alternative to LaunchDarkly, Statsig and Hypertune” — openalternative.co. https://openalternative.co/flagsmith

Primary sources:

• GitHub repository and README: https://github.com/featbit/featbit (1,793 stars, MIT license)
• Online demo: https://app.featbit.co
• Official website: https://www.featbit.co
• Documentation: https://docs.featbit.co