Feature Flags
Meet Git
Flipt Cloud is a fully managed feature flag solution that enables you to keep your feature flags and remote config next to your code.
Trusted by Innovative Teams Worldwide
Feature Flags That Live
Alongside Your Code
Feature flags are mission critical to facilitate continuous delivery and safe deployments. They should reside alongside your existing configurations within your codebase.
Release, Rollback, and Audit
Using Familiar Tooling
Harness the power of Git to effectively manage feature flags in a declarative, auditable and version controlled format.
Synchronize Development And Production
Flipt Cloud enables your local and CI environments to stay in sync with your production feature flags, ensuring smooth releases.
Managed Access Control
Define custom roles and permissions for your team members or use our built-in roles. Integrate with your existing SSO or SCIM provider for effortless user management.
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 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
"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."
VP of Engineering
"We’ve been using Flipt for 9 months now and have been very happy with it. What I like most is that it’s clearly developed according to very high engineering standards. Great docs, clear APIs, easy setup, removes roadblocks without creating new ones. They also have been very receptive to suggestions and code contributions."
Lead Product Engineer
"Flipt is such a perfect representation of how feature flags should work. No question. Flipt is the way to go. As soon as I get people bought in, and understanding the idea, they freaking love it."
Founding Engineer
"This is cool as f*ck."
Founder/CEO
We Speak Your
Language
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
var req = EvaluationRequest.builder().
namespaceKey("production").
flagKey("ui-color").
entityId("user-123").
context(Map.of("platform", "web")).
build();
var 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' });
var client = FliptEvaluationClient.builder().build();
var response = client.evaluateVariant("ui-color", "user-123", Map.of("platform", "web"));
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);
var client = OpenFeatureAPI.getInstance().getClient("sync");
var evaluationContext = new MutableContext();
evaluationContext.setTargetingKey("user-123");
var value = fliptProvider.getBooleanEvaluation("new-ui-enabled", false, evaluationContext).getValue());
Fits In Your Stack
Flipt Cloud ensures your data remains secure within your organization’s Git repositories while seamlessly integrating with Flipt Open Source.
Continue leveraging Flipt Open Source to deploy in your infrastructure for limitless scaling and integration with your existing stack.
Enterprise-Grade
Speed, Security, And Scale
All the features developers need to manage feature flags within their existing workflows at scale.
GitOps-First
Manage features through Flipt Cloud and have your changes flow directory into Git repositories that you own.
Auditable
Automatically keep an audit trail using Git commits 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
Login with GitHub, Google, and more. Easily configure Single Sign On and SAML authentication. Use our built in RBAC roles for authorization, or create your own.
Fully Managed or Self-Hosted
Self hosted Flipt works along side Flipt Cloud to integrate with your existing services over REST or gRPC to enable low latency at scale.
1-1 Support
Our Team plan includes a dedicated Slack support channel to ask questions and get help directly from a Flipt engineer.
Git Started Today
With Flipt Cloud
Experience the power of our enterprise-grade, Git-native feature management platform built for developers.
