Products / Feature Flags
Feature flags that evaluate locally — zero latency, every time.
Built for engineering teams who deploy continuously, the SDK fetches your config once and evaluates flags in-process. No round-trips. No per-evaluation costs. Just instant, deterministic decisions that never block your request path.
Everything you need to ship safely
From first rollout to full replacement, feature flags give you control over every release without a deployment.
Local evaluation — zero latency
The SDK fetches your flag config from CloudFront once and evaluates every flag locally. No network call on each evaluation — not even a cache hit. Flags evaluate entirely in-memory, with no network call on the hot path.
Percentage rollouts
Gradually expose a feature using MurmurHash3 bucketing — 0.01% granularity, deterministic per user. The same user always sees the same variation. Increase from 1% to 100% without reshuffling existing users.
User & attribute targeting
Target by any attribute you pass — plan, country, email, company, or anything custom. Combine multiple rules with AND/OR logic. Allowlists let you always-on or always-off specific user IDs.
Instant kill switches
Disable any flag from the dashboard and the config propagates to every SDK via CloudFront invalidation. No deployment, no hotfix. Average propagation time under 30 seconds globally.
Targeted delivery
Serve one specific variation to 100% of users who match your targeting criteria — with no traffic split or bucketing. Use this for beta rollouts, premium feature gating, and regional releases.
Multi-environment support
Every project has independent dev and prod environments with separate SDK keys. Change a flag in dev without touching prod. Promote configurations deliberately when you're ready.
Scheduled changes
Schedule a flag change to fire at any future date and time. Set traffic to increase automatically on launch day, run a time-limited promotion, and optionally auto-revert when it ends.
11 SDKs across every stack
Native SDKs for Node.js, Browser, React, React Native, Flutter, Python, Go, Java, PHP, and Laravel. Every SDK is type-safe, tree-shakeable, and evaluates flags locally with no per-call network overhead.
How it works
Config on the edge. Evaluation in your process.
SDK fetches config from CloudFront
On startup, the SDK pulls a compact JSON config — your flags, rules, and audience definitions — from a global CDN edge node. ETag caching ensures re-fetches only happen when something actually changed.
Every evaluation is local
sk.decide() and sk.decideAll() evaluate entirely in-memory using MurmurHash3. No HTTP call, no cache lookup, no database query. The result is deterministic: the same user always gets the same variation.
Exposure is recorded once per session
When a user is bucketed into a variation, the SDK fires a single $exposure event — once per user, per flag, per session. This powers your experiment results and counts toward your monthly limit.
Bucketing: MurmurHash3 — 10,000 buckets, 0.01% granularity
A/B testing & experiments →// Initialize once at module level
const signakit = createInstance({ sdkKey: process.env.SIGNAKIT_KEY })
await signakit.onReady()
// Evaluate — local, no network call
const userCtx = signakit.createUserContext(user.id, { plan: 'pro' })
const flags = userCtx.decideAll()
// Use the result — no latency cost
if (flags['new-checkout']?.variationKey === 'treatment') {
return showNewCheckout()
}SDKs
11 native SDKs. One consistent API.
Every SDK evaluates flags locally, ships with TypeScript types (or language-native types), and follows the same decide() pattern.
Common questions
Does calling sk.decide() count toward my monthly event limit?
No. Flag evaluations via sk.decide() and sk.decideAll() are always free and unlimited — they run locally in the SDK with no network call. Only automatic exposure tracking counts toward your limit, and that's recorded once per user, per flag, per session.
How fast is flag evaluation?
Around 0.2ms on average. The SDK fetches your flag config from CloudFront on startup and caches it in memory. Every subsequent evaluation is a pure in-memory hash lookup — no network, no disk, no cache miss.
What happens if CloudFront is unreachable?
The SDK falls back to the last successfully fetched config. If no config has been fetched yet (first cold start), flags return their safe defaults (off/control). Your application never crashes due to a SignaKit network issue.
Can I target users before they're logged in?
Yes. You can pass any stable anonymous identifier as the userId — a session ID, device ID, or a UUID you generate and store in a cookie. The MurmurHash bucketing is deterministic, so the same identifier always gets the same variation.
How quickly do kill switches propagate?
Flag changes trigger a CloudFront cache invalidation. Most SDKs pick up the updated config within 30 seconds globally. Browser and server SDKs respect ETags and only re-fetch when the config has actually changed.
Start shipping with confidence.
Free forever on the first million events. No credit card required.