The Unleash alternative: feature flags in your repo

The main Unleash alternative for teams that want to skip the server entirely is dif. Both are open source. The difference is what the flag actually is. Unleash is a Node.js service you host, backed by PostgreSQL, with a React admin UI where flags get created and toggled. dif is a file format: every feature flag is a Markdown file in your repo, reviewed in a pull request, versioned in git.

Teams choose Unleash for its open-source license and mature governance. They start looking for an alternative when the operational cost bites: a server to run, a Postgres to keep alive, an OSS cap at 5,000 flags in two environments, or a cloud price that starts at $75 per seat with a five-seat minimum. This post covers what changes when a flag stops being a row in a database and becomes a file in the repo.

Key Takeaways

dif is the git-native Unleash alternative: one .md file per flag or experiment, no server to run, no Postgres to host, reviewed in a pull request.

Unleash OSS is free with unlimited seats, but capped at 1 project, 2 environments, and 5,000 feature flags per instance.

Unleash Cloud starts at $75 per seat per month with a five-seat minimum, a $375 monthly floor. dif Cloud is $50/month flat for 1M events with unlimited seats and unlimited projects.

Unleash Edge, the OSS edge-evaluation component, is being deprecated in December 2026. Edge-based flag evaluation moves to paid Enterprise Edge.

The tradeoff: dif has no admin UI for non-engineer flag owners. Flags change in a PR.

Why teams look for an Unleash alternative

Unleash is a mature open-source feature-flag server, spun out of Bekk in Norway and Apache 2.0 licensed. It is the closest philosophical peer to dif on the “open source” line, and a very different design underneath.

The OSS self-hosted tier is free forever and gives you unlimited seats, but it caps hard: 1 project, 2 environments, and 5,000 feature flags per instance. If you outgrow any of those, the answer is Enterprise, and Enterprise is a custom-priced sales conversation. SSO, SCIM, granular RBAC, change-request approvals, and a support SLA all sit behind that same paid tier.

Cloud pricing is $75 per seat per month with a five-seat minimum, which puts the floor at $375 a month before a sixth engineer joins. For a small team, that is per-seat SaaS math applied to an OSS project.

The 2026 change on the horizon is Unleash Edge, the OSS edge-evaluation component. It is being deprecated in December 2026. Teams that rely on edge evaluation will move to paid Enterprise Edge, which is a real decision to make in the next twelve months.

Add the day-to-day: a Node.js server to run, a PostgreSQL to keep alive, an admin UI to keep in sync with the code, and the same drift problem every dashboard-based flag tool has.

dif as the alternative

dif is an open-source, git-native feature-flag and A/B-testing tool. Every flag and every experiment is one Markdown file in your repo, next to the code it changes, reviewed in a pull request, versioned in git. There is no server to run and no database to host. The runtime is a 5 kB TypeScript SDK that makes no network call to pick a variant. See feature flags in your repo for the fuller pitch.

Two open-source models, side by side

Unleash and dif both hold the open-source line, and they answer a different question with it.

Unleash’s answer: the flag data belongs in a system dedicated to flags. That system is a Node.js server, a PostgreSQL database, and a React admin UI where non-engineers can toggle and target flags. Self-host and you run the stack. Go Cloud and you pay per seat for someone to run it for you.

dif’s answer: the flag is code that gates code, so it belongs in the same repo, reviewed in the same pull requests, tracked by the same git history. There is no separate service because there is no separate state. dif build compiles the flag files into a typed client your application imports, and the SDK evaluates locally. Feature flags in git covers the model in depth.

Both are OSS. The difference is whether the flag is a database row or a file in the repo.

dif vs Unleash, side by side

