v0.2.0-rc.11 • Single-Binary Remote Config & Feature Flags

Real-Time Remote Config
Without the Overhead.

Outperform Firebase Remote Config restrictions and eliminate Flipt infrastructure complexity. Sub-millisecond flag evaluation, instantaneous SSE streaming, deterministic A/B experiments, and high-throughput analytics in one single, lightweight Go binary.

Install with Docker Read the Documentation
ConfigWire Admin Dashboard Interface for real-time remote configuration and feature flags
< 0.8ms
p95 Fetch Latency
1 Binary
Zero External DBs
< 1 sec
Realtime SSE Push
50 RPS
Ingest Gate (per-key, k6-verified)
Comparison

Built to Outperform the Alternatives

Why engineering teams choose ConfigWire over steep SaaS pricing, cloud vendor lock-in, and multi-service complexity — including an honest look at where ConfigWire is not (yet) the right fit.

Feature ConfigWire LaunchDarkly Unleash ConfigCat Firebase Remote Config Flipt
Architecture ✓ Single Go binary + embedded SQLite WAL ✗ Closed-source cloud SaaS only ⚠ Multi-tier (Node.js + PostgreSQL + Proxy) ✗ Hosted SaaS only (Cloud CDN based) ⚠ Proprietary GCP cloud lock-in ✗ Multi-service (Requires Postgres/MySQL + Redis)
DevOps & Memory Footprint ✓ Zero external DBs, ~25MB binary, < 30MB RAM ($4/mo VPS) ✗ SaaS only (Relay Proxy requires dedicated container) ⚠ Multi-container: Node.js + PostgreSQL + Proxy (~500MB-1GB RAM) ✗ SaaS only (No self-hosted option) ✗ Closed GCP cloud vendor lock-in ⚠ Multi-container: Go + Postgres + Redis (~300MB-600MB RAM)
Fetch Latency (p95) ✓ 0.78ms (verified via k6 baseline) ⚠ 25ms - 100ms (cloud CDN / Relay Proxy) ⚠ 10ms - 40ms (Node.js API / Edge Proxy) ⚠ 20ms - 80ms (global CDN edge fetch) ✗ 80ms - 400ms (GCP network hops & cold starts) ⚠ 15ms - 50ms (external DB queries)
Real-Time Updates ✓ Instant SSE Stream + 15m polling fallback ✓ Instant SSE streaming ⚠ Polling default (Edge proxy or custom SSE) ⚠ Polling-based (default 60s auto-poll) ✗ 12-hour client throttle default (complex listeners) ⚠ Client-side polling or heavyweight gRPC
Network & Bandwidth Efficiency ✓ Cryptographic ETag (304 Not Modified, 0-byte body) + small SSE config_update frame only on publish ✓ Persistent streaming connection + CDN caching ⚠ Polling consumes repetitive network requests ✓ CDN edge 304 ETag polling ✗ Heavyweight REST requests; aggressive throttling to prevent quota burn ⚠ Standard JSON evaluation payload on every request
Evaluation Privacy & Rule Security ✓ 100% Server-side (Rules never leak to client; minimal payload) ⚠ Client-side or Relay Proxy (Flags evaluated on server/proxy for client SDKs) ⚠ Client-side evaluation (Requires Unleash Proxy to avoid exposing targeting rules) ✗ Client-side evaluation (Downloads entire targeting ruleset to end-user client) ✓ Server-side evaluation against client context ✓ Server-side evaluation via HTTP/gRPC API
Supported Data Types ✓ Boolean, String, Number (Int/Float), JSON Objects & Arrays ✓ Boolean, String, Number, JSON ⚠ Boolean toggles (JSON/String only via variant payloads) ✓ Boolean, String, Int, Double, JSON ✗ Strings only (client casts to Bool/Number/JSON at runtime) ⚠ Boolean & String variants (optional JSON attachment)
Advanced Targeting & SemVer ✓ Native SemVer (<, <=, >, >=), regex, custom attributes, deterministic hashing ✓ Comprehensive rule builder, segments, SemVer, percentage rollouts ✓ Strategy constraints, custom stickiness, segments ✓ Targeting rules, SemVer comparison, percentage rollouts ⚠ Basic condition builder (app version strings, country, GA user properties) ✓ Segment constraints, rollout distributions, entity context
Environment Promotion & Governance ✓ 1-click snapshot promotion & atomic release rollbacks built into single binary ⚠ Supported (Workflows & approvals locked behind Enterprise tier) ⚠ Change requests & environment promotion locked behind Enterprise paywall ✗ Manual tag/config replication across environments (no native promotion pipeline) ✗ Not supported (Requires maintaining completely separate GCP projects) ⚠ External GitOps or custom CLI sync scripts required
Client Footprint ✓ Pure Dart SDK (Flutter, Dart VM, Web, Server) ⚠ Heavyweight proprietary SDKs & large dependencies ⚠ Separate client SDK + edge proxy setup ✓ Lightweight open-source SDKs ✗ Massive Firebase Core & Google Play dependencies ⚠ Multi-megabyte foreign language bindings
A/B Experiments & Stats ✓ Built-in exposure ingest + 90-day rollups ⚠ Expensive add-on experimentation tier ⚠ Limited impressions (advanced stats in Enterprise) ✗ No native stats (requires 3rd-party analytics) ✗ Tied to Google Analytics & expensive BigQuery export ⚠ Basic evaluation without built-in analytics
Cache Architecture ✓ Bring-Your-Own CacheStore seam (Memory or Disk) ⚠ Proprietary SDK in-memory / plugin caches ⚠ In-memory or custom storage provider ✓ Pluggable custom cache interface ⚠ Fixed internal blackbox local storage ⚠ Requires external memory store
Data Privacy & Security ✓ 100% On-Premise, bucket-only ?b= (no raw PII; userId ignored, ip rejected) ⚠ SaaS data exposure (relies on Relay Proxy for private nets) ✓ Self-hosted open source (full data sovereignty) ⚠ Hosted SaaS; configurations stored in cloud ✗ User telemetry shared with Google advertising network ✓ Self-hosted open source
Hosting / License Cost ✓ Free forever (MIT), runs on $4/mo VPS ✗ Cost-prohibitive ($$$$/mo enterprise seats & MAU tiers) ⚠ Free OSS basic; $80+/seat/mo for enterprise features ⚠ Free tier limited (10 configs); $99-$499+/mo plans ✗ Scales unpredictably with monthly active users ⚠ Costly multi-node database clusters
Scale Model ⚠ Single-node SQLite (WAL) — vertical scale only, no clustering or read replicas ✓ Elastic multi-region SaaS scale ✓ Scales horizontally (self-hosted Postgres/Redis) ✓ Global CDN edge scale ✓ Planet-scale GCP infrastructure ⚠ Scales with external DB (you operate the cluster)
SDK & Platform Breadth ⚠ Dart/Flutter-first SDK (other stacks via plain HTTPS/SSE, no native SDKs yet) ✓ Broad official SDK coverage across stacks ✓ Official SDKs for all major stacks ✓ SDKs for all major stacks ✓ First-party mobile & web SDKs ✓ Client SDKs for major languages (gRPC-first)
Governance: RBAC, Approvals & Audit Trail ⚠ Single superuser role; instant publish, no approval flows or per-user audit trail ✓ RBAC, approval workflows & audit log ✓ RBAC + change requests (Enterprise) ⚠ Team management on paid tiers; no approval pipelines ⚠ GCP IAM roles, no flag approval workflow ⚠ Basic auth; audit via GitOps trail
Experimentation Depth ⚠ Counts, rates & per-variant breakdowns; no significance testing ✓ Experimentation with stats engine (paid add-on) ⚠ Impression data; advanced stats in Enterprise ✗ No native experimentation (integrate analytics) ✓ A/B Testing with statistical significance ⚠ Evaluation-only; analytics via external integrations
Maturity & Compliance ⚠ Young OSS project (v0.2.x); no SOC 2/ISO certs; community support ✓ SOC 2 Type II, SLA & enterprise support ✓ SOC 2 (Enterprise) & commercial support ⚠ Long-running SaaS vendor; enterprise terms on paid tiers ✓ Google Cloud compliance & SLA ⚠ Growing OSS community; no compliance certs
vs Firebase

