GO Feature Flag

Self-hosted feature flags, honestly reviewed. No marketing fluff, just what you get when you run it yourself.

TL;DR

• What it is: Open-source (MIT) feature flag relay proxy and SDK suite — think LaunchDarkly, but your flag config lives in a YAML file on S3 and your server never phones home [2].
• Who it’s for: Engineering teams (Go shops first, but polyglot via relay proxy) who want proper feature flags — canary releases, progressive rollouts, A/B testing — without paying LaunchDarkly prices or running a Postgres cluster just to toggle a boolean [2][5].
• Cost savings: LaunchDarkly and similar commercial platforms run $100–$400+/mo for mid-size teams [4][5]. GO Feature Flag’s self-hosted relay proxy runs on whatever server you already have, and the config file costs nothing to store on S3 or GitHub.
• Key strength: No database required. Flag config lives in a version-controlled YAML file. The relay proxy reads it, evaluates rules, and serves flags over REST or OpenFeature SDKs. Operationally, this is about as simple as feature flags get [2].
• Key weakness: At 1,968 GitHub stars it’s a significantly smaller project than the open-source alternatives (Unleash sits at 12,000+, GrowthBook at 7,500+) [5]. No built-in admin UI for non-technical users, no experimentation analytics engine, and the managed cloud option doesn’t exist — it’s self-host only.

---

What is GO Feature Flag

GO Feature Flag is a self-hosted feature flag solution built around a deliberately simple architecture: your flags live in a configuration file (YAML, JSON, or TOML), a lightweight Go relay proxy reads that file from wherever you store it, evaluates targeting rules, and serves flag decisions to your apps via REST API or OpenFeature-compliant SDKs [2].

Originally it was a Go library only. The relay proxy changed that — now the same server can serve flag evaluations to Go, Java, Python, JavaScript, TypeScript, React, Angular, Swift, .NET, PHP, Ruby, Node.js, NestJS, and Kotlin apps through the OpenFeature standard [website]. The pitch is vendor neutrality: GO Feature Flag implements the OpenFeature spec, so if you later migrate to a different backend, your SDK calls stay the same [website].

What makes the architecture unusual is the absence of a database. There’s no Postgres or MySQL backing your flag state. The flag config file is the database — which means you get version control, diffs, pull request reviews, and rollbacks entirely through Git, for free [2]. The relay proxy polls your retriever (S3, Google Cloud Storage, GitHub, GitLab, Bitbucket, HTTP endpoint, local file, Kubernetes ConfigMap, MongoDB, Redis, PostgreSQL) and hot-reloads when the file changes [website].

The project is MIT-licensed, maintained by a single core author (Thomas Poignant) with community contributions, and sits at 1,968 GitHub stars. It’s listed in the Awesome Go registry and has a documented adopters list that includes companies like Minder and Mecena [README][website].

---

Why people choose it over LaunchDarkly, Unleash, and Flipt

The comparison that matters most here is the build-vs-buy decision, and secondarily, GO Feature Flag vs. the other serious open-source options.

Versus LaunchDarkly and commercial platforms. The core complaint with commercial feature flag tools is predictable: pricing that scales with seats, flag evaluations, or MAUs [4][5]. One comparison in the Statsig review [4] notes LaunchDarkly is “prohibitively expensive as you grow.” GO Feature Flag eliminates that category of problem entirely — there’s no per-evaluation billing, no seat count, no MAU meter. You pay for the server that runs the relay proxy, which is minimal: the klutch.sh deployment guide [2] specifically notes that “GO Feature Flag’s minimal resource requirements mean you can run a production-ready feature flag service on small instances.”

Versus Unleash, GrowthBook, Flagsmith. This is where the trade-offs get more nuanced. The flagshark.com comparison [5] breaks down the four main open-source contenders — Unleash, GrowthBook, Flipt, Flagsmith — and GO Feature Flag doesn’t appear in that list. That absence is itself informative: by GitHub star count and adoption, GO Feature Flag is a tier below those four. Unleash has 12,000+ stars, GrowthBook 7,500+, Flipt 4,000+, Flagsmith 5,000+ [5]. GO Feature Flag has 1,968.