Dimension	dif	Unleash
Where flags live	Markdown files in your repo	Rows in PostgreSQL, edited in an admin UI
What you run	Nothing (CLI compiles locally)	Node.js server + PostgreSQL + React admin UI
License	MIT (CLI and SDK)	Apache 2.0 (OSS server)
Self-hosted cost	Free, no caps on flags or environments	Free, capped at 1 project, 2 environments, 5,000 flags per instance
Cloud entry price	$50/month, 1M events, unlimited seats, unlimited projects	$75/seat/month, 5-seat minimum ($375/mo floor)
SDK breadth	JavaScript and TypeScript, React and Svelte adapters	Java, Node.js, Go, Python, .NET, Ruby, PHP, plus JS/TS
Change a flag	Edit a file, commit, merge	Toggle in the admin UI, or hit the API
Sub-second kill switch	No (rollback is a deploy)	Yes (instant from the UI)
Edge evaluation	Local, in the SDK	Unleash Edge (deprecated Dec 2026); Enterprise Edge is paid
Review and audit trail	Pull requests and git history	Change requests + in-app audit log (paid tiers for approvals)
Agent-readable state	Yes (`context.json`)	No

Where Unleash wins

Unleash wins the rows where a mature server does what a git workflow cannot.

Backend-language SDK breadth. Unleash ships SDKs for Java, Node.js, Go, Python, .NET, Ruby, and PHP. dif’s SDK is JavaScript and TypeScript, with React and Svelte adapters. If your production stack is polyglot backends, that is a real gap.

An admin UI for non-engineer flag owners. Product managers, growth analysts, and support engineers can log into the Unleash UI, find a flag, and toggle or target it without touching a repo. dif’s model asks those users to open a PR, or to hand the flag change to someone who will.

Governance for large orgs. Change requests, granular RBAC, environment scoping, project boundaries, SSO, SCIM, and audit logs. Some of those are paid-tier, but the enterprise checklist is checked. dif is newer, and the equivalent controls come from git and CI, not from a policy engine.

Sub-second kill switch. Toggling a flag off in the Unleash UI takes effect the moment the SDK next polls or the edge pushes it. In dif, turning a flag off is editing a number to 0 and merging. If your build takes ten minutes, your worst-case kill is ten minutes.

Where dif wins

dif wins the rows where not running a service pays off.

No server or Postgres. There is nothing to deploy and nothing to monitor. dif build compiles the active flag files locally, and the SDK imports the result. If your Postgres goes down, your flags do not, because there is no Postgres.

No cap on flags or environments in the free tier. Unleash OSS stops at 5,000 flags in 2 environments per project. dif OSS has no cap. Environments are audience filters or branches, and the flag count is your file count.

PR review as the approval flow. Every flag change goes through the code review your team already runs. Approvals live in the git provider, not in a separate policy engine you have to reconcile with what actually shipped.

context.json for coding agents. dif build emits a machine-readable summary of every active flag and each surface’s latest learning. A coding agent reads it on session start, so it does not delete a branch behind a live flag or propose a test the team already ran. A dashboard behind a login cannot pass that to an agent.

Flat pricing for the cloud. dif Cloud is $50 per month for 1 million events, unlimited seats, unlimited projects. Adding a sixth engineer does not touch the bill. Unleash Cloud at $75 per seat with a five-seat minimum starts at $375 a month and grows with the team.

Who should switch, and who should stay on Unleash

Stay on Unleash if:

Your backend stack needs SDKs in Java, Go, Python, .NET, Ruby, or PHP as first-class citizens, and JS-only will not do.
Non-engineer flag owners work in the admin UI and are not going to open PRs.
You are on Unleash Enterprise today and need continuity for hosted-vs-self-hosted Enterprise Edge into 2027.
Change requests, granular RBAC, and SSO are procurement blockers you need out of the box.

Switch to dif if:

Your team is engineering-led and already lives in git and pull requests.
The flag is a code artifact to you, and having it in the repo alongside the code is the point.
Running a Node.js server and a Postgres for feature flags feels like too much infrastructure for the value.
You want a coding agent to read what is gated and what has been tried, and a dashboard behind a login cannot give it that.
You are on Unleash OSS, hitting the 5,000-flag or 2-environment cap, and an Enterprise sales call is not the answer you were looking for.

