Flipt

Feature flag management, honestly reviewed. Built for developers who want deployment safety without another SaaS bill.

TL;DR

• What it is: Open-source feature flag platform that stores all flag configuration directly in your Git repositories — no database required [1][2].
• Who it’s for: Engineering teams (startups through mid-size) who are tired of deployment-day anxiety and want feature flags that live inside their existing Git workflow, not bolted alongside it [website].
• Cost savings: LaunchDarkly and similar managed feature flag platforms can run $300–$1,000+/mo depending on seat count and MAUs. Flipt self-hosted v2 runs as a single binary — no database, no Redis — on the cheapest VPS you can find [2][website].
• Key strength: Genuinely Git-native: UI changes become actual Git commits, environments map to Git branches, and migrations between deployments preserve your data because it’s already in your repo [1][2].
• Key weakness: Flipt Cloud (their hosted offering) was shut down in August 2025 — this is a self-host-only product now. And the most compelling collaboration features (merge proposals, SCM integration) are gated behind a Pro license [2][4].

---

What is Flipt

Flipt is a feature flag management platform. You define flags — booleans, variants, segments — and your application evaluates them at runtime to decide which code path to execute. That’s the feature flag basics; what makes Flipt’s pitch distinct is where it stores those flags.

Most feature flag tools use a database as the source of truth. You make a change in a UI, it writes to Postgres, your app polls or subscribes to get the update. Your Git history has your code changes; a separate system has your flag changes. When production breaks, you correlate two timelines.

Flipt v2 eliminates that separation. Flags live in YAML files committed to your Git repository, right next to the code that reads them [1][2]. Change a flag through the Flipt UI and the platform commits directly to Git. Roll back a bad flag change the same way you roll back bad code: git revert. The GitHub README puts it plainly: “Store feature flags directly in your Git repositories. Use your existing branching strategy. Deploy flags alongside your code using the tools you already know and trust” [README].

The project started as a traditional database-backed flagging tool (v1), but the team spent 2023–2025 rearchitecting it from scratch around Git storage, culminating in the v2 release [1][2]. Flipt Cloud — a hosted version the team offered briefly — was shut down in July 2025 after they concluded “it hasn’t justified the operational cost of running a hosted service long-term” [2]. The company has bet everything on self-hosted v2.

As of this review the project sits at 4,749 GitHub stars.

---

Why people choose it over LaunchDarkly, Unleash, and others

The GitOps problem with most feature flag tools. The Flipt blog wrote bluntly in 2023: most feature flag offerings “work at odds with GitOps practices” [1]. The standard workaround — a Terraform provider that syncs flag state into a managed service — means two sources of truth and a reconciliation process that can fail silently. Their conclusion: build a tool where Git is the flag database, not a secondary sync target [1].

Versus LaunchDarkly and other managed SaaS. LaunchDarkly is the category-defining product: mature, feature-rich, deeply integrated into enterprise security workflows. It’s also expensive at scale and fully closed-source. If your flag data lives in LaunchDarkly, it lives in LaunchDarkly. Flipt’s self-hosted model means your flag configuration sits in your own GitHub/GitLab/Bitbucket repo — you could switch tooling tomorrow and your flags are still readable YAML files [1][2][5].

Versus Unleash. Unleash is the other major open-source feature flag platform. It’s older, more mature, and database-centric. Flipt v2’s differentiator is the zero-dependency deployment (no Postgres required) and the Git-native storage model. Unleash requires you to run a database; Flipt v2 does not [2][README].

Versus raw environment variables. The obvious alternative for non-technical founders: just use env vars. Feature flags give you something env vars don’t — runtime changes without redeployment, gradual rollouts to percentages of users, and a UI for non-engineers to toggle flags. The deployment-free toggle is the core value proposition.