What GO Feature Flag wins on is simplicity of operation. Unleash requires a Node.js API server backed by PostgreSQL. GrowthBook needs MongoDB. Flagsmith needs PostgreSQL. Flipt can run as a single binary, which is the closest comparison [5] — and notably Flipt also has first-class OpenFeature support. GO Feature Flag’s differentiation from Flipt is the file-based retriever approach: if your team already stores config in S3 or GitHub, the flag file fits naturally into that pattern without any additional infrastructure to maintain [2].

Versus rolling your own. Source [1] walks through how you’d implement a basic in-memory feature flag system in Go from scratch — a thread-safe struct with a mutex, a map of flags, and IsEnabled() calls. It’s not complicated for the basic case. GO Feature Flag adds everything that makes the basic case break down in production: remote storage, targeting rules, percentage rollouts, scheduling, A/B testing, SDK support for non-Go services, webhooks, and OpenTelemetry export [website][2]. If you’re three engineers and one service, the scratch solution works. If you’re running multiple services in multiple languages with external stakeholders who need to toggle flags without a deploy, GO Feature Flag is the upgrade path.

---

Features

Flag configuration:

• YAML, JSON, or TOML flag files [2]
• Boolean, string, integer, and JSON variation types [website]
• Hot-reload — relay proxy polls retriever and applies changes without restart [2][website]

Targeting and rollout:

• Rule-based targeting: include/exclude specific users or segments [website]
• Canary releases: enable for a fixed percentage of users [1][website]
• Progressive rollout: ramp from 0% to 100% over a defined time window, with monitoring in between [website]
• Scheduled flag changes: set a flag to flip at a specific time [website]
• A/B testing: split audience into multiple groups, track variation exposure [website][2]

Retrievers (where your flag file lives):

• HTTP(S), local file, Kubernetes ConfigMap [website]
• AWS S3, Google Cloud Storage, Azure Blob Storage [website]
• GitHub, GitLab, Bitbucket [website]
• MongoDB, Redis, PostgreSQL [website]

Exporters (where flag evaluation data goes):

• Apache Kafka, AWS Kinesis, Google Cloud Pub/Sub, AWS SQS [website]
• Webhook, Log, OpenTelemetry [website]

Notifiers (flag change alerts):

• Slack, Discord, Microsoft Teams, Webhook [website]

SDK and language support:

• Native Go library (direct, no relay proxy needed) [README]
• OpenFeature providers for: Go, Java, Kotlin, .NET, Python, JavaScript, TypeScript, React, Angular, Swift, Kotlin/Android, Node.js, PHP, Ruby, NestJS [website]
• REST API for anything not covered by an SDK [2]

Deployment modes:

• Go library embedded in your app (single-service Go teams) [README]
• Relay proxy (centralized server for polyglot environments) [2][website]
• Docker and Kubernetes supported [merged profile][2]

---

Pricing: SaaS vs self-hosted math

GO Feature Flag has no managed cloud offering and no commercial tier. It’s MIT, it’s free, and you run it yourself. Pricing is purely infrastructure.

Self-hosted cost:

• Software license: $0 [README]
• Relay proxy server: fits comfortably on a $5–10/mo VPS or an existing container in your cluster [2]
• Flag file storage: essentially $0 on S3 or GitHub

What you’re replacing:

LaunchDarkly’s pricing is not publicly listed in detail, but multiple sources [4][5] describe it as expensive at scale — one comparison notes it’s “prohibitively expensive” relative to alternatives [4]. Teams report $300–$500+/mo for mid-size usage. Flagsmith Cloud starts at $45/mo for teams. Unleash Cloud starts around $80/mo per month. Flipt Cloud pricing is not publicly documented.

For a five-engineer team paying $200/mo for LaunchDarkly, switching to a self-hosted GO Feature Flag relay proxy cuts that to effectively the cost of a container — call it $5–15/mo if you’re running it standalone, or $0 marginal if it shares existing infrastructure. The annual saving is $2,000–$2,200. The trade-off is that you own the operations.

