Flipt

Self-hosted feature flag management, honestly reviewed. What you get when you treat flags as code.

TL;DR

• What it is: Open-source feature flag management platform built around Git — every flag change becomes a commit in your repository, not a record in a vendor’s database [1].
• Who it’s for: Engineering teams that already use Git-based workflows and want feature flags that fit naturally into pull requests, code review, and CI/CD pipelines. Not a tool for non-technical founders dragging blocks — this is squarely aimed at developers [README].
• Cost savings: LaunchDarkly’s Growth plan starts at roughly $10–$20/seat/month and climbs fast. Flipt self-hosted is a single binary with zero database dependencies — your infrastructure cost is one VPS, period [website].
• Key strength: Genuinely Git-native — not “we have a Terraform provider” Git-native, but flags stored directly in your repository as YAML, versioned, diff-able, and deployable alongside your code [1][README].
• Key weakness: Small team, narrow ecosystem, and the managed cloud offering was shut down in July 2025 — so you are committing to self-hosting, not picking it as an option [2].

---

What is Flipt

Flipt is a feature flag management platform. You define boolean or variant flags, attach targeting rules (percentage rollouts, user segments, context attributes), and your application evaluates them at runtime through an SDK or REST/gRPC API. The basic mechanics are identical to LaunchDarkly, Unleash, or Flagsmith.

What makes Flipt different is where the flag data lives. Most feature flag systems store their state in a proprietary database — their cloud, your PostgreSQL, your Redis. Flipt v2, released in 2025, stores flag state directly in Git repositories as YAML files. When you toggle a flag through the UI, Flipt commits the change to your repo. When you roll back, you run git revert. When you want to audit who changed what, you run git log. The flag data exists in the same place as your code, with the same access controls, the same history, and the same review workflow [README][1].

The GitHub description calls it an “Enterprise-ready, Git native feature management solution.” The homepage headline is blunter: “Deploy features without breaking production.” Both are accurate.

The project sits at 4,749 GitHub stars. The company — also called Flipt — is small. They were running a hosted cloud service alongside the OSS product, but shut it down on August 29, 2025, explicitly because the operational cost wasn’t justified and they wanted to focus on the self-hosted product [2].

---

Why people choose it

The primary reason teams land on Flipt is the Git integration — not as a feature to brag about, but as a workflow constraint they actually want.

The conventional critique of feature flags is that they create a second source of truth alongside your code. Your deployment pipeline manages one set of changes; your feature flag dashboard manages another. When something breaks in production, you’re correlating two independent audit trails from two different systems. GitOps practitioners have felt this friction for years [1].

Flipt’s blog post from 2023 announcing the Git backend work laid this out plainly: “GitOps prescribes that you store all your configuration in one or more Git repositories. Feature flag configuration is just like any other configuration in that it adjusts the behaviour of your applications at runtime. However, we find that it is rarely stored and tracked within Git itself.” [1] The v2 release made that vision concrete — Git isn’t a sync target, it’s the primary data store.

The second reason teams choose Flipt is the deployment simplicity. v2 runs as a single binary with no database dependency by default. For teams that have spent an afternoon fighting Unleash’s PostgreSQL setup or Flagsmith’s Docker Compose file, “single binary, zero dependencies” is a real selling point [README][2].

The third reason is pricing. LaunchDarkly, Split.io, and similar commercial tools charge per seat and per MAU (monthly active users). At any real traffic volume, those numbers get ugly. Flipt’s OSS version has no flags limit, no user limit, and no request limit. You pay for the VPS and nothing else [website].

The candid version: Flipt isn’t winning on integration breadth, community size, or SDK maturity compared to LaunchDarkly or even Unleash. It’s winning on a specific philosophical bet — that flags belong in Git — and on eliminating the hosted-service tax entirely.

---

Features

Core flag management:

• Boolean and variant (multivariate) flags [README]
• Percentage rollouts and user segment targeting [README]
• Context-based evaluation — pass arbitrary key/value pairs from your application and target on them [website]
• Full flag versioning via Git history [README]
• Multi-environment support: environments map to Git branches, directories, or separate repositories [README]
• Namespaces for organizing flags by team or service [README]

