FeatBit

FeatBit is an open-source, enterprise-ready feature flag management platform that decouples code deployments from feature releases, allowing teams to ship safely, target users precisely, and roll back instantly — without redeployment. Built on .NET 8 and Python, it provides a dedicated evaluation server for high-throughput, real-time flag delivery to SDKs via WebSockets, alongside a full management API for creating and governing flags across projects and environments.

The platform supports official SDKs for .NET (C#), Python, Node.js, Java, Go, React, React Native, and OpenFeature providers, making it language-agnostic and suitable for polyglot engineering teams. Deployment options span Docker Compose for single-node setups, Kubernetes with Helm Charts for scalable production environments, and Relay Proxies for edge deployments in customer-managed infrastructure.

FeatBit’s architecture cleanly separates the management API, evaluation server, data analytics server, and Angular frontend into independently deployable services. The infrastructure layer is pluggable — teams can start with PostgreSQL as both the database and message queue, then migrate to Kafka, MongoDB, or ClickHouse as scale demands. Built-in experimentation supports feature-level A/B tests with real-time insight tracking.

The platform is open core: all core feature flag capabilities are MIT-licensed, while enterprise features — including SSO integration, change request workflows, fine-grained RBAC, flag comparison views, and auto-agents — require a paid license key, verified cryptographically within the domain layer.

What You Get

• Multi-language SDK ecosystem - Official SDKs for .NET (C#), Python, Node.js, Java, Go, React, React Native, and OpenFeature providers covering server-side and client-side workloads across polyglot stacks.
• Real-time WebSocket evaluation server - A dedicated evaluation server streams flag changes to connected SDKs over WebSockets, so clients receive updates within milliseconds of a flag toggle without polling.
• User targeting and segments - Define reusable segments using user attributes like plan tier, country, or custom properties, then target flags at individual users or segments with percentage rollouts.
• A/B testing and experimentation - Run feature-level experiments with conversion and metric tracking via a built-in data analytics server, comparing variations across real traffic to make data-driven decisions.
• Feature Workflow automation - Automate flag lifecycle with scheduled changes, change approval requests, and flag triggers that fire on external signals — reducing manual intervention in release pipelines.
• Relay Proxy / Agent - Deploy lightweight edge agents in customer-managed or air-gapped environments to cache flag state locally, ensuring low latency and offline availability without routing traffic to your central server.
• Audit logs and change tracking - Every flag modification is recorded with the actor, timestamp, and diff, providing a complete audit trail for compliance and incident debugging.
• IAM and fine-grained RBAC - Define roles with per-environment and per-flag permissions, integrate with OAuth 2.0 providers and SSO (Okta, Azure AD, Auth0), and enforce least-privilege access across teams.
• Webhook and observability integrations - Connect to Slack, DataDog, New Relic, Grafana, and Growthbook via webhooks; instrument flag usage with OpenTelemetry traces, logs, and metrics.
• Flag comparison helicopter view - Compare flag configurations across environments in a diff-style view, then promote settings from dev to staging to production with one-click copy-to-env.
• FeatBit CLI and REST APIs - Automate flag creation, targeting updates, and environment management via a CLI tool and versioned REST APIs suitable for GitOps and infrastructure-as-code workflows.
• AI Copilot for technical debt - An experimental VSCode extension and ChatGPT integration that scans codebases for stale flag references and suggests cleanup actions to reduce feature flag technical debt.

Common Use Cases

• Phased production rollout - An engineering team ships a rewritten checkout flow to 2% of users initially, monitors error rates and latency in the analytics dashboard, then gradually expands to 100% — all without a new deployment.
• A/B testing a pricing page - A growth team creates two pricing layout variants in FeatBit, assigns 50% of visitors to each via percentage rollout, and measures conversion lift using the built-in experimentation engine.
• Compliance-driven self-hosting - A healthcare company deploys FeatBit on-premises within its EU data perimeter to retain full control of user targeting data while still enabling rapid iteration on features.
• Enterprise feature governance - A financial services team enforces change request approvals before any flag targeting rule reaches production, creating an auditable paper trail for regulatory review.
• Edge deployments with Relay Proxy - A SaaS vendor installs FeatBit Relay Proxies inside each enterprise customer’s private VPC, ensuring flag decisions are served locally with sub-millisecond latency and no data leaving the customer’s environment.
• Kill switch for incident response - An on-call engineer toggles a FeatBit flag to instantly disable a malfunctioning AI recommendation engine across all users within seconds, with the change propagated in real time via WebSocket to all connected clients.

Under The Hood

Architecture FeatBit decomposes into four independently deployable services: an ASP.NET Core management API, a dedicated ASP.NET Core evaluation server, a Python/Flask data analytics server, and an Angular frontend portal. Within each .NET service, a strict layered architecture separates Domain models from Application-layer CQRS handlers (dispatched via MediatR) from pluggable Infrastructure implementations. The evaluation server uses a custom WebSocket streaming middleware to push flag state changes to connected SDKs in real time, decoupled from the management API’s REST surface. The entire infrastructure tier is provider-swappable — teams select PostgreSQL, MongoDB, or Kafka at deployment time via environment configuration without changing application code, enabling a smooth scaling path from a single Docker Compose node to a full Kubernetes cluster.

Tech Stack The management API and evaluation server both run on ASP.NET Core targeting .NET 8, using MediatR for command/query dispatch, FluentValidation for input enforcement, AutoMapper for mapping, and Entity Framework Core with Npgsql for PostgreSQL persistence alongside Dapper and SqlKata for performance-critical queries. Multi-database support covers PostgreSQL, MongoDB (via MongoDB.Driver), and ClickHouse for analytics; Confluent.Kafka handles high-throughput messaging in professional deployments, while StackExchange.Redis provides optional caching. The data analytics server is Python with Flask, gunicorn, and supervisord. The Angular 19 frontend is built with TypeScript and packaged via Docker with nginx as the gateway. Deployment targets span Docker Compose, Kubernetes Helm Charts, and bare-metal start scripts.

Code Quality The codebase has comprehensive testing across all four modules: the backend carries Application.IntegrationTests, Application.UnitTests, and Domain.UnitTests; the evaluation server has Streaming.UnitTests alongside WebSocket-level integration tests covering connection, data sync, echo, and rate-limiting scenarios; Python analytics has integration tests for event ingestion pipelines. C# enforces nullable references in strict mode throughout, and FluentValidation guards every command at the application boundary. Serilog provides structured logging across all server services. Error handling follows typed HTTP status code conventions with dedicated exception and error-code abstractions. The Angular frontend uses karma for unit testing. Continuous integration configuration is not present in the repository itself, though Docker-based workflows and Helm chart packaging provide standardized build artifacts.

What Makes It Unique FeatBit’s most distinctive technical decision is its dedicated evaluation server with custom WebSocket streaming middleware, which pushes flag changes to SDKs in real time without requiring a separate pub/sub broker in the standard deployment — differentiating it from tools that rely on client polling or external Redis pub/sub. The Relay Proxy enables a deployment pattern rarely seen in open-source flag platforms: edge-resident agents that cache and serve flag decisions inside customer private networks, supporting air-gapped and data-sovereignty requirements. The flag comparison helicopter view with environment-aware diff and one-click promotion is a workflow capability that most self-hosted alternatives lack. The open-core license model is implemented with RSA-signed cryptographic license keys verified inside the Domain layer itself, making enterprise feature gating transparent and auditable at the code level rather than hidden in configuration.

Self-Hosting

FeatBit’s core is released under the MIT License, a permissive open-source license that imposes no restrictions on commercial use, modification, or distribution. You can run it in production for any purpose, include it in proprietary products, and distribute modified versions without sharing source code. The only obligation is to retain the copyright notice. However, FeatBit is an open-core product: a defined set of enterprise capabilities — SSO, scheduled flag changes, change request approval workflows, multi-organization support, shareable segments, fine-grained per-flag RBAC, flag environment comparison, and the auto-agents feature — require a valid license key obtained from the FeatBit team. These restrictions are enforced cryptographically via RSA-signed keys verified within the domain layer, so the feature gates are explicit and auditable in the source code.

Running FeatBit yourself means taking ownership of a multi-service system: at minimum you manage an API server, an evaluation server, a data analytics server, and a PostgreSQL database, all containerized and orchestrated via Docker Compose or Kubernetes. For a small team on a single-node setup, the operational overhead is modest — docker compose up deploys everything in minutes. For production at scale, you are responsible for database backups, Kubernetes resource tuning, monitoring integration (OpenTelemetry, DataDog, Grafana), zero-downtime upgrades (which may include manual database migration scripts between versions), and Relay Proxy deployments for edge environments. The project ships Helm Charts and migration SQL/JS scripts per release, but applying them correctly under live traffic is your responsibility.

Compared to FeatBit’s managed cloud offering or commercial alternatives like LaunchDarkly and Flagsmith Cloud, self-hosting trades managed uptime, automatic upgrades, and vendor SLAs for full data sovereignty and no per-seat or per-MAU pricing. The cloud tier adds guaranteed availability, managed scaling, enterprise support with SLAs, and access to all enterprise features without self-managing a license key. For teams with strict data residency requirements, regulatory constraints, or cost sensitivity at high user volumes, self-hosted FeatBit is compelling; for teams that want to focus entirely on product rather than infrastructure, the managed option removes the operational burden.