Zero Throttles & No Lock-in

Firebase Remote Config enforces a strict 12-hour fetch throttle by default, forcing workarounds during rollouts. ConfigWire pairs instant HTTP Server-Sent Events (SSE) with cryptographic ETag conditional refreshes (304), delivering updates in milliseconds without exceeding quota.

vs LaunchDarkly

Zero Per-Seat SaaS Tax

LaunchDarkly bills enterprise rates per seat and monthly active user (MAU), quickly reaching thousands per month and forcing flag rationing. ConfigWire is 100% open-source (MIT), running on a $4/mo VPS with unlimited seats, flags, and environments.

vs Unleash

Zero Multi-Tier Paywalls

Unleash gates advanced targeting, single sign-on, and audit logs behind expensive enterprise tiers and requires managing Node.js and PostgreSQL. ConfigWire ships exposure ingest, 90-day rollups, and rule evaluation in a single zero-dependency binary.

vs ConfigCat

Instant Push & Unlimited Flags

ConfigCat caps free plans at 10 configs and relies heavily on polling intervals (defaulting to 60 seconds). ConfigWire provides sub-second SSE streaming, instant rollout propagation, and unlimited configuration flags on your own private infrastructure.

vs Flipt

One File Instead of a Cluster

Flipt requires orchestrating PostgreSQL, Redis caches, and separate worker containers. ConfigWire compiles into a single Go binary with embedded SQLite in WAL mode. Zero network roundtrips between the app and its database, delivering 0.78ms p95 response times.