Git integration (the differentiator):

• Flag state stored as YAML in your Git repository — you own the data [README][1]
• Every UI change creates a Git commit automatically [website]
• Full read/write Git integration — not just read-only sync [README]
• Supports GitHub, GitLab, Bitbucket, Gitea, and Azure DevOps [2][README]
• Branch-per-environment workflow: test flag changes in a branch before merging to production [README]

Developer experience:

• Single binary deployment with zero external dependencies for v2 [README][2]
• Server-Sent Events (SSE) streaming API for real-time flag propagation — no polling required [README][website]
• SDKs for Go, Python, JavaScript, C#, Swift, Kotlin, Dart [website]
• REST and gRPC APIs [README][website]
• OpenFeature compatible — vendor-neutral evaluation standard [website]
• Dark mode UI [README]

Auth and security:

• OIDC/JWT/OAuth support [README]
• SSO available [merged profile]
• Secrets management for sensitive configuration (OSS) [README]
• Complete audit trail via Git commits [5]

Pro-only features (commercial license required):

• Merge proposals — create PRs for flag changes directly from the Flipt UI, reviewed in GitHub/GitLab/Bitbucket [website][4]
• SCM (Source Control Management) deep integration — full PR workflow without leaving Flipt [4]
• GPG commit signing — cryptographic verification of every flag change [README]

The OSS/Pro split is clean: you get the full Git-native workflow, all SDKs, SSE streaming, multi-environment, and auth in the open-source version. The Pro tier adds the PR review workflow on top. For teams that want to approve flag changes through Git PRs before they go live, that’s the upsell. For teams that are fine with direct commits, the OSS version covers everything [README][4].

---

Pricing: SaaS vs self-hosted math

Flipt self-hosted (OSS):

• Software: $0
• No flag limits, no user limits, no request limits [website]
• Infrastructure: one VPS — a $5–10/month Hetzner or Contabo box handles this without strain
• Pro license: pricing not publicly listed; contact sales

What Flipt Cloud cost: Irrelevant — Flipt Cloud shut down on August 29, 2025. New signups were disabled in July 2025. If you were using it, you migrated to self-hosted v2 or moved elsewhere [2].

LaunchDarkly for comparison:

• Starter: $10/seat/month (billed annually)
• Growth: pricing requires contact sales; community estimates put teams of 10-25 engineers at $500–$2,000/month depending on MAU tier
• Enterprise: custom, typically $3,000+/month for mid-size companies

Unleash (the closest OSS comparison):

• Open-source self-hosted: $0 (Apache 2.0 license)
• Unleash Pro (hosted): $80/month for up to 5 seats
• Enterprise: custom

Flagsmith:

• OSS self-hosted: $0
• Cloud: $45/month starter

The honest math for Flipt: if you’re a 5-10 person engineering team currently paying LaunchDarkly $500–$1,000/month, self-hosting Flipt on a $10 VPS saves you roughly $6,000–$12,000 per year. The setup investment is a few hours once. That math is obvious and real. If you’re on LaunchDarkly’s free tier with fewer than 1,000 MAU, the math is much less compelling — you’re trading zero cost for some operational overhead.

---

Deployment reality check

The v2 deployment story is genuinely simpler than most self-hosted tools. Single binary, no database required. The README says “zero infrastructure” and “zero dependencies by default,” which is accurate for basic use [README][2].

What you actually need:

• A Linux VPS or server to run the binary
• A Git repository (GitHub, GitLab, Gitea, Bitbucket, or self-hosted) for flag storage
• A GitHub Personal Access Token (or equivalent) with repo read/write access [3]
• A reverse proxy (Caddy or nginx) if you want HTTPS and a proper domain
• A Flipt config YAML file pointing at your repository

What you don’t need:

• PostgreSQL
• Redis
• SQLite file management
• Separate database backups (your Git repo IS the backup)

This is a real operational advantage over Unleash or Flagsmith, which both require a database in their default setups.

