The best remote config services for 2026: an honest comparison

If you want to change how your application behaves — a rate limit, a cache TTL, a model name, a price — without deploying anything, the category you’re shopping in is called remote config. Its center of gravity is Firebase Remote Config, which taught a generation of mobile developers that changing a button color shouldn’t cost a week in App Store review. The rest of the industry has since come around to the idea that backends deserve the same courtesy, and there’s now a real field of services competing for the job.

Two names to rule out before we start, because the search terrain here is genuinely bad. “Configuration management” belongs to Ansible, Puppet, and the CMDB people — that’s provisioning servers, a different universe that happens to share a noun. And secrets managers like Doppler and Vault are the adjacent-but-different case: they hand your process credentials when it starts. Remote config is about values your application reads while it runs, from a service that can change them while it runs.

Full disclosure: I build one of the services on this list: Smpl Config. I’ve put it where I think it belongs and said where the others are stronger.

The two kinds of “remote config”

Platform config: a feature of a cloud you already pay for

AWS AppConfig, Azure App Configuration, and Firebase Remote Config live here. Nobody signs up for AWS to get AppConfig; you reach for it because your workloads are already there and the IAM roles are already wired. These services inherit their platform’s strengths — billing, permissions, compliance — and also its assumptions: polling, per-request metering, and identity handled by the mothership.

Independent config services

ConfigCat, Flagsmith, LaunchDarkly, Reforge Launch, Smpl Config, and Statsig live here. They’re cloud-neutral, SDK-first, and you choose them on purpose. Most grew up as feature-flag platforms and added config values along the way; a couple treat config as the headline product. The differences hide in the value model — whether “config” means a typed value, a JSON blob, or a flag wearing a trench coat.

One boundary case worth naming: Doppler shows up in this category’s search results, and its data model literally calls things “configs.” It’s a secrets manager — a good one — and it delivers values as environment variables when your process launches. To pick up a change, you restart the process. That’s the exact thing remote config exists to avoid, and Doppler, to its credit, never claims otherwise. If your problem is credentials, use Doppler. If your problem is runtime behavior, keep reading.

The field at a glance

Service	Type	Typed values	Targeting	Push updates	Audit & history	Free tier
AWS AppConfig	Platform	⚠︎ Flags only	⚠︎ Flags only	✗	⚠︎ CloudTrail	✗ None
Azure App Configuration	Platform	✗	⚠︎ Flags only	⚠︎ DIY	✓	1K req/day
ConfigCat	Independent	⚠︎ No JSON type	✓	✗	✓	10 settings
Firebase Remote Config	Platform	⚠︎ Console only	✓	⚠︎ Clients only	⚠︎ 300 versions	100K fetch/day
Flagsmith	Independent	✓	✓	⚠︎ Enterprise	⚠︎ Scale-Up+	50K req/mo
LaunchDarkly	Independent	✓	✓	✓	⚠︎ Flag-level	1 proj, 3 envs
Reforge Launch	Independent	✓	✓	✓	✓	5 servers
Smpl Config	Independent	✓	✗	✓	⚠︎ Standard+	10 configs
Statsig	Independent	⚠︎ JSON blob	✓	⚠︎ Proxy only	✓	Unlimited checks

✓ first-class support  ·  ✗ build it yourself

Propagation: how a change actually reaches your process

Every service here agrees on the goal — new value, no deploy — and splits on the mechanics. Pollers fetch on a timer: simple, cache-friendly, and your freshness is your interval. Streamers hold a connection open (SSE or WebSocket) and push the change when it happens. Neither is virtuous by itself; a 10-second poll beats a stream that reconnects badly. But the defaults tell you who a product was built for.

Firebase’s default minimum fetch interval on client SDKs is 12 hours. That’s the right default for a hundred million phones and a surprising one for a server — which is why the real-time listener exists to bypass it, on clients. Firebase’s server-side answer is re-downloading the template on a timer you write yourself. At the other end, LaunchDarkly, Reforge Launch, and Smpl Config hold connections open and push changes to running server processes. Statsig’s server SDKs poll every 10 seconds, which is honest and fine. AWS bills you for every poll, which at least concentrates the mind.

A note on speed: vendors’ propagation numbers are claims, and this article reports them as claims. Measuring is a habit around here — we run a live scheduler-latency benchmark — but nobody is independently clocking config propagation across vendors yet, including us.

Service	Delivery	Default freshness	Push reaches
AWS AppConfig	Poll	Whatever interval you poll at	Nowhere
Azure App Configuration	Poll (sentinel key)	~30 seconds in Microsoft's own examples	.NET/Spring via Event Grid wiring
ConfigCat	Poll (CDN)	60 seconds	Nowhere
Firebase Remote Config	Stream + poll	12 hours on clients by default; the real-time listener bypasses it	Clients only
Flagsmith	Poll; SSE on Enterprise	60 seconds (local evaluation)	Enterprise plans
LaunchDarkly	Stream (SSE)	On change	Servers and clients
Reforge Launch	Stream (SSE)	On change	Servers and clients
Smpl Config	Stream (WebSocket)	On change	Servers
Statsig	Poll	10 seconds (server SDKs)	Self-hosted proxy only