Client Freedom

Pure Dart & Pluggable Cache

Unlike vendor SDKs that pull in heavyweight native Google Play services or foreign language wrappers, ConfigWire's client is 100% pure Dart. It runs seamlessly across Flutter, desktop, web, Dart VM, and backend servers with pluggable CacheStore adapters.

Deployment

Up and Running in 60 Seconds

Deploy via Docker, then create your superuser account directly inside ConfigWire's native homepage. 

# Run ConfigWire with persistent storage and automatic healthcheck
docker run -d \
  --name configwire \
  --restart unless-stopped \
  -p 8090:8090 \
  -v cw-data:/app/pb_data \
  ghcr.io/configwire/configwire:latest

# Verify instance is ready
curl -s http://localhost:8090/healthz
# -> {"status":"ok"}
First-Run Experience

Create Super Account via Homepage

No need to navigate to PocketBase's underlying /_/ installer! ConfigWire features its own native first-run onboarding right on the homepage:

1

Open ConfigWire in Your Browser

Navigate directly to http://localhost:8090/.

2

Native Superuser Setup Screen

ConfigWire detects fresh deployment via GET /api/v1/admin/setup/status and presents the root administrator creation modal.

3

Create Your Credentials

Provide your admin email and password. ConfigWire creates your account via POST /api/v1/admin/setup and transitions directly to your dashboard.

Prefer no browser? Set CONFIGWIRE_ADMIN_EMAIL + CONFIGWIRE_ADMIN_PASSWORD before first boot to auto-create the account and skip this screen.

Code Integration

Unified Developer Experience

Evaluate flags, roll out A/B experiments, and stream real-time updates using either your command line or the official Dart SDK.

1. Simple Fetch & 304 Cache

