Feature flag API + deterministic bucketing
Feature flag API for deterministic rollouts and user bucketing.
EdgeAssign is a hosted rollout API that returns stable feature decisions from deterministic inputs, with no assignment storage required.
Privacy by design: no per-user assignment history to retain, purge, or audit. Smaller retention surface, simpler compliance posture.
No assignment tables. No sync issues. No rollout drift. No rollout infrastructure to maintain.
Hash → modulo
Decisions are derived, not stored:
bucket = hash(seed + flag + subject) % 100
Because the bucket is derived from stable inputs, the same decision can be recomputed at any time — no assignment records needed.
Deterministic, no storage
Same subject gets the same answer — no per-user assignment tables needed.
Zero billing anxiety
7-day grace window, throttling instead of hard cutoffs, no surprise charges.
Live API base URL: https://api.edge-assign.com
# PowerShell (safe JSON)
$body = @'
{"subject":"alice","traits":{"plan":"pro","beta":true}}
'@
curl.exe -X POST -H "X-API-Key: YOUR_API_KEY" -H "Content-Type: application/json" --data-binary $body "https://api.edge-assign.com/v1/eval/prod1/new_checkout"
# macOS / Linux
curl -X POST -H "X-API-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"subject":"alice","traits":{"plan":"pro","beta":true}}' \
"https://api.edge-assign.com/v1/eval/prod1/new_checkout"
{
"eligible": true,
"enabled": true,
"bucket": 8,
"rollout_percent": 25
}
Rules + eval in one request
Send a subject and traits, evaluate eligibility, and apply rollout percentages in a single call.
Use rules like plan in ["pro","team"] or beta == true without extra endpoints.
# PowerShell (safe JSON)
$body = @'
{"subject":"alice","traits":{"plan":"pro","beta":true}}
'@
curl.exe -X POST -H "X-API-Key: YOUR_API_KEY" -H "Content-Type: application/json" --data-binary $body "https://api.edge-assign.com/v1/eval/prod1/new_checkout"
# macOS / Linux
curl -X POST -H "X-API-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"subject":"alice","traits":{"plan":"pro","beta":true}}' \
"https://api.edge-assign.com/v1/eval/prod1/new_checkout"
Why not just hash locally?
Hashing is easy. The hard part is distributing a master seed safely and keeping hashing behavior consistent across backend, frontend, mobile, and edge environments.
Warning: shipping a master seed to clients exposes cryptographic inputs and can destabilize rollouts if any environment drifts. Centralizing seed and logic in one API keeps those inputs off clients.
What local hashing handles
- Simple deterministic bucketing
- Basic percentage rollout
What gets hard fast
- Seed synchronization across clients and services
- Client exposure risk and reverse engineering
- Cross-platform hashing behavior drift
- Updating logic in one place instead of many
Trust, privacy, and compliance
EdgeAssign is built for zero-retention privacy: no per-user assignment tables, no persistent user-level rollout history.
- Deterministic decisions are computed on demand
- Stateless allocation reduces compliance scope
- Use SafeTraits: map sensitive inputs to booleans or coarse labels
EdgeAssign centralizes deterministic rollout math and seed consistency. Your systems still define business meaning (for example, what qualifies as “pro”).
This Worker code does not log request bodies. If you enable platform logging or external observability tooling, ensure payloads are excluded or scrubbed.
Optional client-side hashing
For stricter privacy requirements, you can hash subject identifiers before sending them to EdgeAssign. Deterministic rollout still works on the hashed value.
subject = sha256(user_id)
bucket = hash(seed + flag + subject) % 100
Show the math
Deterministic bucketing — no per-user storage required.
// seed + flag + subject => stable bucket
bucket = hash(seed + flag + subject) % 100
eligible = rules(traits)
enabled = eligible && bucket < rollout_percent
- Deterministic results for the same subject + traits.
- No per-user rollout assignment storage.
- Cacheable at the edge for low latency.
Each request, explained
- Evaluate eligibility rules against your traits.
- Compute a stable bucket for the subject.
- Apply rollout percentage to that bucket.
- Return a deterministic decision you can safely cache.
Designed for low-latency evals; cache at the edge or service layer.
Zero billing anxiety
Over-quota behavior is a production concern, not a billing footnote. EdgeAssign is designed to keep your app alive.
- Warnings at 80%, 90%, and 100% of your monthly limit.
- 7-day grace window up to 120% after you hit 100%.
- After grace, traffic is throttled (slower), not hard-stopped.
- No surprise upgrades; billing changes only with explicit opt-in.
Why teams pick EdgeAssign
Derived, not stored
No per-user assignment tables to maintain or sync.
Stable by design
Same subject + inputs always produce the same result.
Single-call evaluation
Eligibility and rollout in one request.
Cache-friendly
Deterministic responses work at the edge.
EdgeAssign vs. the usual options
Focused tool for rollouts: fast, predictable, low-ops.
| Tool | Positioned for | When EdgeAssign is the better fit |
|---|---|---|
| EdgeAssign | Deterministic bucketing + trait-based evaluation, API-first. | When you want a lightweight rollout API with deterministic decisions. |
| LaunchDarkly | Enterprise feature management platform with broad workflow needs. | When you want deterministic rollout and eligibility without broader platform overhead. |
| Statsig | Feature gates plus experimentation and product analytics. | When you want deterministic rollout without bundling experimentation and analytics. |
| Unleash | Open-source and self-hosted feature management options. | When you want hosted rollout evaluation instead of operating your own flag infrastructure. |
| ConfigCat, Flagsmith, GrowthBook, PostHog, DevCycle | Feature management platforms with different tradeoffs and scope. | When you want a rollout + eligibility API without extra surface area. |
Built for speed, simplicity, and deterministic decisions without storage overhead. Derived, not stored.
| Operational detail | EdgeAssign | Typical platforms |
|---|---|---|
| Over-quota behavior | 7-day grace window + throttling (app stays alive) | Hard 401 / abrupt cutoff (production outage risk) |
How it works
1. Define a feature
Create a feature flag for your project and set the rollout percentage you want.
2. Send a subject + traits
Your app sends a project, feature name, subject ID, and optional traits for eligibility rules.
3. Get a stable answer
EdgeAssign deterministically places that user into a stable bucket and returns yes or no.
Simple pricing
Starter
$19.99/month
- 1 project
- 1 API key
- Up to 100,000 requests/month
- Stable percentage rollout
- Account page with usage stats
Developer-first billing: warnings at 80/90/100%, 7-day grace up to 120%, then throttling (no hard stop). Billing never changes without explicit opt-in.
Instant API access after checkout.
Pro
$49.99/month
- 1 project
- 1 API key
- Up to 1,000,000 requests/month
- Stable percentage rollout
- Usage dashboard (monthly totals)
- Account page with usage stats
Developer-first billing: opt-in upgrades only, no surprise charges.
Instant API access after checkout.
Caching guidance
Deterministic responses work well with edge or service-layer caching. For most use cases, a 30–60 second TTL provides a practical balance between lower latency and near-real-time rollout control.
Prefer stale-while-revalidate during brief outages: serve the last-known decision while revalidating in the background. Store last-known-good decisions in a durable layer (edge KV or similar) so cache evictions do not cause sudden behavior changes.
Backend key rotation invalidates old keys immediately, but cached authorizations may linger until TTL expiry.
Quickstart
Warning: do not send raw PII in traits. Map sensitive data to SafeTraits (booleans or coarse labels) before it leaves your infrastructure.
# PowerShell (safe JSON)
curl.exe "https://api.edge-assign.com/health"
curl.exe -H "X-API-Key: YOUR_API_KEY" "https://api.edge-assign.com/v1/flag/prod1/new_checkout/alice"
$eval = @'
{"subject":"alice","traits":{"beta":true,"plan":"pro"}}
'@
curl.exe -X POST -H "X-API-Key: YOUR_API_KEY" -H "Content-Type: application/json" --data-binary $eval "https://api.edge-assign.com/v1/eval/prod1/new_checkout"
$batch = @'
{"items":[{"subject":"alice","traits":{"plan":"pro"}},{"subject":"bob","traits":{"plan":"free"}}]}
'@
curl.exe -X POST -H "X-API-Key: YOUR_API_KEY" -H "Content-Type: application/json" --data-binary $batch "https://api.edge-assign.com/v1/eval-batch/prod1/new_checkout"
curl.exe -H "X-API-Key: YOUR_API_KEY" "https://api.edge-assign.com/v1/bucket/prod1/alice?mod=100"
# macOS / Linux
curl "https://api.edge-assign.com/health"
curl -H "X-API-Key: YOUR_API_KEY" \
"https://api.edge-assign.com/v1/flag/prod1/new_checkout/alice"
curl -X POST -H "X-API-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"subject":"alice","traits":{"beta":true,"plan":"pro"}}' \
"https://api.edge-assign.com/v1/eval/prod1/new_checkout"
curl -X POST -H "X-API-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"items":[{"subject":"alice","traits":{"plan":"pro"}},{"subject":"bob","traits":{"plan":"free"}}]}' \
"https://api.edge-assign.com/v1/eval-batch/prod1/new_checkout"
curl -H "X-API-Key: YOUR_API_KEY" \
"https://api.edge-assign.com/v1/bucket/prod1/alice?mod=100"
# Learn more at https://edge-assign.com/docs.html
Why no SLA?
EdgeAssign is lean by design. The architecture removes many failure modes that force heavy support structures, so support is direct and technical rather than layered and bureaucratic.
- Deterministic, stateless evaluation means no assignment database to corrupt.
- Edge caching and short TTLs absorb traffic spikes while keeping rollouts predictable.
- Fewer moving parts means fewer incident classes and faster diagnosis.
If you do need help, you get direct access to the engineer who built the system.
FAQ
What does EdgeAssign do?
EdgeAssign gives developers deterministic percentage rollouts and stable user bucketing through a simple API.
Does the same user always get the same result?
Yes. For the same project and feature, the result is deterministic and stable.
What happens after I buy?
You get redirected to a confirmation page with your project name, a masked API key (with a reveal action), and an example request.
What happens if I cancel?
Access stays active through the paid billing period, then turns off when the subscription actually ends.
What happens if I hit my limit?
You get warnings at 80%, 90%, and 100%. At 100% you enter a 7-day grace window up to 120%. After grace, traffic is throttled (slower responses), not abruptly cut off. Billing never changes without explicit opt-in.
Can I view my account later?
Yes. EdgeAssign includes an account page where you can view your project, API key, subscription status, and usage.
Does EdgeAssign store per-user rollout assignments?
No. Rollout decisions are computed deterministically on demand instead of storing per-user assignment records.
What about latency and caching?
Responses are deterministic, so you can safely cache evaluations at the edge or service layer to reduce latency.
A 30–60 second TTL is a reasonable default for many setups. Cached responses may delay rollout updates or key changes until the TTL expires.
How do I update rollouts?
Update flags via API or internal tooling, for example moving a rollout from 10% to 25% without code changes.
