Feature Flags in Go Services

Feature flags let Go teams deploy code to production while keeping new behavior off until validation completes - or flip a kill switch without rebuilding the binary.

Summary

A feature flag is a runtime decision: given a flag key and evaluation context (user, tenant, region), return enabled or disabled.

Go services evaluate flags in handlers, workers, and gRPC interceptors.

OpenFeature provides a vendor-neutral SDK; LaunchDarkly, Flagsmith, and in-house config services plug in as providers.

Flags complement canary deploys: canary shifts traffic between binaries; flags shift behavior within the same binary.

Recipe

Quick-reference recipe card - copy-paste ready.

import (
    "context"
    "github.com/open-feature/go-sdk/openfeature"
)
 
func checkoutHandler(client *openfeature.Client) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        enabled, _ := client.BooleanValue(r.Context(), "new-checkout", false, openfeature.EvaluationContext{})
        if enabled {
            newCheckout(w, r)
            return
        }
        legacyCheckout(w, r)
    }
}

When to reach for this:

• Dark-launching features during canary or blue-green deploys
• Gradual percentage rollouts to enterprise tenants
• Kill switches for risky integrations without emergency redeploy
• A/B experiments on API behavior or response shape
• Ops-controlled toggles (maintenance mode, read-only mode)

Working Example

package main
 
import (
    "context"
    "log/slog"
    "net/http"
    "os"
    "sync"
    "time"
)
 
// InMemoryProvider is a minimal flag backend for demos and tests.
type InMemoryProvider struct {
    mu    sync.RWMutex
    flags map[string]bool
}
 
func NewInMemoryProvider() *InMemoryProvider {
    return &InMemoryProvider{flags: map[string]bool{}}
}
 
func (p *InMemoryProvider) Set(key string, val bool) {
    p.mu.Lock()
    p.flags[key] = val
    p.mu.Unlock()
}
 
func (p *InMemoryProvider) BooleanEvaluation(_ context.Context, flag string, defaultValue bool, _ map[string]interface{}) (bool, error) {
    p.mu.RLock()
    defer p.mu.RUnlock()
    if v, ok := p.flags[flag]; ok {
        return v, nil
    }
    return defaultValue, nil
}
 
type FlagClient struct {
    provider *InMemoryProvider
}
 
func (c *FlagClient) Enabled(ctx context.Context, key string, def bool) bool {
    val, err := c.provider.BooleanEvaluation(ctx, key, def, nil)
    if err != nil {
        slog.Warn("flag eval error", "key", key, "err", err)
        return def
    }
    return val
}
 
func main() {
    provider := NewInMemoryProvider()
    // Default off - dark launch
    provider.Set("new-pricing", false)
    flags := &FlagClient{provider: provider}
 
    mux := http.NewServeMux()
    mux.HandleFunc("GET /price", func(w http.ResponseWriter, r *http.Request) {
        if flags.Enabled(r.Context(), "new-pricing", false) {
            w.Write([]byte(`{"amount":99,"engine":"v2"}`))
            return
        }
        w.Write([]byte(`{"amount":100,"engine":"v1"}`))
    })
    mux.HandleFunc("POST /admin/flags/{key}", func(w http.ResponseWriter, r *http.Request) {
        if r.Header.Get("X-Admin-Token") != os.Getenv("ADMIN_TOKEN") {
            http.Error(w, "forbidden", http.StatusForbidden)
            return
        }
        key := r.PathValue("key")
        provider.Set(key, r.URL.Query().Get("value") == "true")
        w.WriteHeader(http.StatusNoContent)
    })
 
    srv := &http.Server{Addr: ":8080", Handler: mux, ReadHeaderTimeout: 5 * time.Second}
    slog.Info("listening", "addr", srv.Addr)
    if err := srv.ListenAndServe(); err != nil {
        slog.Error("server stopped", "err", err)
        os.Exit(1)
    }
}

What this demonstrates:

• Default false for new flags - safe dark launch posture.
• Flag evaluation errors fall back to default (fail-safe to legacy path).
• Admin endpoint guarded by token for controlled enablement (production uses vendor UI or GitOps).
• Same binary serves both code paths; toggling does not require redeploy.

Deep Dive

How It Works

1. Provider fetches flag definitions from LaunchDarkly, Flagsmith, S3 JSON, or etcd.
2. SDK caches evaluations and streams updates (SSE or polling).
3. Application calls BooleanValue / StringValue at decision points with an evaluation context (user ID, org, region).
4. Observability logs flag key and variant in structured fields for incident correlation.

Evaluation Context

Pass context from JWT claims or API keys - never evaluate flags without identity for user-facing behavior.

OpenFeature vs Vendor SDK

Go Notes

// Evaluate once per request, pass decision down - avoid N+1 provider calls
func middleware(flags *FlagClient) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            ctx := context.WithValue(r.Context(), pricingFlagKey,
                flags.Enabled(r.Context(), "new-pricing", false))
            next.ServeHTTP(w, r.WithContext(ctx))
        })
    }
}

• Inject *openfeature.Client or your interface in main - test with a fake provider.
• For gRPC, evaluate in unary interceptors and attach to context.Context.

Gotchas

• Default true for new flags - a provider outage enables risky code for everyone. Fix: default false; explicit opt-in per environment.
• Flag checks in hot loops - calling the provider on every DB row. Fix: evaluate once per request or cache with TTL respecting stream updates.
• Inconsistent flag state across pods - stale cache after kill switch. Fix: use provider streaming; set short max cache TTL for critical flags.
• No audit trail - nobody knows who enabled payments-v2. Fix: use vendor audit logs or GitOps for flag config.
• Permanent flags - if flag branches become spaghetti. Fix: flag retirement tickets; delete dead paths after full rollout.
• Sensitive flags in logs - logging full evaluation context leaks PII. Fix: log flag key and result only.

Alternatives

FAQs

Related

• Enterprise Delivery Basics - env-backed flag example
• Shipping Go Services Safely at Enterprise Scale - flags in the delivery chain
• Release Strategy: Blue-Green & Canary for Go - traffic shifting
• Progressive Delivery & Automated Verification - verify before enabling flags
• Rollback Runbooks for Go Deployments - disable flags during incidents

Stack versions: This page was written for Go 1.26.x (Green Tea GC default, go fix modernizers - verify patch at build), chi (latest - verify at build), gin (latest - verify at build), echo (latest - verify at build), google.golang.org/grpc (latest - verify at build), sigs.k8s.io/controller-runtime (latest - verify at build), kubebuilder (latest - verify at build), tinygo (latest - verify board targets at build), wazero (latest - verify at build), and golangci-lint (latest - verify linter set at build).