Category 1: platform config

AWS AppConfig

AWS AppConfig treats a config change the way the rest of AWS treats a code change: as a deployment. You pick a strategy — grow 20% of targets at a time, bake for a while, watch a CloudWatch alarm — and a bad value rolls itself back before it finishes shipping. That’s the personality of the product, and it’s a good one. Feature-flag profiles get typed attributes with real constraints (regex, ranges, enums); freeform configs are JSON, YAML, or text documents the service doesn’t look inside. Retrieval is polling, usually through an agent you run beside your code, and every poll is billed: 20 cents per million requests plus 80 cents per thousand configurations delivered. AWS’s own pricing example — 2,000 servers polling every two minutes — works out to $152.64 a month. There’s no free tier and no push. Best when you’re already on AWS and the thing you fear is a bad config change, not the polling bill.

Azure App Configuration

Azure App Configuration is a centralized key-value store with real operational maturity: 30-day revision history with point-in-time restore, snapshots, soft delete, geo-replication, and a flat bill — the Standard tier is $1.20 per store per day, about $36 a month, with 200,000 requests a day included. Values are strings. All of them. A contentType field can remind you that a string is secretly JSON, but nothing enforces it; typing is your application’s problem. Environments are done with labels, and permissions are store-scoped, so the documented answer to keeping staging hands off production is a separate store per environment — each with its own daily charge. Refresh is polling against a sentinel key, roughly every 30 seconds in Microsoft’s examples; a push mode exists for .NET and Spring via Event Grid, and the Spring docs file it under “not recommended.” Best for .NET and Java shops on Azure that want boring, durable, centrally managed config and don’t need typed values or user targeting.

Firebase Remote Config

Firebase Remote Config is the category’s center of gravity for a reason. If your surface is a mobile app, the targeting is superb: conditions across 18 rule types, Google Analytics audiences, ML-driven per-user personalization, A/B testing wired straight into Analytics, and real-time streaming updates on every client platform — iOS, Android, Web, Flutter, Unity, C++. Parameters carry a declared type in the console, but it’s validated at publish time, not enforced at retrieval; your get call does the casting. Server-side is a different story: officially a Preview, limited to the Admin SDKs in Node.js, Python, Go, and Java, with no streaming — you re-download the template on a timer. There’s no environments concept either; Google’s guidance for dev/staging/prod is three separate Firebase projects, promoted by hand. Version history caps at 300 lifetime versions and there are no approvals — anyone with console access ships to production. And the free lunch is ending: from September 1, 2026, fetches beyond 100,000 a day bill at six cents per 10,000. Best when you’re building a mobile app, which is exactly what it’s for.

Category 2: independent config services

ConfigCat

ConfigCat sells flags and config as one product with one refreshingly flat idea: every feature on every plan — unlimited seats everywhere, SAML included on the free tier — and plans differ only in quotas. Settings are typed (boolean, string, integer, double) with targeting rules and percentage rollouts on any custom user attribute, served from a CDN your SDK polls every 60 seconds by default, with SDKs for 17 platforms and a proper offline/override story. There’s no JSON setting type; since July 2026 a text setting can be required to validate as JSON, which is most of the way there as long as your app does the parsing. The free tier’s 10 settings go quickly if you’re doing config rather than a handful of flags; Pro is $110 a month ($95 billed annually) for 100 settings and three environments. Scheduled changes still aren’t native — ConfigCat’s own blog suggests the public API plus cron, and if you go that route we have opinions about cron services. Best when you want flags-plus-config economics an entire team can log into without a seat-count negotiation.

Flagsmith

Flagsmith has the richest value model among the flag-first products here: a flag carries an on/off state plus a typed value — string, number, boolean, or JSON — with multivariate variants and segment targeting on identity traits. It’s also the one open-source option in this lineup (BSD-3-Clause, self-hosted via Docker Compose), which is the sturdiest possible answer to “what happens if the config service goes away.” The SaaS tiers claw a fair amount back, though: real-time SSE updates require an Enterprise plan, audit logs arrive with Scale-Up governance at $300 a month, and as of this writing the pricing page says scheduled flags come with Start-Up while the docs say Scale-Up and Enterprise. We’ll let them settle it. Free is 50,000 requests a month with one seat; Start-Up is $45 a month for a million requests and three seats. Best when open source or self-hosting is a requirement — just check that the features you need aren’t gated two tiers up.

LaunchDarkly

