Flagward separates deploying code from releasing it. Your SDK downloads the rules once and evaluates them inside your process in under a millisecond — and when you flip a flag, the change streams to every connected client over SSE.
app.flagward.com · free to try · no card
Flagward · production
livenew-checkout
Boolean · one-page checkout
checkout-cta
Multivariate · call to action
Change anything here. The app renders the new value in the same frame — nothing was fetched.
Express checkout
One page. One tap.
Rendered from a locally evaluated flag — no request was made.
That is not a video. Flip the switch — the checkout on the right is reading the flag you just changed.
Most teams are forced to make them at the same moment. That single coupling is what turns a launch into a deploy window and a bug into an incident.
The feature goes live when the pipeline finishes. Timing a launch means timing a merge, and a rollback means another deploy.
With Flagward
Merge whenever the code is ready. Release by flipping a switch, at the moment you choose.
Something breaks in production. Revert, rebuild, redeploy — and hope nothing else rode along in that commit.
With Flagward
Force the flag off. The override bypasses every rule, reaches connected clients immediately, and lands in the audit trail with its reason.
A flag service you call over HTTP puts the network on your render path — and takes your app down with it when it is unreachable.
With Flagward
Rules are downloaded once and evaluated in your process. A check costs nothing, works offline, and the user's context never leaves the client.
Flagward is a control plane, not a dependency in your request path. The rules travel to your process once; after that, an evaluation is a function call.
In the dashboard, inside a project and an environment. You pick the key — it is the exact string your code will pass to useFlag.
key: "new-checkout"Once, on init, authenticated with the environment's API key. One key scopes the SDK to one environment and nothing else.
GET /api/v1/sdk/flags/The evaluator runs in your process against the context you pass. No network on the render path, and no user attributes leaving the client.
useFlag("new-checkout") → trueFlip a flag, adjust a rollout or pull the kill switch, and the new snapshot is pushed to every connected SDK over SSE.
event: flags.updatedOne trade-off, stated plainly. In a browser, local evaluation means the rules travel to the client — anyone can open devtools and read that you target plan == "enterprise". Do not put a secret in a targeting rule. When the rules themselves must stay server-side, Flagward also exposes remote evaluation via POST /api/v1/sdk/evaluate/.
This is a real evaluator running in your browser with Flagward's rules. Change the state, the targeting, the rollout percentage or the override, and watch who the flag resolves to — and why.
Flag state
The configured on/off switch for this environment.
Targeting rule
plan in "pro,enterprise"
Rollout
60%Each user gets a stable bucket from their id, so raising the percentage only ever adds people.
Kill switch
Forces the value and bypasses every rule.
Evaluate as
Checkout — step 2 of 3
Payment details
Two more steps before the order is placed.
Rendered from a locally evaluated flag — no request was made.
Evaluation · Bruno
ROLLOUT_EXCLUDEDuseFlag("new-checkout") → false
Matched "Paid plans, gradual rollout" but bucket 97 is outside the 60% rollout
SDK trace
Waiting — change a control to see an evaluation.
Every value on screen — the variant, the reason, the bucket — comes straight out of the evaluation. Nothing here is scripted.
Flagward is deliberately small: a control plane for flags, a fast local evaluator, and enough visibility to know what your users are actually being served.
Rules are evaluated in your process, not over HTTP. A flag check never blocks on the network and keeps working when Flagward is unreachable.
Every change streams to connected SDKs over SSE. No polling interval to tune, no waiting for a cache to expire.
Force a flag on or off during an incident. The override bypasses every rule, records its reason, and lifting it restores the exact configuration you had.
Boolean and multivariate flags, strategy rules built from attribute conditions, and percentage rollouts on stable per-user buckets.
Each environment carries its own API key, and a key scopes an SDK to that environment and nothing else.
Multi-tenant from the model up. Access comes from memberships only — a foreign row answers 404, superuser or not.
Connected SDKs, evaluation volume, the evaluation log and the full override trail, all on one page.
Django, Redis and Postgres, one docker compose up away. MIT licensed, and your flag data stays on your infrastructure.
Every adapter carries the same evaluator, so a rule resolves identically whichever you use — and an adapter re-exports the core, so you install one package, not two.
npm install @flagward/reactReact 18+. Authenticate with the environment's API key from the dashboard — a key scopes the SDK to one environment and nothing else.
Source: basb7/flagward-sdk-js →import { FlagwardProvider, useFlag } from "@flagward/react";
function App() {
return (
<FlagwardProvider apiKey={process.env.NEXT_PUBLIC_FLAGWARD_KEY} host="https://app.flagward.com">
<Checkout />
</FlagwardProvider>
);
}
function Checkout() {
const { value, isLoading } = useFlag("new-checkout");
// `value` is undefined until the first snapshot arrives, and stays
// undefined for a key this environment does not have.
if (isLoading) return <LegacyCheckout />;
return value ? <NewCheckout /> : <LegacyCheckout />;
}Flagward is open source and self-hostable by design. The hosted dashboard is the same software with the operations taken off your plate.
Flagward ships with development defaults so it runs out of the box. They are not safe for a deployment — read SECURITY.md before exposing an instance.
git clone https://github.com/basb7/flagward.git
cd flagward
docker compose up
# Dashboard http://localhost:3000
# API http://localhost:8000Create an organization, add a project and an environment, and wrap your first component. The flag you create in the dashboard is readable from your app on the same afternoon.