How it works

The API is never in the read path

Most feature flag services put a server in front of every flag check. Switchbox doesn't. Your flags are published as a static JSON file on Cloudflare's edge, and your app's SDK reads it from there, then evaluates locally.

WriteOn every save

Dashboard

You toggle a flag

Switchbox API

Writes DB, builds JSON

Cloudflare edge

Static flags.json

ReadEvery flag check in your app

Cloudflare edge

Polled every ~30s

SDK in your app

Caches the config

Local evaluation

Sub-millisecond

Notice the API is only in the write lane. Reads are served from Cloudflare's edge, so your app keeps working even if our entire backend is down.

The write path

When you toggle a flag, change a rule, or edit a value, the API does two things: it writes the change to its database (the source of truth), then regenerates the entire config for that environment as a JSON file and uploads it to the edge. There's no separate publish button, saving is publishing.

The read path

Your app's SDK fetches that JSON once and caches it in memory. Every enabled() or getValue() call evaluates the rules and rollout locally, in-process. A background poller re-fetches every ~30 seconds, so a dashboard change reaches your app within one interval, without our API ever being in the request.

Try it

Configure, publish, evaluate

Set up a flag in the dashboard. It becomes JSON on the edge. Your app reads it instantly.

DashboardInteractive
new_checkout
boolean
Rules
Otherwise
Rollout25%
Published to edgecdn.switchbox.dev
flags.jsonCDN
{
  "version": "2026-03-10T12:00:00Z",
  "flags": {
    "new_checkout": {
      "enabled": true,
      "rollout_pct": 25,
      "default_value": false,
      "rules": [
        {
          "attribute": "email",
          "operator": "ends_with",
          "value": "@company.com"
        }
      ]
    }
  }
}
app.pyYour app
from switchbox import Switchbox


client = Switchbox(sdk_key="your-sdk-key")


user = {"user_id": "42", "email": "[email protected]"}


if client.enabled("new_checkout", user):
    show_new_checkout()
$ python app.pystdout
client.enabled(...) → True
# matched rule: email ends_with @company.com
show_new_checkout()

Install the SDK and you're live.

View on GitHub
$pip install switchbox-flags
Read the Python quickstart

No black box

This is the whole thing your SDK reads

A static JSON file per environment, served by its SDK key. You can curl it yourself. The SDK that evaluates it is open source and zero-dependency, so there's nothing you can't read.

flags.json · on the edge
{
  "version": "2026-07-11T12:00:00Z",
  "flags": {
    "new_checkout": {
      "enabled": true,
      "rollout_pct": 30,
      "flag_type": "boolean",
      "default_value": false
    }
  }
}
app.py · your backend
from switchbox import Switchbox


client = Switchbox(sdk_key="your-sdk-key")


# Reads the edge JSON, evaluates locally.
# No network call to our API.
if client.enabled("new_checkout", user={"user_id": user.id}):
    show_new_checkout()

What that one decision buys you

Every strength below is a direct consequence of keeping reads off our servers, and so is the one cost.

Fail-safe

Our API can be down and your flags keep serving from the edge. If the SDK has ever fetched a config, it keeps evaluating against the last good one.

No added latency

Flag checks are local and sub-millisecond. There's no per-request round-trip to us, so a flag check can never slow your app down.

CDN-scale reads

Read traffic is static-file GETs on Cloudflare's edge, not database queries, so it scales the way a CDN does, not the way a server does.

Private by design

The SDK evaluates against your user data in-process. Nothing about who saw what is ever sent back to us.

The cost: ~30 seconds to propagate

Because delivery is poll-based, a change isn't instant. A toggle takes up to your poll interval (~30s by default) to reach every running client. For rollouts, kill switches, and targeting that's imperceptible. If you need a hard guarantee a value has propagated, wait one interval before depending on it.

Resilient by design

Kill the backend. Your flags keep serving.

Switchbox is never in your read path. Kill our API, the database, the whole backend, and your flags keep serving from Cloudflare's edge.

See it for yourself

Create a team, add a flag, and read it from your app in minutes. The deeper mechanics live in the docs.

Get startedRead the docsView the SDK