FeatBit

FeatBit is an open‑source, self‑hosted feature flag service that gives developers fine‑grained control over code execution paths without requiring redeployments. Built on modern .NET (≥ 6) and a lightweight Angular 16 front‑end, it exposes a RESTful API and SDKs for .NET, Python, and JavaScript that support real‑time updates, offline mode, and event collection. The system is designed to run inside Docker or Kubernetes clusters, allowing teams to keep the service within their own network for compliance and data sovereignty.

Architecture

• Backend: ASP.NET Core 6+ microservice architecture, leveraging MediatR for CQRS and Entity Framework Core for persistence. The core domain is split into Feature Management (flag definition, targeting rules), Identity & Auth (OAuth2/OpenID Connect via IdentityServer4), and Eventing (Kafka or Redis Streams for real‑time flag propagation).
• Database: PostgreSQL is the primary relational store; optional Redis for caching and session state. The schema supports hierarchical flag structures, segmentation targeting, and audit trails.
• Frontend: Angular 16 SPA using NgRx for state management. It communicates with the API over HTTPS and renders flag dashboards, segmentation builders, and analytics.
• SDKs: Native libraries in C#, Python, JavaScript/TypeScript. They implement a client‑side cache that refreshes via long‑polling or WebSocket, ensuring near real‑time flag changes with minimal latency.

Core Capabilities

• Granular Flag Evaluation: Targeting rules based on user attributes, environment variables, or custom segments. Supports percentage rollouts and A/B testing configurations.
• Event Hooks & Webhooks: External services can subscribe to flag change events or receive notification payloads for audit and analytics pipelines.
• Audit & Analytics: Built‑in dashboards expose flag usage, rollout progress, and error rates. All events are persisted for compliance audits.
• SDK Features: Offline mode (caching), real‑time updates, and optional telemetry collection for usage metrics.

Deployment & Infrastructure

• Containerization: Docker Compose scripts ship with the repo; Helm charts are available for Kubernetes deployments on Azure, GKE, or EKS. The image is lightweight (≈ 200 MB) and can be run on any platform supporting .NET 6+.
• Scalability: Horizontal scaling is supported by stateless API instances behind a load balancer. Redis or Kafka can be scaled independently to handle high event throughput.
• Self‑Hosting Requirements: A PostgreSQL instance, Redis (optional), and a reverse proxy (NGINX/Traefik) for TLS termination. The system can run on bare metal, VMs, or cloud‑managed services.

Integration & Extensibility

• Plugin System: The backend exposes a modular architecture; developers can add custom rule evaluators or authentication providers via dependency injection.
• OpenAPI Spec: Full API documentation is auto‑generated and available at /swagger. Custom client libraries can be generated with Swagger Codegen.
• SDK Extensibility: SDKs allow custom event listeners and telemetry sinks, enabling integration with monitoring tools like Prometheus or Grafana.

Developer Experience

• Configuration: All settings are externalized via environment variables or a appsettings.json file, facilitating CI/CD pipelines.
• Documentation: The official docs cover API usage, SDK integration, and deployment scenarios. Inline code comments are plentiful due to the open‑source nature.
• Community: Active Slack channel, GitHub issues, and a dedicated LinkedIn page keep developers connected. The project is MIT‑licensed, encouraging commercial use without licensing overhead.

Use Cases

1. Feature Rollouts: Deploy code to production, then enable a feature for 5% of users and gradually increase exposure while monitoring metrics.
2. A/B Testing: Toggle between UI variants without code changes, measuring engagement and conversion rates.
3. Compliance & Data Residency: Host the flag service on-premises to keep user segmentation data within a regulated jurisdiction.
4. Rapid Incident Recovery: Disable a problematic feature instantly across all environments without redeploying.

Advantages

• Performance: In‑process SDKs with local caching keep flag evaluation latency under 1 ms.
• Flexibility: The open‑source license and modular architecture allow custom extensions without vendor lock‑in.
• Operational Simplicity: Docker/K8s deployment and lightweight binaries reduce infrastructure overhead compared to commercial counterparts.
• Developer‑First: Straightforward if/else logic, rich SDKs, and an intuitive UI make it accessible to developers who prefer to drive business changes directly.

FeatBit’s blend of a robust, scalable backend with lightweight SDKs and an extensible plugin system makes it a compelling choice for teams that need to ship features safely, target audiences precisely, and maintain full control over their feature flag service.