What you don’t get that commercial platforms include: managed uptime guarantees, built-in dashboards, role-based access control with a UI, audit logs, and vendor support. If those are table stakes for your team, factor in the cost of building or forgoing them.

---

Deployment reality check

The klutch.sh deployment guide [2] is the most detailed third-party walkthrough available. The honest summary: deployment is straightforward for a Go-native team, and manageable for anyone comfortable with Docker.

What you actually need:

• A server to run the relay proxy (Docker container, Kubernetes pod, or a plain binary) [2]
• A flag configuration file hosted somewhere the relay proxy can reach (S3, GitHub, HTTP endpoint, or local path) [2]
• Optionally: a domain and TLS termination if your apps are external

What you don’t need:

• A database (this is the differentiator — the flag file is the persistence layer) [2]
• A separate admin UI (flag changes happen by editing the YAML file and pushing it)

What can go wrong:

• The “no UI” stance means non-technical stakeholders can’t toggle flags themselves. A product manager who needs to kill a feature at 2am has to either edit a YAML file, ask an engineer, or you build a thin wrapper around the config. For teams used to LaunchDarkly’s dashboard, this is a real operational change.
• The relay proxy is a single point of failure unless you run multiple instances. If it goes down, client SDKs fall back to default values — which is safe behavior but worth planning for [2].
• Progressive rollouts and scheduled changes are powerful but config-file-driven. There’s no visual dashboard showing you “the rollout is currently at 34%.” You get that data from your exporters (OpenTelemetry, S3, Kafka) if you configure them [website].
• Community size is small relative to the problem domain. If you hit an edge case or need a new retriever, you’re likely to be the one opening a GitHub issue or writing the PR.

Realistic setup time for a technical user following the documentation: 20–45 minutes to a working relay proxy serving a basic flag. Configuring exporters and notifiers adds another hour.

---

Pros and Cons

Pros

• No database dependency. Config file as truth is a genuine operational simplification — no Postgres cluster to manage, no schema migrations, flag history is Git history [2].
• MIT license. No commercial restrictions. Self-host, fork, embed in a product, use in a regulated environment [README][5].
• OpenFeature first. Native support for the emerging open standard means your flag evaluation code isn’t coupled to the vendor [website][2]. If you switch backends, the SDK layer stays the same.
• Multi-language via relay proxy. A Go shop that also runs a React frontend and a Python data pipeline can use one flag server [website][2].
• Rich retriever support. S3, GCS, Azure, GitHub, GitLab, Kubernetes ConfigMap, HTTP — your flags can live wherever your config already lives [website].
• Advanced rollout strategies out of the box. Progressive rollout with time windows, scheduled changes, A/B testing variants — these are not afterthoughts [website][1][2].
• Lightweight. Runs on minimal resources, no JVM, no heavy framework [2].

Cons

• No admin UI for non-technical users. Flag management is YAML editing. Product and business stakeholders cannot self-serve [website]. This is a real blocker for teams where non-engineers need flag control.
• Small community. At 1,968 stars, it’s a fraction of Unleash (12,000+) or GrowthBook (7,500+) [5]. Fewer integrations, fewer guides, slower issue resolution.
• No built-in experimentation analytics. GO Feature Flag can export A/B test exposure data to Kafka or S3, but statistical analysis is your problem. GrowthBook, for comparison, has a built-in stats engine [5].
• No managed cloud option. Self-host or nothing. No fallback if you need to start fast and set up infrastructure later.
• Single core maintainer risk. The project is primarily maintained by one person. Long-term bus factor is a concern for production-critical infrastructure.
• Limited observability without configuration. Flag evaluation metrics require setting up an exporter (OpenTelemetry, S3, etc.). Out of the box, you’re flying blind on usage data.

---

Who should use this / who shouldn’t

Use GO Feature Flag if:

