copilot

Feature Management
Without Limits

Flipt is an open-source feature management platform you can truly own.
It's easy to set up, has no seat limits, and is built for developers from scale-ups to enterprises.

Feature Management
For Developers

Flipt is an open-source feature management platform that's fully self-hosted.
It's easy to set up, has no seat limits, and is built for developers from scale-ups to enterprises.

Most Feature Flag Solutions
Weren't Built For Developers

Existing solutions are meant to be implemented, not loved, by developers.

Limited Scale

Hosted solutions are prone to unplanned and unexplained downtime, and charge on a per-seat basis. Home-grown solutions cost too much to maintain at scale.

Not Dev Friendly

Current solutions are designed for product managers, lack support for modern development workflows (like GitOps) & live far from applications' source code.

Zero Customization

SaaS solutions don't support customization, and home-grown solutions require significant resources to support all the features you need.

Feature Flags Reimagined For Developers

A (truly) open-source, fully-featured, developer friendly feature management platform that removes speed, scale, technology and capacity limits.

A Comprehensive Feature Set

Yes, Flipt can do that

Flipt supports a large and varied set of use cases due to a highly-configurable flag definition, including all the features you would expect (and more):

  • Multi-variant flags that return a specific string or boolean flags that can change rollout over time.
  • Unlimited flag targeting, where entities can be users, services, groups, individuals, or anything else you want to flag.
  • Namespaces to organize your flags, segments, rules and any other relevant pieces of data.
GitOps Workflow
Works where you do

Developer-first workflows baked into the platform

Flipt enables faster development by integrating into your existing tool stack and allows you to easily mimic  production flag data locally.

  • Integrate with GitOps workflows to make changes to both code and feature flags in the same pull request.
  • Evaluate any Flipt flag from your command line with Flipt CLI, using any relevant context as input.
  • Automate workflows with our GitHub Action to make sure your deployed application and the flag system are in sync.
Modern Feature Management

Fast, reliable & secure feature flags

Flipt was built from the ground up with modern technologies, can be completely self-hosted, is easy to set up and built for speed, security & scale.

  • Plays nicely with cloud-native technologies including Kubernetes.
  • Supports REST API and gRPC out of the box to enable language-agnostic integration and always up-to-date SDKs.
  • Written in Go & compiles to a single binary that can run on any modern platform.
Flipt Integrations
plug-and-play feature flags

Easily integrate with any environment

Flipt doesn't require you to run a specific database - or any database at all - and offers a simple, modern and unopinionated operating pattern.

  • Supports SQLite, PostgreSQL, CockroachDB, MySQL, LibSQL/Turso
  • Supports GitOps by serving flag state from Git, OCI (Docker) repositories, or any major cloud blob store (S3, Google Cloud Storage, Azure Container Store).
  • Integrates with top observability/metrics tools such as OpenTelemetry, Prometheus, and Grafana.
  • Works great in air-gapped and highly-regulated, secured on-premise environments.

We Speak Your
Language(s)

Flipt maintains server-side, client-side, and OpenFeature SDKs for most popular programming language. Let us know if your language is missing!

const resp = await flipt.evaluation.variant({
  namespaceKey: "production",

  flagKey: "ui-color",

  entityId: "user-123",

  context: {

    platform: "web",

  },
});

if (resp.variantKey === "dark") {

  // show dark UI

}

resp, _ := flipt.Variant(ctx, &evaluation.EvaluationRequest{
 NamespaceKey: "production",
 FlagKey: "ui-color",
 EntityId: "user-123",
 Context: map[string]string{
   "platform": "web",
 },
})

if resp.VariantKey == "dark" {
 // show dark UI
}

resp = flipt.evaluation.variant(
  namespace_key="production",
  flag_key="ui-color",
  entity_id="user-123",
  context={    
    "platform": "web",
  }
)

if resp.variant_key == "dark":
 # show dark UI

EvaluationRequest req = EvaluationRequest.builder().
   namespaceKey("production").
   flagKey("ui-color").
   entityId("user-123").
   context(Map.of("platform", "web")).
   build();

VariantEvaluationResponse resp = flipt.evaluation().variant(req);

if (resp.getVariantKey().equals("dark")) {
 // show dark UI
}

let resp = flipt.variant(&evaluation::EvaluateRequest {
       namespace_key: String::from("production"),
       flag_key: String::from("ui-color"),
       entity_id: String::from("user-123"),
       context: std::collections::HashMap::from([(
           String::from("platform"),
           String::from("web"),
       )]),
       ..Default::default()
   })    
    .await

if resp.variant_key == "dark" {
   // show dark UI
}

$resp = $flipt->variant('ui-color', ['platform' => 'web'], 'user-123');

if ($resp->getVariantKey() === 'dark') {
   // show dark UI
}

const fliptEvaluationClient = new FliptEvaluationClient();

const variant = fliptEvaluationClient.evaluateVariant("ui-color", "user-123", { platform: "web" });

evaluationClient, _ := flipt.NewClient()

defer evaluationClient.Close()

variantResult, err := evaluationClient.EvaluateVariant(context.Background(), "ui-color", "user-123",   map[string]string{
    "platform": "web",
  }
)

flipt_evaluation_client = FliptEvaluationClient()

variant_result = flipt_evaluation_client.evaluate_variant(flag_key="ui-color", entity_id="user-123", context={"platform": "web"})

const fliptClient = await FliptEvaluationClient.init();

const variant = fliptClient.evaluateVariant('ui-color', 'user-123', { platform: 'web' });

