Flagship is the feature-flag and progressive-delivery platform for teams that ship constantly. Merge the code, dark-launch it behind a flag, serve it to 1% of traffic, watch the guardrails, then ramp to everyone — or kill it in 200ms — without touching the deploy.
const checkout = flagship.variant("new-checkout", {
user: ctx.user,
rules: [{ segment: "beta", serve: "on" }],
rollout: { on: 5 }, // 5% of everyone else
fallback: "off", // safe if we go dark
});
if (checkout === "on") renderNewCheckout();Release teams ramp every change through Flagship
Stop binding 'it's deployed' to 'it's live.' Flagship gives every team one place to gate, target, measure, and reverse any change already running in production.
Move a release from 1% to 100% on a slider or a schedule. Sticky bucketing pins each user to one variant across sessions, devices, and replicas — no flicker between visits.
A bad release is one toggle from gone. The off state reaches every edge node and connected SDK in under 200 milliseconds, worldwide — no deploy in the loop.
Serve variants by plan, region, account, app version, or any attribute you stream in. Compose rules in a no-code builder; every one is versioned and diffable underneath.
Bind error rate, latency, and conversion to each rollout. The moment a variant regresses past your threshold, Flagship halts the ramp and pages the owner — before the blast radius grows.
Who flipped which flag, for whom, from what value, and when. Every change is logged, diffable, and reversible to any point in the timeline.
What progressive delivery looks like in production
Typed SDKs, in-process evaluation, and a sandbox that mirrors production. Wrap a flag in one line and trust it under load.
SDKs evaluate flags in-process from a ruleset streamed to memory. Zero network call on the hot path, zero added latency per request — sub-millisecond median.
First-class, fully typed SDKs for TypeScript, Go, Python, Rust, Swift, and Kotlin. Your editor knows every variant and its return type before you ship.
Define, review, and promote flags through pull requests with our Terraform provider and GitHub Action. Production state never drifts from main.
Flagship scans your repo, finds the toggles you shipped and forgot, and opens the PR that removes them and their dead branch. Tech debt that retires itself.
The same flag carries a change through its whole life. No second tool to learn at each stage.
Serve the change to your own team and a named beta segment while everyone else stays on the old path. Real feedback before a single customer is in the blast radius.
Release to 1% of traffic with guardrails watching error rate and latency live. Catch the regression at 1% and auto-halt — never discover it at 100%.
Split traffic across variants and read statistically sound lift on the metrics you actually report — a built-in sequential test calls the winner without you waiting on a fixed sample.
Promote to everyone, archive the flag, and let Flagship open the PR that deletes the dead code path so the win doesn't leave a mess behind.
“We went from two release windows a week to shipping forty times a day. Every risky change rides a flag, so 'deploy' stopped being the word that emptied the room at standup.”
“A pricing bug hit 100% of EU traffic at 2am. One toggle, 200 milliseconds, gone — no escalation, no hotfix deploy, no incident review the next morning. That single save paid for the contract.”
“Product runs the rollouts now without filing a ticket, and engineering trusts the guardrails to catch anything they ramp too fast. Same dashboard, two teams, zero standoff.”
Create as many flags as your codebase needs. We never charge you to be careful.
For solo builders and side projects.
For product teams shipping daily.
For platform teams at scale.
No. The SDKs evaluate flags locally from a ruleset streamed into memory, so there's no network round-trip on your request path. Median in-process evaluation is sub-millisecond; edge evaluation is 11ms at p99.
Every SDK caches the last ruleset it received and falls back to the default you set per flag. If our service vanishes entirely, your app keeps serving the variants you last shipped — flags fail to a known state, never to a blank one.
Homegrown toggles give you on and off. Flagship adds sticky percentage rollouts, attribute targeting, experiments with real statistics, automated guardrails, a full audit trail, and stale-flag cleanup — every part that turns painful once more than one team is flipping things.
Yes. Product and ops drive flags from a no-code dashboard, while approval workflows, change windows, and RBAC keep production fenced off. Every change a non-engineer makes is still logged and reversible to the second.
No. Targeting can run entirely on attributes evaluated inside your own infrastructure with the local SDKs or a self-hosted relay. Enterprise plans add a private edge, so no end-user data ever crosses your perimeter.
Install an SDK, wrap one line of code, and ship your first controlled rollout this afternoon. No sales call to get started.