FeatureSignalsFeatureSignals

Everything you need to manage feature flags

A complete, open-source feature management platform built for engineering teams that value speed, control, and transparency.

Ship with Confidence

Deploy daily, release strategically

Flag Engine

Boolean, string, number, JSON, and A/B flag types. Percentage rollouts with MurmurHash3 consistent hashing. User targeting with 13 operators. Segment-based rules with AND/OR logic.

client := fs.NewClient("YOUR_API_KEY")
defer client.Close()

enabled := client.IsEnabled("checkout-redesign",
    fs.User{Key: "user-42", Attributes: map[string]any{
        "plan": "pro", "country": "IN",
    }})

if enabled {
    renderNewCheckout()
}

Multi-Environment

Dev, staging, production, and custom environments. Per-environment flag states and targeting rules. Promote configurations between environments. Per-environment API keys.

// Different API keys per environment — same code, different config
devClient := fs.NewClient(os.Getenv("FS_DEV_KEY"))
prodClient := fs.NewClient(os.Getenv("FS_PROD_KEY"))

// Flag is ON in dev, 10% rollout in prod
devClient.IsEnabled("new-feature", user)  // true
prodClient.IsEnabled("new-feature", user) // depends on rollout

Kill Switch & Scheduling

Emergency disable any flag with one click. Schedule flags to auto-enable or auto-disable at specific times. Background scheduler checks every 30 seconds with full audit trail.

# Emergency disable — propagates to all SDKs in seconds
curl -X POST https://api.featuresignals.com/v1/projects/proj-1/flags/risky-feature/kill \
  -H "Authorization: Bearer <token>" \
  -d '{ "env_id": "env-production" }'

# Response: { "status": "killed", "flag_key": "risky-feature" }

Experiment & Measure

Data-driven decisions, not guesses

A/B Experimentation

Built-in variant assignment with weighted splits. Consistent hashing ensures the same user always sees the same variant. Impression tracking API for analytics.

import { useStringFlagDetails } from "@featuresignals/react";

function PricingPage() {
  const { value, reason } = useStringFlagDetails(
    "pricing-experiment", "control"
  );

  return value === "treatment-a"
    ? <NewPricing />
    : <CurrentPricing />;
}

Mutual Exclusion Groups

Prevent experiment interference by grouping flags that should never be active for the same user simultaneously. Deterministic winner selection using consistent hashing.

// POST /v1/evaluate with two mutually exclusive flags
// Only ONE will return "on" for any given user

{ "key": "banner-experiment",  "value": true,  "reason": "SPLIT" }
{ "key": "pricing-experiment", "value": false, "reason": "MUTUAL_EXCLUSION" }

Usage Insights & Metrics

In-memory counters tracking evaluations per flag, environment, and reason. Value distribution insights showing true/false percentages. Dashboard visualization with top-flags chart.

curl "https://api.featuresignals.com/v1/projects/proj-1/environments/env-prod/flag-insights" \
  -H "Authorization: Bearer <token>"

# [
#   { "flag_key": "new-checkout", "true_pct": 75.2, "false_pct": 24.8 },
#   { "flag_key": "dark-mode", "true_pct": 41.0, "false_pct": 59.0 }
# ]

Debug & Troubleshoot

See exactly what every user experiences

Entity Inspector & Comparison

See all flag evaluations for a specific user. Compare two users side-by-side to verify targeting rules, permission gating, and rollout percentages are working correctly.

curl -X POST .../inspect-entity \
  -H "Authorization: Bearer <token>" \
  -d '{
    "entity_key": "user-42",
    "attributes": { "plan": "enterprise", "country": "US" }
  }'

# Returns: flag_key, value, reason for every flag

Environment Comparison & Sync

Compare flag states across environments side-by-side. Spot configuration drift instantly. Bulk-sync selected flags from one environment to another with full audit trail.

curl "https://api.featuresignals.com/v1/projects/proj-1/flags/compare-environments\
?source_env_id=env-staging&target_env_id=env-production" \
  -H "Authorization: Bearer <token>"

