Open source, Apache-2.0

Feature flags
at the edge.

No server. No database. No bill. Self-host your flag service in five minutes, and drive it from any OpenFeature SDK.

Try the live demo Read the docs

new-checkout0 of 40 raised

FlagRollout 25%Rule: EU always on

Drag the rollout. The same visitors stay raised as it climbs.

Works today with these languages, each through its own OpenFeature provider:

Go
Java
Python
.NET
Ruby
Rust
JavaScript

The Flaghoist rule builder, showing a targeting rule that serves the EU cookie banner to visitors whose country is DE, FR, ES or IT.

The dashboard ships with the server.

One deploy brings up the OFREP read API, the admin API and this, at/admin, inside your own infrastructure. There is no second service to run and no vendor console to log into.

The rule you just built in the hero is the same rule shape this editor writes, evaluated by the same engine.

Built to be owned, not rented.

Nothing runs when nothing asks

Scale-to-zero on the Cloudflare free tier. No always-on process, no database instance, no monthly floor.

Multiple languages, on day one

The read path implements OFREP, so Go, Java, Python and .NET work through their own OpenFeature providers. We ship no SDKs.

Point it at your database

A storage adapter is four methods. Cloudflare KV, Redis and Postgres ship today, and a conformance suite proves any adapter you write.

Targeting that holds still

Sticky SHA-256 rollouts keep the same users in the same bucket across deploys. Ordered rules, first match wins.

One deploy, API and UI

The read API, the admin API and the dashboard all come up together at one URL. There is no second service to operate.

Inside your boundary

Flags live in your account and your compliance perimeter. Swapping to another provider is a one-line change.

Why not just use X?

An honest table, including the rows where Flaghoist loses today.

	LaunchDarkly	Flagsmith / Unleash	PostHog	flagd	Flaghoist
Deployment	SaaS	Server + Postgres	SaaS or server + DB	Sidecar per pod	Serverless, or any runtime
Idle cost	Subscription	Always-on server + DB	Free tier, then usage	A sidecar per pod	$0, scale-to-zero
Management UI	Yes	Yes	Yes	No	Yes, self-hosted
Protocol	Proprietary SDK	OF providers	Own SDK	OpenFeature-native	OpenFeature + OFREP
Your data lives	Their cloud	Your DB	Their cloud	Files	Your DB, your account
Multivariate flags	Yes	Yes	Yes	Yes	Not yet, boolean only
Experiments / A-B	Yes	Yes	Yes	No	No, bring your own analytics
Maturity	Mature	Mature	Mature	CNCF	Pre-alpha, one maintainer

Why not just build it yourself? You can. A JSON blob in object storage gets you 60% of the way. The other 40% is what is here: sticky SHA-256 rollouts that do not reshuffle users on every deploy, ordered targeting rules, OFREP conformance so every OpenFeature SDK works unmodified, an audit trail, and a UI your PM can use without a deploy.

Five minutes, start to flag.

Deploy the service

One config file, one command. Your own Worker and KV, or bring Redis, Postgres, or an adapter you wrote.

$ npm create flaghoist@latest team-flags
$ cd team-flags && npx flaghoist deploy
→ https://team-flags.you.workers.dev

Install a client
JavaScript shown. In Go, Python, Java or .NET, install your language's official OFREP provider instead. There is nothing Flaghoist-specific to add.
```
$ npm i @openfeature/web-sdk @flaghoist/vue
```
Register the provider once
Wire it at startup and your application code never mentions Flaghoist again. It only ever talks to OpenFeature.
```
await OpenFeature.setProviderAndWait(
  new FlaghoistProvider({ url, apiKey }),
)
```
Read a flag
Then toggle it, roll it to 25%, or target a cohort. From the dashboard or the CLI, with no deploy.
```
const newCheckout = useFeatureFlag('new-checkout')
```

Built by one person.
Here is why that is safe.

Weighing a single-maintainer project before you adopt it is fair. Here is exactly what it means for you, and why it matters less here than it would elsewhere.

Apache-2.0: Anyone can fork it and keep it alive. No CLA, no rug-pull clause.
Your flags, your storage: Your KV, your Redis, your Postgres. This project's health never touches your data.
An open protocol: The API is OFREP. To leave, point the same OpenFeature providers elsewhere. No rewrite.
Eject whenever: flaghoist eject hands you a self-contained TypeScript project you own outright.

If this project stalled tomorrow, you would keep running exactly what you are running today. That is deliberate. It is the whole point of self-hosting on open protocols.

Own your flags.

Self-host it, read it, fork it. Never pay per seat for a toggle again.

Get started

$ npm create flaghoist@latest team-flags