FliptEvaluationClient fliptClient = FliptEvaluationClient.builder()
                    .build();

Map<String, String> context = new HashMap<>();
context.put("platform", "web");

Result<VariantEvaluationResponse> result =
    fliptClient.evaluateVariant("ui-color", "user-123", context);

client = Flipt::EvaluationClient.new()

resp = client.evaluate_variant({ flag_key: 'ui-color', entity_id: 'user-123',
    context: { platform: 'web' }
})

const provider = new FliptProvider();
OpenFeature.setProvider(provider);

const client = OpenFeature.getClient();
const value = await client.getBooleanValue('new-ui-enabled', false, {
  targetingKey: 'user-123',
});

openfeature.SetProvider(flipt.NewProvider())

client := openfeature.NewClient("sync")

value, err := client.BooleanValue(
  context.Background(), "new-ui-enabled", false, openfeature.NewEvaluationContext("user-123"),
)

const provider = new FliptWebProvider();
await OpenFeature.setProviderAndWait(provider);

const evaluationCtx: EvaluationContext = {
  targetingKey: 'user-123',
  platform: 'web',
};

await OpenFeature.setContext(evaluationCtx);
const client = await OpenFeature.getClient();

const value = client.getBooleanDetails('ui-color', false);

OpenFeatureAPI.getInstance().setProviderAndWait("sync", fliptProvider);

client = OpenFeatureAPI.getInstance().getClient("sync");

MutableContext evaluationContext = new MutableContext();
evaluationContext.setTargetingKey("user-123");

value = fliptProvider.getBooleanEvaluation("new-ui-enabled", false, evaluationContext).getValue());

Enterprise-grade
Speed, Security, And Scale

All the features developers need to manage feature flags within their existing workflows at scale.

GitOps-first

Sync feature flags with your Git workflow repositories and user your existing CI/CD pipeline to deploy changes.

Auditable

Automatically keep audit logs to see who made changes and remain compliant.

Easy integration

Supports OpenFeature and SDKs for languages like JavaScript, Go, Ruby, Rust, Java, Python and more.

Secure

Supports HTTPS, OpenID Connect, Kubernetes, JWT, and Static Token Authentication, and SSO including Okta, Auth0, or Google.

gRPC enabled speed

Flipt works with your existing services over REST or gRPC to enable low latency at scale.

Pluggable storage

Choose your persistence layer. Postgres, MySQL, CockroachDB, Object Store, Git, and more.

Dedicated Support
SAML / SSO and RBAC
Directory Sync Enabled
Hosted Metrics
Managed Audit Logs

Flipt Hybrid Cloud has No Limits

Need more features? 

Flipt's fully managed feature management solution provides unlimited users, flags, and environments with all of the enterprise-grade features you need.

Trusted by Developers, Proven in Production

Learn how leading engineering teams use Flipt to gain better control over feature releases and improve their continuous delivery practices.

"At Paradigm, we prioritize speed, security, and simplicity in our release operations, and 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

Software Architect

Paradigm

“Flipt has allowed Rokt to dynamically turn on features, enable bulkheads for failure recovery, test experiments in production, and maintain low latency and high availability throughout the course of operations."

Dan Piet

Director of Engineering

Rokt

"Flipt has allowed us to control every aspect of our product with a fine tooth comb, ensuring that features experiencing issues are properly handled, or features that need a timed rollout are done so with precision."

Connor Wright

Lead Developer

AsphaltBot

"Flipt is a performance-focused and self-hostable feature flag platform with an intuitive flag model that's flexible enough to support multiple feature-management use cases across Allocate's stack.  As a startup, it was an easy choice compared to the other vendor offerings out there and their dev team has been a joy to collaborate with."

Jeremy Caron

VP of Engineering

Allocate

"At Paradigm, we prioritize speed, security, and simplicity in our release operations, and 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

Software Architect

Paradigm

“Flipt has allowed Rokt to dynamically turn on features, enable bulkheads for failure recovery, test experiments in production, and maintain low latency and high availability throughout the course of operations."

Dan Piet

Director of Engineering

Rokt

"Flipt has allowed us to control every aspect of our product with a fine tooth comb, ensuring that features experiencing issues are properly handled, or features that need a timed rollout are done so with precision."

Connor Wright

Lead Developer

AsphaltBot

"Flipt is a performance-focused and self-hostable feature flag platform with an intuitive flag model that's flexible enough to support multiple feature-management use cases across Allocate's stack.  As a startup, it was an easy choice compared to the other vendor offerings out there and their dev team has been a joy to collaborate with."

Jeremy Caron

VP of Engineering

Allocate

"At Paradigm, we prioritize speed, security, and simplicity in our release operations, and 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

Software Architect

Paradigm

“Flipt has allowed Rokt to dynamically turn on features, enable bulkheads for failure recovery, test experiments in production, and maintain low latency and high availability throughout the course of operations."

Dan Piet

Director of Engineering

Rokt

"Flipt has allowed us to control every aspect of our product with a fine tooth comb, ensuring that features experiencing issues are properly handled, or features that need a timed rollout are done so with precision."

Connor Wright

Lead Developer

AsphaltBot

"Flipt is a performance-focused and self-hostable feature flag platform with an intuitive flag model that's flexible enough to support multiple feature-management use cases across Allocate's stack.  As a startup, it was an easy choice compared to the other vendor offerings out there and their dev team has been a joy to collaborate with."

Jeremy Caron

VP of Engineering

Allocate

Feature Management
Done right,
without limits.

Get started today and experience the power of enterprise-grade, open-source feature management built for developers.