Deploy and Host Flipt

Flipt is a performance-focused, open-source feature flag platform that lets development teams control feature rollouts, run A/B tests, and toggle code paths dynamically — without redeploying applications. Built in Go as a single binary, it's designed for teams who want full ownership of their flag data with no vendor lock-in or per-seat pricing.

Self-host Flipt on Railway with this one-click template and get a production-ready stack pre-wired with PostgreSQL for persistent flag storage and Redis for sub-millisecond evaluation caching — all connected via private networking out of the box.

Getting Started with Flipt on Railway

Once your Railway deployment is live, navigate to the public URL assigned to your Flipt service. The dashboard is accessible on port 8080 — Railway will expose this automatically via the generated domain. From the UI, create your first namespace and define feature flags using the Flags section in the sidebar. Authentication is disabled by default in this template (FLIPT_AUTHENTICATION_REQUIRED=false), so you can start experimenting immediately. When you're ready to lock down access, set FLIPT_AUTHENTICATION_REQUIRED=true and rotate the bootstrap token stored in FLIPT_AUTHENTICATION_METHODS_TOKEN_BOOTSTRAP_TOKEN.

About Hosting Flipt

Flipt is an enterprise-ready, Git-native feature management platform written in Go. It stores flag configuration in PostgreSQL (this template) or directly in Git repositories as YAML, and evaluates flags over both gRPC and REST APIs. Key features include:

• Flag types: Boolean flags, multivariate flags, and percentage rollouts
• Targeting rules: Segment users by custom constraints and attributes
• OpenFeature support: Compatible with the vendor-neutral OpenFeature evaluation standard
• SDKs: Client-side (JS/TS, React, Android) and server-side (Go, Python, Ruby, Java, .NET, PHP, Node)
• Redis caching: Millisecond-level evaluation latency at scale
• REST + gRPC APIs: Evaluate flags from any language or framework
• Web UI: React-based dashboard for non-CLI flag management

In this template, Flipt connects to PostgreSQL over Railway's private network for flag storage and to Redis for caching evaluated responses. The cache TTL is set to 60 seconds by default.

Why Deploy Flipt on Railway

Deploying Flipt manually means configuring Postgres connections, Redis caching, networking, and TLS yourself. This template removes all of that:

• Zero Docker or Compose configuration — deploy in one click
• Private networking between Flipt, Postgres, and Redis out of the box
• Managed TLS and custom domains via Railway
• Environment variables pre-wired; no manual service discovery
• Scale any service independently from the Railway dashboard
• Open-source with no license cost — pay only for infrastructure

Common Use Cases

• Progressive feature rollouts: Ship a new feature to 5% of users first, monitor error rates, then gradually expand to 100% — all without a redeploy
• Kill switches: Instantly disable a broken feature in production without touching code or triggering a deployment pipeline
• Environment-specific flags: Enable experimental features in staging while keeping them hidden in production using namespace separation
• A/B testing foundations: Target specific user segments with different flag variants to compare behaviour before full rollout

Flipt vs Competitors

Flipt is the strongest choice for teams that want 100% open-source feature flagging with no paid tiers, Git-native workflows, and minimal operational overhead — especially on infrastructure like Railway.

Dependencies for Flipt

• flipt/flipt:latest — official Flipt Docker image (Go binary, flipt.io)
• PostgreSQL — persists flag definitions, namespaces, segments, and rules
• Redis — caches evaluated flag responses; reduces database load at high evaluation rates

Environment Variables Reference

Deployment Dependencies

• Runtime: Go binary — no external runtime required
• Docker image: flipt/flipt:latest (Docker Hub)
• GitHub: github.com/flipt-io/flipt
• Docs: docs.flipt.io

Server Requirements to Self-Host Flipt

Flipt's Go binary is exceptionally lightweight. Community benchmarks report under 50 MB RAM usage even with thousands of flags in memory.

Add roughly 200–300 MB for the PostgreSQL service and 64–128 MB for Redis when sizing your Railway plan.

Self-Hosting Flipt

Docker (standalone with SQLite):

docker run -d \
  --name flipt \
  -p 8080:8080 \
  flipt/flipt:latest

Docker with PostgreSQL and Redis:

# docker-compose.yml
services:
  flipt:
    image: flipt/flipt:latest
    ports:
      - "8080:8080"
    environment:
      FLIPT_DB_URL: "postgresql://postgres:password@postgres:5432/flipt"
      FLIPT_CACHE_ENABLED: "true"
      FLIPT_CACHE_BACKEND: "redis"
      FLIPT_CACHE_REDIS_HOST: "redis"
      FLIPT_CACHE_REDIS_PORT: "6379"
    depends_on:
      - postgres
      - redis

  postgres:
    image: postgres:16
    environment:
      POSTGRES_DB: flipt
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: password

  redis:
    image: redis:7
    command: redis-server --requirepass password

Then run docker compose up -d and access the UI at http://localhost:8080.

Is Flipt Free?

Flipt is 100% open-source under the GPL-3.0 license with no paid tiers, no seat limits, and no feature gates. The only cost is infrastructure. On Railway, a typical Flipt stack (app + Postgres + Redis) runs approximately $5–$15/month depending on traffic and data volume. Flipt also offers a managed Flipt Cloud option with Git-native workflows and zero self-hosting overhead — pricing is separate from the open-source project.

FAQ

What is Flipt? Flipt is an open-source, self-hosted feature flag platform built in Go. It lets engineering teams toggle features on or off for specific users without redeploying code, supporting progressive rollouts, kill switches, and A/B test variants.

What does this Railway template deploy? It deploys three services: the Flipt application server (flipt/flipt:latest) on port 8080, a PostgreSQL database for flag storage, and a Redis instance for evaluation caching. All three communicate over Railway's private network.

Why does this template include PostgreSQL? Flipt needs a persistent backend to store flag definitions, segments, rules, and namespaces across restarts. PostgreSQL is the recommended production backend. Without it, Flipt defaults to SQLite (file-based), which isn't suitable for multi-instance or cloud deployments.

Why is Redis included? Redis caches flag evaluation responses so Flipt doesn't hit the database on every evaluation request. At high request volumes this significantly reduces latency and Postgres load. The cache TTL in this template is set to 60 seconds.

Can I use Flipt in production? Yes. Flipt is used in production by teams at companies like Allocate and Rokt. The Go binary is stateless and scales horizontally. The main consideration for production is ensuring Postgres and Redis are appropriately sized and backed up.

Does Flipt support OpenFeature? Yes. Flipt implements the OpenFeature Remote Evaluation Protocol (OFREP), allowing you to use any OpenFeature-compatible SDK to evaluate flags against your self-hosted Flipt instance.

Is authentication enabled by default in this template? No — FLIPT_AUTHENTICATION_REQUIRED is set to false for ease of initial setup. Before going to production, set it to true and use the bootstrap token to generate API keys for your applications.