Fetch flag values with sub-millisecond latency. Send If-None-Match to receive 304 Not Modified when configuration has not changed. Canonical /api/v1/config (env resolves from the key); the env path is backward-compatible.

fetch.sh 
# Fetch live values
curl -s http://localhost:8090/api/v1/env/dev/config \
  -H "X-ConfigWire-Key: cw-YourKey123"

# Response:
{
  "version": 1,
  "etag": "5dadac695eb4c603",
  "values": { "launch_flag": true }
}

# 304 Conditional Check
curl -sI http://localhost:8090/api/v1/env/dev/config \
  -H "X-ConfigWire-Key: cw-YourKey123" \
  -H "If-None-Match: 5dadac695eb4c603"
# -> HTTP/1.1 304 Not Modified

2. Variants & Experiments

v0.2.0-rc.11 (released 2026-11-04) is bucket-only (since v0.2.0-rc.1). Pin a stable bucket with ?b=0-9999 — bucketing rides fnv64a(?b= + seed) % 10000 (valid wins; absent/empty never rejected — fetch mints, ingest stores ""). Server-derived anonID derivation no longer exists (no daily salt rotation, no rebucket) and SDKs no longer emit ?userHash=; legacy ?userHash=/?uid=/?country= plus body userHash and event-body userId (any case) are accepted-but-ignored, never stored/logged. Pass targeting context via attrs. Canonical /api/v1/events (env resolves from the key); the env path is backward-compatible. Record exposure events asynchronously to populate A/B statistics.

experiments.sh 
# Fetch targeted variant (stable bucket ?b= pins one install to an arm)
curl -s "http://localhost:8090/api/v1/env/dev/config?b=1234&attrs=%7B%22plan%22%3A%22pro%22%7D" \
  -H "X-ConfigWire-Key: cw-YourKey123"

# Response contains assigned variant arm:
{
  "values": { "checkout_flow": "v2" },
  "variants": { "checkout_flow": "treatment" }
}

# Ingest user exposure event (identity is bucket-only ?b=; body userHash + event userId accepted-but-ignored)
curl -X POST http://localhost:8090/api/v1/env/dev/events \
  -H "X-ConfigWire-Key: cw-YourKey123" \
  -H "Content-Type: application/json" \
  -d '{"events":[{"kind":"exposure","flag":"checkout_flow","variant":"treatment","version":1}]}'
# flag is optional per-flag attribution (absent counts env-wide; fetch events keep flag "")
# -> {"accepted":1,"status":202}

3. Realtime Push (SSE)

Connect directly to Server-Sent Events (SSE). Receive instant update notifications the microsecond a release is published or rolled back. Canonical /api/v1/stream (env resolves from the key); the env path is backward-compatible.

stream.sh 
# Open unbuffered SSE stream
curl -N http://localhost:8090/api/v1/env/dev/stream \
  -H "X-ConfigWire-Key: cw-YourKey123"

# Output stream:
: ping

event: config_update
data: {"version":2,"etag":"1f75363af9defec2","env":"dev"}

: ping
Capabilities

Engineered for Reliability & Scale

Every layer of ConfigWire is built with production durability, performance, and operational simplicity in mind.

Single-Binary Architecture

Deploy anywhere: Linux, macOS, or Docker. Ships as one compact binary with an embedded SQLite database in WAL mode and bundled static admin assets.

Sub-Millisecond Evaluation

Tested under heavy load gates: p95 fetch latency is 0.78ms. In-memory caching and server-side evaluation eliminate database bottlenecks.

Native Realtime Streaming

Server-Sent Events (SSE) push release updates the instant they are published, backed by : ping keepalives every 20s (server closes at 10min; client reconnects with backoff), max 5 concurrent streams per SDK key, and a 15-minute polling fallback.

Immutable Releases & Rollbacks

Releases are cryptographically hashed immutable snapshots. Roll back instant changes in zero lock time with strict baseVersion conflict detection.