• You’re a Go-first team (or polyglot team) that’s currently paying $150–$500/mo for a commercial feature flag platform and finds the price hard to justify.
• You’re comfortable managing a YAML config file and want flags to live in your existing Git workflow.
• You want OpenFeature compliance so your flagging code isn’t locked to a specific vendor’s SDK interface.
• Your infrastructure already includes S3, GCS, or GitHub — the flag file fits naturally there.
• Privacy or compliance requirements prevent sending user evaluation data to external SaaS.

Skip it (pick Unleash instead) if:

• You need a mature open-source option with a proper admin UI, role-based permissions, and a larger community behind it [5].
• Your team includes non-technical stakeholders who need to manage flags without touching config files.
• You want enterprise features (audit logs, SSO, advanced segmentation) with open-source as a foundation.

Skip it (pick GrowthBook instead) if:

• Experimentation and A/B test statistical analysis are core to your workflow — GrowthBook has a built-in stats engine, GO Feature Flag does not [5].

Skip it (pick Flipt instead) if:

• You want a single-binary deployment with OpenFeature support and a slightly larger community, without the file-retriever architecture [5].

Skip it (stay on LaunchDarkly/Statsig) if:

• Your team needs a managed platform with SLA guarantees, 24/7 support, and a polished UI for non-engineers [4].
• You have no engineering capacity to run and maintain self-hosted infrastructure.

---

Alternatives worth considering

• Unleash — the most mature open-source option, Apache 2.0 core, 12,000+ stars, Node.js + Postgres, proper admin UI, managed cloud available. Steeper operational overhead [5].
• GrowthBook — MIT, 7,500+ stars, best-in-class experimentation analytics, built-in stats engine. More complex setup than GO Feature Flag [5].
• Flipt — GPL 3.0, 4,000+ stars, single binary deployment, first-class OpenFeature support, simplest self-hosting in the category. Closest architectural competitor [5].
• Flagsmith — BSD 3-Clause, 5,000+ stars, strong remote config capabilities beyond pure feature flags, managed cloud available [5].
• LaunchDarkly — the commercial incumbent. Best UI, largest SDK catalog, most expensive. Worth it if you’re not ready to own infrastructure [4].
• Statsig — commercial, “unlimited free feature flags” with analytics and experimentation built in. Viable middle ground if self-hosting is too much [4].

---

Bottom line

GO Feature Flag earns its place for a specific team profile: engineers who want proper feature flags (not a hand-rolled boolean map), already know how to deploy a Docker container, and refuse to pay a feature flag SaaS bill that only ever goes up. The file-based retriever architecture is the standout idea — it means zero database overhead, and your flag history is just Git history. The OpenFeature commitment is smart long-term positioning. The trade-offs are real: no admin UI means non-technical teammates can’t self-serve, the community is small relative to Unleash or GrowthBook, and there’s no managed cloud fallback if you need to move fast. If you’re comparing it to commercial platforms purely on cost, the math is obvious. If you’re comparing it to Unleash or Flipt, it wins on operational simplicity and loses on community size and feature breadth. For a backend-heavy team that lives in Git and wants to stop paying a per-seat SaaS bill for what is fundamentally a YAML file with an API in front of it, GO Feature Flag is a solid, honest choice.

---

Sources

1. OneUptime Blog — “How to Use Feature Flags in Go” (2026-01-07). https://oneuptime.com/blog/post/2026-01-07-go-feature-flags/view
2. Klutch.sh Documentation — “Deploying GO Feature Flag”. https://docs.klutch.sh/guides/open-source-software/go-feature-flag/
3. Unleash Documentation — “Go feature flag examples”. https://docs.getunleash.io/guides/feature-flag-examples-golang
4. Statsig — “7 Best Free Feature Flagging Tools in 2025” (2025-07-21). https://www.statsig.com/comparison/best-free-feature-flagging-tools
5. FlagShark — “Open Source Feature Flag Tools Compared: Unleash vs GrowthBook vs Flipt vs Flagsmith” (2026). https://flagshark.com/blog/open-source-feature-flag-tools-compared-2026/

Primary sources:

• GitHub repository and README: https://github.com/thomaspoignant/go-feature-flag (1,968 stars, MIT license)
• Official website: https://gofeatureflag.org