The “flags as code” pitch resonates with engineering teams who already do GitOps for everything else. One customer quote on the Flipt homepage: “Flipt empowers us to achieve these by being co-located within our infrastructure. Flipt offers a straightforward yet robust flagging solution, streamlining the development of our new features and ensuring their successful rollout.” — Michael Hintz, Senior Engineer at Paradigm [website]. Another: “Flipt has allowed Rokt to dynamically turn on features…” [website].

---

Features

Core flag engine:

• Boolean flags (on/off) and variant flags (A/B, multivariate) [README]
• Segment-based targeting: route flags to specific users, roles, or attributes [README][5]
• Percentage rollouts: gradually expose features to 10%, 50%, 100% of users [website]
• Real-time flag propagation via Server-Sent Events (SSE) — no polling required, changes reach client SDKs in milliseconds [README][website]
• Full version history via Git — every flag change is a commit with author, timestamp, and diff [1][5]

Git-native storage:

• Flags stored as YAML files in your own Git repository [1][2]
• UI changes → automatic Git commits, pushed back to your repo [website]
• Multi-environment support: map environments to Git branches, directories, or separate repos [README]
• Works with GitHub, GitLab, BitBucket, Azure DevOps, Gitea [README][4]
• Zero database required — single binary, self-contained [2][README]

SDKs and integrations:

• Native SDKs: Go, Python, JavaScript, C#, Swift, Kotlin, Dart [website]
• REST API and gRPC API for service-to-service communication [website][README]
• OpenFeature support — the CNCF vendor-neutral feature flag standard [website]
• Server-side and client-side evaluation modes [website]

Authentication:

• OIDC, JWT, OAuth supported [README][5]
• SSO available [features list]

Pro-gated features:

• Merge proposals: PR-style review workflow for flag changes, works with GitHub, GitLab, Bitbucket, Azure DevOps — Pro only [4]
• SCM integration (deep Git provider integration beyond basic sync) — Pro only [4]
• GPG commit signing for cryptographic verification of flag changes — Pro only [README]
• Secrets management integration — listed as OSS [README]

---

Pricing: SaaS vs self-hosted math

Flipt self-hosted (open source):

• Software: $0
• Infrastructure: a VPS to run the single binary on. Flipt v2 has no database dependency, so a $4–6/mo Hetzner CAX11 or similar handles moderate loads comfortably
• Pro license: pricing not published publicly; the website directs to a free 14-day trial with no credit card required [website]

Flipt Cloud: shut down August 29, 2025 — no longer an option [2].

LaunchDarkly for comparison: pricing tiers start at a free plan for small teams, with paid plans scaling based on monthly active users (MAUs). At 10,000 MAUs the Starter plan runs around $10–12/mo; at 50,000+ MAUs and enterprise features (SSO, advanced targeting, data export) the bills climb into hundreds per month. Specific pricing data not available in sources reviewed — check LaunchDarkly’s current pricing page directly.

Unleash Cloud: offers a free OSS self-hosted version and a managed Pro plan. Self-hosted is free but requires a database.

Concrete self-hosting math:

• Flipt v2 binary + $6 VPS = $6/mo with unlimited flags, unlimited evaluations, unlimited environments
• No per-seat tax, no MAU limits, no flag limits [website]
• The only cost that scales: your compute, and only if evaluation volume demands it

The “scale without the billing shock” messaging [website] is real — most managed feature flag tools charge per MAU or per seat. If you’re running a SaaS with 50,000 users and 15 engineers all touching flags, the per-seat/per-MAU math on a managed platform gets uncomfortable fast. Self-hosted Flipt’s cost doesn’t move with those variables.

---

Deployment reality check

This is where Flipt v2 makes a genuinely unusual claim: zero external dependencies. No Postgres. No Redis. No message broker. Single binary [2][README]. That’s a meaningful reduction in operational surface compared to most self-hosted tools.

What you actually need:

