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.
Trusted by Innovative Teams Worldwide
In-house &
SaaS Feature Flags
Have Too Many Limits
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.
Feature flagging without any limits
Flipt removes all limits from Feature flagging, so scale-ups and enterprises have all the features they need to scale without slowing down or worrying about costs or capacity.
- Unlimited seats, environments, namespaces, or flags so you can flag anything you want without limits.
- Pre-built authentication support, so you can easily get started, including Auth0, GitHub, Google Workspace, and Okta.
- Enterprise-grade features including consistently maintained audit logs and analytics.
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.
.png)
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.
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.
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.
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."
Software Architect
“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."
Director of Engineering
"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."
Lead Developer
"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."
Software Architect
“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."
Director of Engineering
"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."
Lead Developer
"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."
Software Architect
“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."
Director of Engineering
"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."
Lead Developer
Feature Management
Done right,
without limits.
Get started today and experience the power of enterprise-grade, open-source feature management built for developers.