The migration path from Flipt Cloud to v2 is documented and described by the team as “straightforward” because Flipt Cloud already stored flag data in GitHub repositories — you’re just pointing v2 at the same repo [3]. That architecture decision turned a vendor sunset into a migration, not a data loss event.

Where it gets complicated:

The SCM integration (merge proposals, PR workflow) requires a Pro license and additional configuration — connecting Flipt to your Git provider’s API, setting up credentials, configuring environments per the docs [4]. The OSS path where UI changes go directly to commits is simpler; the PR-approval workflow requires more setup.

Multi-environment configuration has real complexity. You’re mapping environments to Git branches or directories, which means your branching strategy and your flag environment strategy need to align. Teams with disciplined GitFlow will find this natural. Teams with messier branching histories will need to think about it [3][README].

Realistic time estimates: 1–2 hours for a developer comfortable with Git and a Linux terminal to get a working v2 instance with a connected repository. Double that if you’re configuring SSO and multi-environment. The Pro SCM integration (PRs from Flipt UI) adds another hour of setup per provider.

---

Pros and Cons

Pros

• Flags as code, genuinely. Not “we sync to Git” but “Git is the database.” Flag changes are commits, rollbacks are reverts, history is git log. If you’re already doing GitOps, this fits without friction [1][README].
• Single binary, zero dependencies. v2 runs without a database, without Redis, without a separate service. The operational surface area is minimal compared to alternatives [README][2].
• No usage-based pricing pressure. No per-seat fees, no MAU limits in the OSS version, no flag count restrictions. You self-host and the cost is flat [website].
• Real-time flag propagation. SSE streaming means flag changes hit your clients in milliseconds without polling [README][website]. This matters when you’re doing a production rollback and every second counts.
• Git provider flexibility. GitHub, GitLab, Bitbucket, Gitea, Azure DevOps — not locked to one provider [2][README][4].
• OpenFeature compatible. The industry standard evaluation interface means you’re not completely locked to Flipt’s SDK if you want to swap later [website].
• Clean data ownership. When Flipt shut down its cloud service, users kept their data because it was in their own GitHub repos all along [2]. That’s the architecture paying off.

Cons

• Small team, shutdown history. The company shut down Flipt Cloud in July 2025 after deciding the operational cost wasn’t justified [2]. They remain committed to the OSS product, but this is a team making hard resource calls. If you’re betting your production infrastructure on Flipt, you’re betting on a small company staying focused.
• Narrow SDK ecosystem. Go, Python, JavaScript, C#, Swift, Kotlin, Dart — reasonable coverage, but nowhere near LaunchDarkly’s SDK depth for edge cases like PHP, Ruby, or Elixir [website].
• PR workflow requires Pro license. The most compelling Git-native feature — reviewing flag changes through pull requests before they go live — is behind the commercial tier [4][README]. The OSS version commits directly without a review gate.
• 4,749 stars is a limited community. Unleash has 10,000+ stars. Flagsmith has 5,000+. The plugin/integration ecosystem is thinner; you’ll hit corners that haven’t been built yet.
• Git complexity can bite. Multi-environment configuration requires thinking carefully about how your branching strategy maps to your environments. Teams with inconsistent Git practices will find this more painful than teams with disciplined workflows [3].
• Pricing opacity. Pro license pricing requires contacting sales. For a product marketed at developers who distrust sales processes, this is friction [4][website].
• v2 is a ground-up rewrite. The existing v1 documentation and resources are still online but reference a different architecture. New adopters are fine; teams migrating from v1 need to re-evaluate assumptions [README].

---

Who should use this / who shouldn’t

Use Flipt if:

• Your team already uses GitOps — Terraform, Flux, ArgoCD, or just strict PR-based deployments — and you want feature flags that don’t create a parallel non-Git change process.
• You’re paying $500+/month for LaunchDarkly or Split.io and the bill is becoming a line item someone questions in budget reviews.
• You have developers comfortable managing a single Linux binary on a server they already run.
• You want to own your flag data completely, with no dependency on a third-party cloud that could sunset (as Flipt Cloud itself demonstrated is possible) [2].
• Your team’s primary language is Go, Python, or JavaScript — the SDKs for these are most mature [website].