• A Linux host (VPS, EC2 instance, bare metal, whatever) — also runs on macOS and Windows [2]
• The Flipt v2 binary (or Docker image)
• Access to a Git repository (GitHub, GitLab, Bitbucket, etc.) for flag storage
• A reverse proxy (Caddy/nginx) if you want HTTPS — standard setup
• A GitHub/GitLab Personal Access Token with repo read/write permissions [3]

What you don’t need:

• PostgreSQL
• MySQL
• Redis
• A separate database backup strategy — your flags are in Git, which you’re already backing up

Setup flow (rough steps based on docs):

1. Download or Docker-pull the Flipt v2 binary
2. Create a configuration file pointing at your Git repository
3. Set a GITHUB_TOKEN (or equivalent) environment variable
4. Start Flipt — it clones the repo and starts syncing

The migration guide for Flipt Cloud users [3] gives a good sense of the configuration complexity: it’s a YAML config file with a credentials block, a storage block pointing at your remote, and an environments block mapping names to directories. Not trivial for someone who’s never touched a config file, but not frightening for anyone who’s deployed any other self-hosted tool.

What can go sideways:

• The SCM deep integration (Merge Proposals, PR creation from UI) is Pro-only [4]. The free tier syncs flags to Git but doesn’t create pull requests. If you want the full GitOps workflow with code review for flag changes, you need a Pro license.
• Flipt Cloud is gone [2]. If you tried Flipt Cloud previously and assumed the hosted option would remain, it won’t. Self-hosting is the only path.
• The GitHub repo referenced in the merged profile (github.com/markphelps/flipt) appears to be the original creator’s personal repo rather than the main organization (github.com/flipt-io/flipt). Confirm you’re looking at the correct repo for v2.
• Multi-environment configuration with branch-per-environment can get complex — “environment per branch,” “environment per directory,” and “environment per repository” are all supported [README], but you need to pick a model and be consistent.

Realistic time estimate: 30–60 minutes for a technical user to get a working self-hosted instance connected to a GitHub repo. The zero-dependency architecture means the hardest parts (database setup, connection strings, migrations) don’t exist.

---

Pros and Cons

Pros

• Zero-dependency deployment. Single binary, no database required, runs anywhere [2][README]. This is genuinely rare in the self-hosted category.
• Flags live in your Git repo. Your flag data is yours, in a format you can read and edit without Flipt — plain YAML files [1][2]. No vendor lock-in on your data.
• Full version history for free. Every flag change is a Git commit. You don’t need to pay for an “audit log” feature; you already have one [1][5].
• Real-time updates via SSE. Flag changes propagate to clients in milliseconds without polling infrastructure [README][website].
• Multi-environment with Git flexibility. Branch-per-env, directory-per-env, repo-per-env — meets teams where their Git structure already is [README].
• No per-seat or per-MAU pricing on self-hosted. Unlimited flags, unlimited users, unlimited evaluations [website].
• OpenFeature support. If you ever want to switch flagging providers, OpenFeature compatibility means your evaluation code doesn’t change [website].
• Honest shutdown of Flipt Cloud. The team killed a product that wasn’t working economically rather than quietly degrading it [2]. That’s a reasonable signal about how they operate.

Cons

• Merge Proposals are Pro-only. The most compelling feature — PR-style code review for flag changes — requires a paid Pro license [4]. The free tier can sync to Git, but creating reviewable pull requests from the UI is gated.
• Flipt Cloud is dead. Announced July 2025, shut down August 2025 [2]. If you want managed hosting, you’ll need a third-party provider or run it yourself.
• 4,749 stars is modest for the category. LaunchDarkly has market dominance; Unleash has a larger open-source community. Flipt is a smaller project with a smaller ecosystem.
• License is unclear from public metadata. The merged profile lists the license as NOASSERTION — verify the actual license terms on the repository before deploying in a commercial context.
• Pro pricing not published. The website offers a free trial but doesn’t list Pro pricing. You need to contact sales or start a trial to understand the commercial cost [website].
• Not for non-technical users. This tool is built for developers. There’s no meaningful way to hand it to a marketer or PM who doesn’t understand Git workflows. Segment targeting, rollout percentages, flag evaluation — all of it assumes engineering context.
• Small team risk. The Flipt Cloud shutdown [2] demonstrates what happens when the economics don’t work. Flipt is run by a small team; betting your feature flag infrastructure on it means accepting that risk.