LaunchDarkly is the enterprise flag platform, and its remote-config story is the flag model stretched to fit: a “config” is a multivariate flag serving string, number, or JSON variations. Delivery is excellent — streaming is the default, SDKs cover 13 server-side platforms plus clients and edge runtimes, and a Relay Proxy runs in your own infrastructure if you want it. The constraint is the variation model itself: variations are a predefined set with the type locked at flag creation, so “serve a new value” means editing a named variation in the dashboard rather than writing an arbitrary value to a key. The new thing this year is AI Configs, now GA under the AgentControl banner — runtime control of prompts and model settings, billed per AI run. It’s the closest LaunchDarkly has come to a dedicated config product, and it’s for AI workloads specifically. The Developer tier is free with one project, three environments, and 14-day data retention; Foundation runs $10 per service connection plus $8.33 per thousand client-side MAU, billed yearly. Per-flag change history is included broadly, but the full audit log, approvals, and scheduling are Enterprise features. Best when you’re buying a flag platform for a large organization and config can live inside it as JSON variations.

Reforge Launch (formerly Prefab)

The product formerly known as Prefab is the closest thing this lineup has to another config-first platform, and it’s had an eventful stretch: acquired by Reforge in late 2024 and relaunched as Reforge Launch, with the docs now at docs.reforge.com — while the old prefab.cloud homepage redirects to Quonfig, the Prefab founder’s new product. The product underneath survived the move intact. Config values are properly typed — string, int, double, boolean, JSON, plus exotics like duration — with per-environment values that can explicitly inherit the default, SSE push to running server SDKs, and two genuinely useful bundled extras: dynamic log levels and secrets. SDKs cover Ruby, Java, Node.js, Python, Go, and JavaScript/React; there’s no .NET. Pricing, per the page still published at the old domain: free for up to 5 servers and around 1.5 million requests a month; Pro at $99 a month for up to 100 servers and 15 million requests. Best when you want typed config with push and dynamic logging in one tool, and .NET isn’t in your stack.

Smpl Config

Smpl Config is built around an idea the rest of this lineup skips: real inheritance. A config can declare a parent; inherited keys resolve through the chain and locally declared keys shadow them — so “every service gets these defaults, this one overrides two of them” is a data-model feature instead of a copy-paste convention. (Reforge Launch’s per-environment [inherit] is the nearest neighbor, on a different axis.) Values are typed — string, number, boolean, JSON — and the API enforces the type on every write, including per-environment overrides. The SDKs work code-first: declare defaults in code, bind() them, and the keys surface in the console for someone to override, with changes streaming back over WebSocket into the running process. Six SDK languages, a CLI, and a Terraform provider come with every tier, alongside unlimited servers and API requests; the free tier covers 10 configs of 25 keys each across two environments. Now the honest part: there’s no user-level targeting — configs vary by environment, and per-user rules are Smpl Flags’ job. Change history starts on the $49 Standard tier, point-in-time restore on the $99 Pro tier, and per-environment write permissions are an Enterprise feature. If typed, inherited, push-updated config is the actual job you’re hiring for, it belongs on your shortlist.

Statsig (Dynamic Config)

Statsig’s Dynamic Config is a JSON object served through the same rule engine that powers its feature gates and experiments: target by user ID, email, country, app version, custom fields, or segments, with gradual rollouts. Typing is client-side discipline — getters take a fallback, and a fallback of the wrong type wins over the stored value, which is a sensible guard but not a schema. Server SDKs poll every 10 seconds; push requires self-hosting their Forward Proxy. Configs cap at 100 KB, audit logs are kept indefinitely, and approval policies are an Enterprise feature. The free tier is remarkable for this use case: config checks are unmetered on every plan — the billing meter is analytics events — so a config-heavy, experiment-light team rides free for a long time. Ownership has been busy: OpenAI acquired Statsig in September 2025, and in May 2026 the brand, platform, and customers moved to Amplitude while the founding team stayed at OpenAI. The product is live and taking signups; the roadmap is now Amplitude’s. Best when you’re running experiments anyway — it’s an experimentation platform, and Dynamic Config is one of its instruments.

Which should you pick?

If you’re building a mobile app, use Firebase Remote Config and don’t overthink it — the targeting, the A/B testing, and the price were built for exactly you. Just note the September 2026 pricing change if your fleet is large.

If you’re already on AWS or Azure, the house option is a fine default. AppConfig is the pick when what you fear is a bad config change, since it treats a config push like a production deployment. Azure App Configuration is the boring, durable, flat-rate choice for .NET and Java shops that can live with every value being a string.

Among the independents: if open source or self-hosting matters, it’s Flagsmith. If you want the most product for the fewest procurement meetings, ConfigCat’s everything-on-every-plan model with unlimited seats is hard to argue with. If you’re a large organization standardizing on a flag platform, LaunchDarkly is the incumbent for a reason, and config rides along as JSON variations. If your team is experimentation-led, Statsig’s unmetered config checks make it nearly free for this particular job.

And if config itself is the product you’re shopping for — typed values, inheritance, push updates, config as a first-class thing rather than a flag with a payload — the two candidates in this lineup are Reforge Launch and Smpl Config. Reforge Launch bundles dynamic log levels and secrets; Smpl Config brings config-to-config inheritance, code-first registration, and unlimited servers on the free tier. Pick by your stack and by which of those extras you’ll actually use.