What migration looks like

Day one is dif init in the repo that already has your application code. It writes a dif/ directory, a generated TypeScript client, and managed blocks in CLAUDE.md, AGENTS.md, and .cursorrules. There is no account and no API key.

The port is per flag, done by hand. For each Unleash flag you keep, create one Markdown file with the same variants and weights. An Unleash strategy at 10% rollout becomes a two-variant flag with weights 90 and 10:

---
id: checkout-v2
status: active
owner: sam@acme.com
surface: checkout
variants:
  - id: "off"
    weight: 90
  - id: "on"
    weight: 10
metrics:
  primary: completed_checkout
---

## Brief

Ported from Unleash. Ramp to 25% once the guardrails hold for a week.

The call site changes from an Unleash SDK check to a dif call:

// Before, with Unleash
if (unleash.isEnabled('checkout-v2')) {
  return <NewCheckout />;
}

// After, with dif
if (dif('checkout-v2') === 'on') {
  return <NewCheckout />;
}

Then dif validate runs in CI and fails the pull request if the weights do not total 100 or the owner is not a real email:

$ dif validate
Validating 12 files in dif/flags/active/

  ok   checkout-v2         weights 90/10, owner sam@acme.com
  ok   home-hero-copy      weights 50/50, owner ali@acme.com
  fail pricing-experiment  weights sum to 90, not 100

Found 1 error.

Where the flag files sit after a port:

dif/
  config.yaml
  flags/
    active/
      checkout-v2.md
      home-hero-copy.md
      pricing-experiment.md
    concluded/
  surfaces/
    checkout.md
    home.md
    pricing.md

Because the Unleash OSS caps do not carry over, a team bumping into 5,000 flags or 2 environments finds neither limit exists in dif. The flag count is your file count, and environments are audience filters.

FAQ

Is dif open source? Yes. The CLI and SDK are MIT licensed, and the core runs entirely from your repo with nothing hosted. dif Cloud is an optional hosted analysis layer at cloud.dif.sh, not something you self-host.

Do I need to run a server for dif? No. dif build compiles the active flag files locally into a typed TypeScript client that your application imports. The SDK evaluates flags in-process, so there is no service to deploy and no database to keep alive.

Can I self-host dif? The CLI and SDK do not need hosting because they run in your repo and your app. dif Cloud is an optional hosted analysis layer at cloud.dif.sh; skip it if you do not need it.

How does dif compare to Unleash on price? dif’s CLI and SDK are free, no caps on flags, environments, or projects. dif Cloud is $50 per month for 1 million events with unlimited seats. Unleash OSS is free but capped at 1 project, 2 environments, and 5,000 flags per instance, and Unleash Cloud starts at $75 per seat per month with a five-seat minimum ($375/mo floor).

What happens to Unleash Edge in 2026? Unleash Edge, the OSS edge-evaluation component, is being deprecated in December 2026. Teams that need edge-based flag evaluation move to Enterprise Edge, which is on the paid tier. Time that into any 2026 decision.

Does dif have an admin UI? No. Flags are files, and the UI is your editor and your git provider’s pull-request review. That is a real gap for a non-engineer flag owner, and it is the tradeoff of the git-native model.

Try dif

An Unleash alternative that skips the server puts the flag where the code already lives. In dif that is a Markdown file, reviewed in a pull request, versioned in git, and compiled locally by the SDK. There is no Node.js service, no PostgreSQL, no admin UI to keep in sync with the code. Every flag file has an owner and a decision, and dif validate fails the pull request when either is missing.

The tradeoff is real. A rollback in dif is a merge and a deploy, and there is no admin UI for a non-engineer flag owner. For teams whose flag work already lives in code review, that is a fair trade. For teams whose flag work does not, Unleash is the better tool.

Install the CLI and see for yourself:

npm install -g @dif.sh/cli
dif init

The docs cover the rest of the loop.