Stale Flag Scanner

CLI tool that scans your codebase for flag references and reports stale flags. CI/CD mode exits with code 1 on stale flags found. JSON and table output.

# Scan for stale flags
featuresignals scan --dir ./src --api-key $FS_API_KEY

# CI mode — fails the build if stale flags exist
featuresignals scan --dir ./src --ci --api-key $FS_API_KEY

Govern & Comply

Enterprise-grade control and auditability

Enterprise Governance

Tamper-evident audit logs with before/after diffs. Approval workflows for production changes. RBAC with owner/admin/developer/viewer roles. Per-environment permissions.

# Request approval before enabling in production
curl -X POST .../v1/approvals \
  -H "Authorization: Bearer <dev-token>" \
  -d '{
    "flag_id": "flag-uuid",
    "change_type": "toggle",
    "payload": { "enabled": true }
  }'

# Admin approves
curl -X POST .../v1/approvals/{id}/review \
  -d '{ "action": "approve", "note": "LGTM" }'

Toggle Categories & Lifecycle

Classify flags as release, experiment, ops, or permission. Category-aware staleness thresholds (14d, 30d, 90d, 90d). Track status through active → rolled_out → deprecated → archived.

{
  "key": "circuit-breaker-payments",
  "category": "ops",
  "status": "active"
}

// Staleness thresholds:
// release: 14 days, experiment: 30 days
// ops: 90 days, permission: never

Webhooks & Integrations

HTTP webhooks with HMAC-SHA256 signatures. Event filtering by type. Exponential retry with delivery logging. Integrate with Slack, CI/CD, or any HTTP endpoint.

{
  "event": "flag.state.updated",
  "data": {
    "flag_key": "new-checkout",
    "environment": "production",
    "enabled": true,
    "actor": "admin@company.com"
  }
}
// Delivered with X-Signature: sha256=<hmac>

Deploy Your Way

Self-host, cloud, or hybrid — you choose

SDKs for Every Stack

Go, Node.js, Python, Java, C#, Ruby, React, and Vue SDKs. All implement OpenFeature providers for zero vendor lock-in. Local evaluation. SSE streaming for real-time updates.

import fs "github.com/featuresignals/sdk-go"

client := fs.NewClient("YOUR_API_KEY")
defer client.Close()

if client.IsEnabled("dark-mode", fs.User{Key: "user-42"}) {
    enableDarkTheme()
}

Relay Proxy

Lightweight Go binary caching flags at the edge. Reduces latency, provides fault tolerance, and minimizes upstream API load. Syncs via SSE or polling.

docker run -d --name relay-proxy \
  -p 8081:8081 \
  -e FS_UPSTREAM=https://api.featuresignals.com \
  -e FS_API_KEY=relay-key-abc123 \
  -e FS_SYNC_MODE=sse \
  featuresignals/relay-proxy:latest

# SDKs connect to relay → lower latency, offline resilience

Deploy Anywhere

Docker Compose for quick start. Self-host on any VPS. Kubernetes-ready. Caddy for automatic HTTPS. Single Go binary with zero external dependencies beyond PostgreSQL.

git clone https://github.com/dinesh-g1/featuresignals
cd featuresignals
docker compose up -d

# Services: API (8080), Dashboard (3000), PostgreSQL (5432)

How FeatureSignals Compares

Open-source with full feature parity. No per-seat pricing. No evaluation caps.

FeatureFeatureSignalsLaunchDarklyUnleash
Open-source (Apache 2.0)
Self-hosted option
A/B experimentation
Mutual exclusion groups
OpenFeature SDKs
Real-time SSE streaming
Relay proxy
Approval workflows
Audit logs with diffs
Entity inspector
Stale flag scanner
Flag scheduling
Environment comparison
Unlimited evaluations
No per-seat pricing

Data based on publicly available documentation as of April 2026.

See every feature in action

Start FreeQuickstart Guide