Skip it (use Unleash instead) if:

• You want the broadest open-source feature flag ecosystem with the most community plugins, proxy integrations, and third-party guides.
• Your team’s flag workflow doesn’t need to be Git-based — you just want a self-hosted dashboard with a database backend and straightforward setup.
• You need a maintained, open-source SDK for a less common language like PHP or Ruby.

Skip it (use LaunchDarkly or Split.io) if:

• You need enterprise SLA, dedicated support, and compliance certifications without managing your own infrastructure.
• You have non-technical product managers or marketers who need to control feature flags through a polished UI without any Git interaction.
• You’re under 10 users and LaunchDarkly’s free tier already covers your needs.

Skip it (use GrowthBook) if:

• You need feature flags combined with A/B testing and experimentation analytics in a single self-hosted tool.

Skip it (use Flagsmith) if:

• You want a self-hosted option with a more traditional database backend and a larger existing community of tutorials and deployment guides.

---

Alternatives worth considering

• Unleash — The most-starred open-source feature flag platform (Apache 2.0 license). Database-backed, broader SDK catalog, larger community. Lacks the Git-native angle entirely.
• Flagsmith — Open-source (BSD 3), self-hostable, simpler architecture, more tutorials available for non-specialists. Also database-backed.
• GrowthBook — Open-source feature flags plus A/B testing in one tool. Strong choice if you need experimentation metrics alongside flag management.
• LaunchDarkly — The commercial standard. Best SDK coverage, enterprise support, most mature platform. Price scales aggressively with seats and MAU.
• Split.io — Similar to LaunchDarkly. Strong experimentation features. Usage-based pricing that bites at scale.
• OpenFeature — Not a product but a vendor-neutral SDK standard. Worth knowing about because Flipt supports it, which reduces lock-in if you switch [website].

For a developer team doing GitOps and self-hosting, the realistic shortlist is Flipt vs Unleash. Pick Flipt if Git-native flag storage and zero database dependency matter. Pick Unleash if you want the broader community and simpler conceptual model.

---

Bottom line

Flipt makes a specific bet: that feature flags should live in Git alongside the code they control, with the same version history, the same review workflow, and the same deployment pipeline. For teams that have already committed to GitOps, this is a natural fit rather than a philosophical argument. For teams with a messier relationship to Git, it’s friction they’ll feel in the configuration.

The Flipt Cloud shutdown in 2025 was a moment of honesty: this is a small team, they’re not going to run a hosted service at a loss, and they’d rather do self-hosting well than do managed cloud poorly [2]. That’s actually a reasonable call, and the architecture — flags in your Git repo — means you keep your data regardless of what happens to the company.

If you’re a developer team paying LaunchDarkly $500–$2,000/month and you’re already managing your own infrastructure, Flipt v2 is worth an afternoon evaluation. Single binary, point it at a Git repo, done. If you need a non-technical team to own flag management, or if you need enterprise support on an SLA, this isn’t the right tool.

If the self-hosting setup is the blocker, that’s exactly what upready.dev deploys for clients. One-time engagement, you own the infrastructure permanently.

---

Sources

1. George MacRorie, Flipt Blog — “How’s About Git?” (May 31, 2023). https://blog.flipt.io/gitops-announcement
2. Mark Phelps, Flipt Blog — “Sunsetting Flipt Cloud” (July 24, 2025). https://blog.flipt.io/sunsetting-flipt-cloud
3. Flipt Documentation — “Flipt Cloud to Flipt v2 Migration Guide”. https://docs.flipt.io/v2/guides/migration/cloud/flipt-cloud-to-v2
4. Flipt Documentation — “Git SCM Integration”. https://docs.flipt.io/v2/guides/operations/environments/git-scm
5. NewAIForYou — “Flipt Cloud: Effortless Feature Management, Powered by Git”. https://newaiforyou.com/ai/flipt

Primary sources:

• GitHub repository and README: https://github.com/flipt-io/flipt (4,749 stars)
• Official website: https://flipt.io
• Documentation: https://docs.flipt.io/v2/introduction