---

Who should use this / who shouldn’t

Use Flipt if:

• You’re an engineering team that already does GitOps for infrastructure and wants feature flags to follow the same model.
• You want zero-database self-hosting — the simplest possible operational footprint for a flagging tool.
• You’re paying for a managed feature flag SaaS (LaunchDarkly, Split, Statsig) and the MAU/seat billing is starting to hurt.
• Your compliance requirements mean flag data must live in your own infrastructure, not a vendor’s cloud.
• You have Go, Python, or JavaScript as primary languages with active SDK support.

Skip it if you’re non-technical. Flipt requires you to understand Git, configure YAML, and run a binary. There’s no hosted version. If you can’t or won’t deploy a self-hosted service, there’s no path here.

Skip it (pick Unleash) if:

• You want a more mature open-source community around your flagging tool.
• You prefer database-backed storage (Unleash supports Postgres, MySQL, and others) with more explicit control over the data model.
• You need enterprise RBAC and SSO without a Pro license cost.

Skip it (pick LaunchDarkly or Statsig) if:

• Your team’s time is too valuable to manage any self-hosted infrastructure.
• You need the broadest SDK support, enterprise SLAs, and deep analytics integrations.
• Your compliance team requires SOC 2 attestation from your tooling vendors.

Skip it (stay on env vars) if:

• You have fewer than 3 engineers and you toggle features by pushing code. Feature flags add operational complexity — only reach for them when deployment-time toggles are actively costing you.

---

Alternatives worth considering

• Unleash — the other major open-source feature flag platform. Database-backed (Postgres required), larger community, more mature enterprise features in the open-source tier. Less opinionated about Git workflows.
• LaunchDarkly — the category leader. Best-in-class managed service, massive SDK ecosystem, strong analytics. Expensive at scale and fully closed source.
• Statsig — newer managed platform, strong on experimentation and analytics alongside flags. No self-hosted option.
• GrowthBook — open-source, focused on A/B testing and experimentation rather than pure feature flagging. More relevant if you need statistical significance built in.
• Flagsmith — open-source feature flag platform with a database-backed self-hosted option and a managed cloud. More traditional architecture than Flipt v2.
• Harness Feature Flags — enterprise-grade, acquired by Harness, expensive.
• Raw environment variables — genuinely appropriate for small teams. No infrastructure, no cost, no UI. The tradeoff is runtime toggle capability.

For an engineering team building on GitOps principles, the realistic shortlist is Flipt v2 vs Unleash. Pick Flipt if the zero-dependency deployment and Git-native storage model align with how you already work. Pick Unleash if you want a database-backed model with a larger community and more mature open-source enterprise features.

---

Bottom line

Flipt v2 is a focused product with a clear point of view: feature flags should be stored in Git, alongside code, using the same version control and review workflows your team already runs. The execution on that idea is solid — zero external dependencies, single binary, SSE-based real-time propagation, multi-environment support mapped to Git branches. The Git-native storage model is genuinely differentiated; most competitors treat Git sync as an optional bolt-on, not the primary storage layer.

The honest caveats: the hosted option is gone, the best collaboration features (Merge Proposals) cost money, and 4,749 stars reflects a smaller community than the category leaders. For a small engineering team doing GitOps who wants to stop paying per-MAU fees for a managed flag service, the math on a $6 VPS running a stateless binary is straightforward. For a non-technical founder or a team that wants zero ops overhead, this isn’t the right tool.

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

---

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” (Pro feature). 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: https://github.com/markphelps/flipt (4,749 stars)
• Official website: https://flipt.io
• Flipt v2 documentation: https://docs.flipt.io/v2/introduction