Targeting beyond users.
Describe who you mean: paying orgs in Brazil, devices on app version 3.2, one specific customer having a bad day. Combine conditions with AND and OR, save the result as a segment, and watch the live preview show who matches.
Stop redeploying
to flip a switch.
feat evaluates flags inside your runtime and streams changes to every SDK as they happen. Plans are metered on how often your SDKs call us, so seats, flags, and the size of your user base never show up on the bill.
console.feat.soproduction
new-checkoutOFFnew_checkout_v2
Acme Headphones
Studio-grade sound, 38-hour battery.
$249 USD
Add to cartFlip it. The change reaches every connected SDK over the live stream, with no redeploy and no app-store round trip.
01 / what's in the box
A full flag platform.
Targeting to approvals.
Six things every flag platform should do, working from your first signup: targeting rules, sticky rollouts, per-environment approvals, a real audit log, the right key for each runtime, and local in-runtime evaluation.
Sticky rollouts.
Ship a flag to 10% of pro-tier organizations in Germany with one click. Sticky rollouts keep the same audience on the same variation across requests, sessions, and devices. Different rules can carry different splits, with a fallback split that catches everyone else.
Approvals per env, per flag.
Production requires approval. Staging doesn't. Configure how many approvers it takes, whether someone can approve their own change, and whether comments are required, per environment.
Different keys for different runtimes.
Server keys for back-ends, browser-safe keys for client-side code, and a semi-secret, server-rotatable mobile key for the Flutter and Dart SDK. Each tuned to its runtime's security model.
Auditor-grade history.
Every change captured with full before-and-after history, who made it, and why. On every plan, Free included, with API-key secrets redacted before a record is written.
Evaluates locally. Updates live.
Save a change and connected SDKs pick it up over the live stream in under a second; a background poll catches up within 30 seconds if a stream drops. Your SDK keeps a local copy and evaluates flags in your runtime, so there's no network call per flag check. JavaScript, Python, Go, Ruby, browser JavaScript, and Flutter/Dart all evaluate the same way, so what your back-end returns matches what the edge serves.
02 / targeting
The audience updates
while you type.
Compose rules across any audience you can describe: users, devices, organizations, sessions, requests. Conditions compare text, numbers, dates, and semver, and combine with AND and OR.
flag · new_checkout_v2
Serve true to audiences where
recalculating
.
AND
.
AND
.
→ otherwise servefalse
live audience preview
0.38M / 4.82M users
7.9% of your audience matches these rules.
user.plan is "pro" AND
device.platform in "ios, android" AND
device.app_version version ≥ "2.4.0"
03 / rollout + experiments
Roll out to 1%,
then 10%, then everyone.
Ship a flag to 1% of any audience. Sticky rollouts keep the same user (or device, or organization) on the same variation across requests and sessions. Different rules can carry different splits, with a fallback split for everyone else. A built-in statistical engine and auto-advance gradual rollouts are planned, with no date committed yet.
Progressive rollout
drag to adjustShip to 1%, watch the metrics, ramp up. Every change is instant. No redeploys, no flag drift.
In treatment
14,46,000
Evals / min
5,04,000
Latency
2ms p99
A/B testing
PlannedA built-in statistical engine, variant tracking, and metric integrations are on the way. Today: ship the slider on the left and bring your own analytics for measurement.
- Variant tracking shared with the same SDKs you already use
- Pluggable metric sources (Segment, Mixpanel, PostHog, custom)
- Frequentist and Bayesian engines side-by-side
- Auto-advance gradual rollouts that halt on a regression
04 / sdk
Same shape,
every runtime.
Six SDKs on one shared evaluation engine: JavaScript, Python, Go, and Ruby evaluate locally; browser JavaScript and Flutter/Dart evaluate at the edge. What your back-end returns matches what the edge serves. OpenFeature providers for web, Node, and Dart. REST API for anything else (reference docs in progress).
↪Server SDKs evaluate in your runtime, with no per-check network call. Browser and Dart read a cached snapshot, so those reads are synchronous too.
↪Polls are version-aware, so a check that finds nothing new costs nothing to transfer.
↪Streams changes in under a second over SSE, with a 30-second safety poll when a stream drops.
// Local cache; in-process eval after first sync import { FeatClient } from '@feathq/js-sdk' const feat = new FeatClient({ apiKey: process.env.FEAT_SERVER_KEY!, }) await feat.ready() const { value } = await feat.evaluate('new_checkout_v2', false, { targetingKey: user.id, user: { key: user.id, plan: 'pro' }, })
05 / safety
When it's on fire,
pull the lever.
Flip a flag off and connected SDKs get the change over the live stream in under a second. SDKs that poll instead catch it within 30 seconds. The audit log records who, what, and why.
Kill a feature globally.
Something on fire? Hit kill. The off state streams out in under a second. No rollback. No redeploy. No standup.
new_checkout_v2 · productionlive
change propagated · live everywhereidle
active sessions affected0
click the button to simulate an emergency kill
06 / control
Simple by default.
Advanced on demand.
Every governance feature is an org-level toggle. Start with kill-switch flags; turn on segments, individual targeting, approvals, and progressive rollouts when your team needs them. Disabled features disappear from the console.
Always on
- Boolean, string, number, and JSON flags
- Targeting rules
- Percentage rollouts
- Kill switch + archive
- Audit history
- API keys for every runtime
The basics every team gets, on every plan. No setup, no settings page.
Org-level toggles
- Segments
- Individual targeting
- Change requests + approvals
- Progressive rollouts
Flip on what your team is ready for. Disabled features vanish from the console, so it never grows past what you actually use.
07 / privacy
Evaluation leaves
no record.
The JavaScript, Go, Python, and Ruby SDKs evaluate flags inside your runtime, so the attributes you target on (email, plan, anything) never reach our servers. Browser and mobile SDKs evaluate at the edge, so their context does reach us: we use it for that one evaluation and drop it. Either way nothing from an evaluation is written down, so your bill is a count and there is no traffic-derived record of who your users are. The one place we hold a user identifier is where you typed one in yourself, in an individual target or a segment.
your runtime
context: { user: "u_1732",
email: "ana@acme.io",
plan: "pro" }
evaluate("checkout-v2")
→ true, locally, ~2 ms
Attributes stay here. A server SDK has no evaluate call to send them on.
feat's edge
stores for billing:
requests += 1
→ that is the whole record
context, attributes: dropped after eval
Your bill is a count. No contexts, no per-evaluation events, and nothing identifying kept from the traffic itself. The JavaScript, Go, Python, and Ruby SDKs send us nothing at all.
Two nuances, stated plainly. Browser and mobile SDKs evaluate at our edge rather than in your process, so the context you pass them does reach our code; it is used for that one evaluation and then dropped. And individual targeting and segments hold the identifiers you type into them, because that is what those features are: your config, stored and shipped to your SDKs. Neither is derived from your traffic.
08 / receipts
Numbers we
actually publish.
These numbers come from the SDK and data-plane code, not from a brainstorm.
0 ms
p99 local SDK eval latency, evaluated in your runtime.
0.0 %
Uptime SLA on Growth tier and above.
< 1 sec
For a saved change to reach connected SDKs over the live stream.
0 M
Free-tier SDK requests a month. Unlimited flags, environments, and seats on every plan.
09 / check our work
Everything here
is checkable.
No testimonials yet, so here is the next best thing: where to go and verify the claims on this page yourself.
A dependency tree you can read at a glance.
The Go, Python, and Ruby SDKs are standard-library only. The JavaScript SDK adds feat's own engine and schema plus the OpenFeature packages behind its provider; nothing else. Releases publish to npm with provenance attestation via OIDC trusted publishing, so you can verify each artifact came from our CI, not a laptop.
see the provenance on npm →The wire format is public.
The exact datafile your SDK consumes is a documented, versioned schema, published as @feathq/datafile-schema. Rollout bucketing is deterministic down to the hash recipe, which we published in full; port it yourself and your numbers should match ours exactly. Prefer vendor-neutral? OpenFeature providers ship for the server and browser SDKs.
read the bucketing recipe →A paper trail on every plan.
The audit log is on for everyone, Free included. Changes made in one request group into one entry instead of thirty rows, comments can be required per environment, and API-key secrets are redacted before a record is ever written.
how the audit log works →10 / pricing
Honest pricing.
No “contact us” tax.
Free forever for solo devs. One meter for teams, SDK requests, and nothing else: seats, flags, environments, and the number of people using your product are all off the bill.
Free
$0 1M requests / mo Nothing to bill: there is no card on file.
A real production tier. A million requests, no card, no expiry.
- Boolean, string, number & JSON flags
- Unlimited flags, environments, projects & seats
- Full targeting: every operator, custom context kinds, anonymous contexts
- Percentage rollouts & individual targeting
- Segments
- Kill switch + archive
- Live streaming updates
- All SDKs + OpenFeature providers
- 3 built-in roles
- 2FA + Google/GitHub sign-in Planned
- 30-day audit log
- Usage alerts at 50 / 80 / 95 / 100%
- Email support, best effort
Pro
$29/mo 10M requests / mo $6 per extra million, pay as you go.
Ten million requests for $29. The cheapest entry tier in the category, and it caps nothing.
- Everything in Free, plus:
- 10M requests, then $6 per extra million
- Required comments on changes
- Flag comparison across environments
- 1-year audit log
- Webhooks Planned
- CLI Planned
- Email support, 48-hour response
Growth
$99/mo 25M requests / mo $6 per extra million, pay as you go.
Approvals, custom roles, and three years of audit history. Governance without the meeting.
- Everything in Pro, plus:
- Change requests + approvals
- Unlimited custom roles
- 3-year audit log
- 25M requests, then $6 per extra million
- SSO enforcement + SAML Planned
- Slack integration Planned
- 99.9% uptime SLA
- Email 8h · shared Slack channel · migration support
Bigger than Growth? There is no enterprise tier to negotiate.
Stay on Growth and the usage rate carries you: $6 per extra million, no cap and
no sales call. If you need something that isn't on this page, email us and we'll
tell you straight whether we have it.
Email us →