Privacy-First Analytics

High-throughput ingest buffer for fetch and exposure events. Bucket-only ?b= identity (v0.2.0-rc.11); raw ip/PII keys stay rejected while event-body userId is accepted-but-ignored, never stored.

Enterprise-Grade Security

Bcrypt-hashed SDK keys, global 200 rps effective (min 200, burst 400 ceiling), fetch 100 / ingest 50 (1..10000), CIDR admin allowlists, and last-admin deletion guards.

FAQ

Frequently Asked Questions

Everything you need to know about ConfigWire's architecture, self-hosting, hosted Cloud plans, comparison with alternatives, and client SDK support.

ConfigWire is a single-binary, self-hosted real-time remote configuration and feature flags engine. Existing solutions force teams to choose between expensive SaaS paywalls (LaunchDarkly charging thousands per month based on MAUs), complex multi-container clusters (Unleash, Flipt requiring Node.js/Go, Postgres, and Redis), or restrictive cloud vendor lock-in (Firebase Remote Config with its 12-hour client throttle). ConfigWire ships as one lightweight Go binary with embedded SQLite WAL, providing sub-millisecond rule evaluation and instant push updates with zero infrastructure baggage.

Firebase Remote Config enforces an aggressive 12-hour client throttle by default and ties your application to Google Cloud Platform, Google Play services, and user tracking. In contrast, ConfigWire delivers instant Server-Sent Events (SSE) push streaming (< 1 second propagation) paired with conditional HTTP 304 ETag responses (0-byte payloads when unchanged). ConfigWire runs on your own infrastructure, supports native JSON payloads, and strictly protects privacy by rejecting raw PII.

LaunchDarkly charges enterprise rates per seat and monthly active user, quickly multiplying infrastructure costs. Unleash locks advanced targeting, change requests, and metrics behind an $80+/seat enterprise tier and requires running Node.js, PostgreSQL, and proxy containers. Flipt requires configuring PostgreSQL, Redis, and multi-service orchestration. ConfigWire compiles into a single ~25MB binary that runs on a $4/month VPS with < 30MB RAM usage, sub-0.8ms p95 latency, and zero tiered paywalls.

No. ConfigWire embeds a highly optimized SQLite database in WAL (Write-Ahead Logging) mode alongside an atomic in-memory cache pointer. All flag evaluation happens in memory on the server with zero database disk I/O on hot evaluation paths, enabling sustained 0.78ms p95 latency under heavy production traffic.

Under rigorous k6 load gates, ConfigWire achieves a p95 fetch latency of 0.78ms. Because targeting rules are evaluated 100% server-side against in-memory snapshots, clients never wait on database transactions, and targeting criteria are never exposed to client bundles.

ConfigWire provides official Dart and Flutter client packages: package:configwire (pure Dart for Flutter, Dart VM, Web, and backend servers) and package:configwire_flutter (automatic persistent caching and device targeting). In addition, ConfigWire exposes a simple, high-performance REST wire contract and Server-Sent Events stream, making it easy to integrate with Go, Node.js, Python, Rust, Swift, Kotlin, or any standard HTTP client.

Both. Self-hosting the MIT-licensed binary is free forever — and if you want zero operations, ConfigWire Cloud gives you a private hosted tenant in seconds, with upgrade or downgrade anytime from the billing portal. Current plans and limits are on the Cloud site.

It runs the exact same binary — Cloud just removes the operations. The orchestrator provisions your tenant, applies HTTPS routing, keeps per-plan resource limits (CPU/RAM/retention) and rate-limit ceilings, and handles backups and suspend/resume. Your flag data stays in your own SQLite volume, fully exportable at any time, so you can move to self-hosting later with a standard backup download.

Yes. ConfigWire is released under the permissive MIT License. It is 100% free for both personal and commercial use with zero restrictions on seat count, active user volume, number of flags, or environments.