For Modern engineering and product teams

Ship with confidence, even on Friday nights!

The feature flagging platform that eliminates the risk of new feature releases. Developer teams deploy continuously and monitor the impact of features on technical infrastructure, while business teams control how features are released and their impact on users' experience and business KPIs.
We serve Enterprise teams
FitbodKlarnaTreatwellMeccaHumm GroupEDFPost NLOui.sncfYves RocherEurosport

We deliver much more than just switching features on and off

We push the concept of feature flags to the next level, giving you full control over how you release new features and who has access to them

Feature flags & toggles

Progressive  rollout
Continuous delivery
Test in production
Experimentation through API
Enterprise-grade architecture
Feature flags & toggles

Feature control at the flip of a switch

Enjoy the flexibility of remote configuration at scale. Managing feature flags on complex and multiple environments can get tricky. With Flagship, organize your flags any way you like, and create any flag type: Boolean, Number or String. Quickly see which user segments are exposed to which flags and their corresponding results. Scale at the pace of your ambition.
Manage your feature flags at scale
Progressively rollout to a percentage of your user base
Progressive rollout

Be confident when rolling out new features

Set deployment intervals, or percentages, to automatically roll out your features over time and monitor their reception with associated KPIs. You can also release to specific user segments and later extend to your entire user base if you are happy with the feature. Hit a snag? Deployment automatically rolls back when KPIs dip below a certain threshold. Minimize risk - and headaches - for your team.
Continuous delivery

Separate code deployments from feature releases 

Accelerate your development process by decoupling code deployments from feature releases. Engineering teams deploy code at their own pace, while product teams independently release features when they are ready. They can test in production and gather user feedback while developers focus on their next development cycle.
Feature flags overview
Test in production to measure impact on infrastructure
Test in production

Staging environments can only go so far

Relying on staging environments to test your code is limited and brings its own challenges, such as keeping both production and staging environments in sync. Moreover, “soak testing” (e.g.: testing a feature with a typical production load), is hard. With feature flags and user segmentation, you can easily see how your code performs using existing monitoring tools and adapt quickly.
Experimentation through API

A/B testing made for developers

Marketing teams rely on client-side testing platforms to run cosmetic changes but - when it comes to advanced scenarios - they end up calling upon developers who need extra flexibility to meet this demand. By wrapping code logic with feature flags, they easily assign feature variations to groups of users, while marketers still enjoy the convenience of a statistical engine to measure outcomes. Plus, since it's server-side based, they can run flicker-free A/B tests on any website, app or codebase.
Experimentation through API
Enterprise-grade features
Enterprise-grade architecture

Speed, scale and reliability to the core

Inserting a few IF statements in your codebase is easy, but maintaining a full-featured feature flag management platform requires time, resources and commitment. From data security and safeguards to scalable architecture through a fast decision engine that supports file bucketing users for increased performance and low latency, we make sure we exceed the most demanding technical requirements.
Feature Flag Setup
Multi-channel experiences

Ensure experience continuity

Manage feature flags across web, mobile and server side applications and make sure users who get assigned a specific value for a feature flag on one device get the same one on a different one.

We support your technology stack

Choose whatever implementation method works best for you:
our agnostic API or one of our available SDKs.

Built for performance and scale

Our architecture is based on multi-cloud providers that offer high performance and highly scalable managed services.

Bucketing file
response time < 5ms 

Global CDN with more than 200 PoPs
(Points of Presence) 

Decision API
response time  < 50ms

Global API endpoints with serverless compute services that auto-scale

data platform

Our infrastructure supports petabytes of events with more than 900 clients over the world

Packed full of features

Flagship is not just a feature management solution for developers.
We're also a top-notch experiment platform that suits product and marketing needs.

Feature flag as a Service

Control all your feature flags in an easy to use web dashboard. Update flags with no need to change the code and re-deploy.

Feature management templates

Reusable templates to speed up use cases implementation.

User segments & targeting

Roll out new features to only subsets of users, using any user attributes you have access to.

Experiment platform

Focus on outcomes, not outputs. Run A/B tests to track the business impact of feature releases.

Smart Decision API

Our API will take the decision for you, who should see what, based on our proprietary Multi-Armed Bandit algorithm.

Strong reports and data collect

Make informed decisions with best of breed reporting capabilities, including data filtering and export.

Agnostic API or SDKs

Choose whatever implementation method works best for you. From client to server-side, we've got you covered.

Support for web, mobile apps, IoT

Control your feature release on any environments: mobile native applications (iOS or Android), SPA, e-commerce websites, connected devices...

Experience continuity

Be consistent while experimenting on different devices and when visitors switch from anonymous to identified users.

Instant updates

Update your native mobile application without waiting hours or days for store validation.

Progressive rollout

Gradually release features while keeping a closed eye on metrics you care about. 

Automatic triggered rollback

Release risk-free by setting a rollback KPI to revert releases if this metric crosses
a certain threshold.

Kill switch

Wrap new or risky behavior with a flag. If something goes wrong or crash your app, shut it off quickly with a single click.

Premium local support

Benefit from bespoke onboarding and support from our Customer Success Managers and Technical Solution Engineers.

GDPR & CCPA compliant

As a European headquartered company, we’ve been aligning with Privacy standards since 2017.

ISO 27001 certified

We believe in trust and security. We do our best to ensure your data is safe. Learn more or view our ISO 27001 certificate.

Flagship integrates smoothly
into your workflow

Flagship is developer-friendly and easy to integrate with
User management

Get your team on board

Once you've created your account, invite your teammates. Flagship is designed to be used by product teams, developers and devops with fine control over user access.

It also accommodates your workflow. Use multiple environments, starting with your local machine, and easily scale to staging and production environments.

Wrap features with flags

Create flags from the Flagship dashboard (Boolean, String, Number...). Next, in your codebase, install one of our SDKs and wrap your feature in a flag using one the convenient method provided.

Alternatively, you can directly use our RESTful API that is language-agnostic by design. You can use Flagship even if your stack includes multiple programming languages or if you would like to experiment with languages for which we don't yet offer a dedicated SDK.
Setup Feature FlagsUser segmentation with context keys

Segment your user base

Depending on your use cases, you'll want to assign specific flag values to different user segments. For instance, logged-in users can be served one value and, therefore, be presented a specific feature, while non logged-in users will be served another value.

You can pass to the SDK / Decision API, a context object which holds the characteristics of the active user. This context will be used to adapt the API response, based on the configuration you set in the dashboard.

Set up your metrics and KPIs

Decide what KPIs to track in agreement with business stakeholders. The purpose of linking flags to business KPIs is twofold:

  • Show stakeholders the impact of your development on the end-users' experience or any technical metrics.
  • Demonstrate the benefits either via increased ROI or avoided income losses.

Flagship’s Universal Collect protocol provides a unified hit format to send data back to Flagship for reporting purposes. Read documentation.

Setup metrics in FlagshipUse case templates

You're all set up. Limitless use cases are now at your fingertips

Deploy code wrapped with flags straight to production. Don't worry! It's hidden for everyone. You activate features, right from the Flagship dashboard, whenever you're ready.

You can also run any of the following advanced scenarios: progressive rollout to a limited percentage of your audience or to specific user groups, automatic rollback based on triggers, full experimentations. Contact us for more use cases

Easy-to-use platform
 your developers will love

Getting started in a local environment is as easy as copying/pasting some lines of code.

Select a programming language
React Native

The following helps you run Flagship on your ReactJS environment (client-side or server-side). Flagship ReactJS SDK provides a <FlagshipProvider />, which makes Flagship features available to the rest of your app. These features are accessible using hooks.

Install the React Flagship SDK with npm or yarn.

npm install

Import the Flagship React provider. In most cases, you'll want to do this in your main App.js file to wrap your entire app with the provider.

Initialize the provider. You must at least include the required props like envId, apiKey, visitorData.

Use one of the Flagship hooks in your component to get the modifications.

The following documentation will help you get Flagship running in your JavaScript environment (client-side or server-side) with preconfigured methods to implement the Decision API.

Install the node module:

npm install

Import the library.

import flagship from ""; // ES6 ++
const flagship = require(""); // ES5

Initialize the library.

const fsInstance = flagship.start("YOUR_ENV_ID", "YOUR_API_KEY", {
  /* sdk settings */

Create a visitor id.

const fsVisitorInstance = fsInstance.newVisitor("YOUR_VISITOR_ID", {

When the visitor is ready, get modifications.

fsVisitorInstance.on("ready", () => {
  console.log("visitor is ready ! ✨");
  const { btnColor, btnText } = fsVisitorInstance.getModifications([
      key: "btnColor",
      defaultValue: "#ff0000",
      activate: true
      key: "btnText",
      defaultValue: "Wahoo !",
      activate: true
  console.log(btnColor); // output: "#fff"
  console.log(btnText); // output: "Awesome!"

Our Python SDK is available on To install it, simply run the following command in your Python environement in a terminal.

pip install flagship

Initialize the library using the start() function, passing a Config object as parameter.

from import Flagship
from flagship.config import Config
from flagship.handler import FlagshipEventHandler

class CustomEventHandler(FlagshipEventHandler):
    def __init__(self):

    def on_log(self, level, message):
        print("Log >> " + message)

    def on_exception_raised(self, exception, traceback):
        FlagshipEventHandler.on_exception_raised(self, exception, traceback)
        print("Exception >> " + str(exception))

 Flagship.instance().start("your_env_id", "your_api_key"

Set the user context. User context is a property dataset that defines the current user of your app. It is sent and used by the Flagship Decision API as targeting criteria for campaign assignment.

context = {

visitor = Flagship.instance().create_visitor("user_#1234")

visitor.update_context(('age', 31), True)

The synchronize_modifications() method of the visitor instance automatically calls the Flagship Decision API to run campaign assignments according to the current user context and retrieve applicable modifications.

visitor = Flagship.instance().create_visitor("user_#1234", {'isVip':True})

#Synchronize by passing True to update context.
visitor.update_context(('age', 31), True)

#Synchronize with stand alone function

Once the campaign has been assigned and synchronized, all the modifications are stored in the SDK. You can retrieve these modifications using the following functions from the visitor instance:

visitor = Flagship.instance().create_visitor("user_#1234", {'isVip':True})

vip_feature_enabled = visitor.get_modification('vip_feature', False)

Once a modification is displayed on the screen for a user, you must send an activate event to tell Flagship that the user has seen this specific variation. There are two options for activating a modification:

visitor = Flagship.instance().create_visitor("user_#1234", {'isVip':True})

#Method 1: Activation during get_modification
vip_feature_enabled = visitor.get_modification('vip_feature', True)

#Method 2: Activation from stand alone activate_modification
menu_order = visitor.get_modification('menu_order', False)

The following documentation will help you get Flagship running in your Go environment (server-side) with preconfigured methods to implement the Decision API & Bucketing.

Install the Go SDK

// Install from source
go get
cd $GOPATH/src/
go install

// Install using go.mod
module mymodule
go 1.12
require ( v2.0.2

// If you are already using go.mod in your application you can run the following:
go mod edit -require

To initialize and start the library, just call the Start function of the flagship package, using the bucketing function builder if you want to use the bucketing mode.

// Using the Decision API (default)
fsClient, err := flagship.Start(environmentID, apiKey)

// Using the Bucketing mode
fsClient, err := flagship.Start(environmentID, apiKey, client.WithBucketing())

User context is a property dataset that defines the current user of your app. It is sent and used by the Flagship Decision API as targeting criteria for campaign assignment. The SDK provides a method create a new visitor with an ID and a context.

// Create visitor context
context := map[string]interface{}{
  "isVip": true,
  "age": 30,
  "name": "visitor",
// Create a visitor
fsVisitor, err := fsClient.NewVisitor("visitor_id", context)

Synchronizing campaign modifications allows you to automatically call the Flagship decision API (or bucketing file), which makes the allocation according to user context and gets all their modifications. All the applicable modifications are stored in the SDK and are updated synchronously when SynchronizeModifications() is called.

// This function has no parameters

Once the campaign has been allocated and synchronized all the modifications are stored in the SDK. Then, you can retrieve them with the following functions:

discountName, err := fsVisitor.GetModificationstring("discountName", "Black Friday", true);

// If there is not error (and if there is, your value will still be set to defaut), you can use your modification value in your business logic
discountValue := getDiscountFromDB(discountName)

Once a modification has been printed on the screen for a user, you must send an activation event to tell Flagship that the user has seen this specific variation.

// Activate the modification automatically when retrieving it
color, err := Flagship.GetModificationString("discountName", "Black Friday", true)

// ---OR---

// Activate the modification later on manually
err := Flagship.ActivateModification("discountName")

Please refer to the SDK link below.

The following documentation helps you run Flagship on your React Native environment. Flagship React Native SDK provides a , which makes Flagship features available to the rest of your app. Flagship features are accessible using Flagship hooks.

Install the node module.

npm install
Import the Flagship React provider. In most cases, you'll do this in your App.js file to wrap your entire app with the provider.

Initialize the provider with the required props (envId, apiKey, visitorData).

Use a Flagship hook in a component to get the desired modifications.

Please refer to the SDK link below.
Please refer to the SDK link below.
Keep reading our developer docs

Find out why engineering and product teams love Feature Management platforms
"Progressive rollout lets us stop or fully rollout a test as soon as it reaches statistical significance without having to wait for a new publication of the app. If the chosen KPIs worsen, we can avoid prolonging a sub-optimal experience. On the other hand, if the test is positive, all of our clients can start feeling the benefits immediately."
Benoit Bouffart
Benoit Bouffart
Chief Tech & Product Officer
"We wanted to be quicker and more efficient in our releases, without increasing any risks. Flagship lets us do it, as well as running advanced experimentations to optimize our product."
Head of Product @ Weekendesk
Alexandre Duarte
Head of product
"It allows us to build advanced personalization scenarios. The platform is very easy to use, and we've been able to put in place our campaigns very quickly thanks to the availability of both Customer Success Manager and Support teams."
Kamran Shaikh
Kamran Shaikh
Senior Digital Marketing Manager
Why rollback a new feature is soooooo hard? And the problem is usually not in a technology.
How many feature flags does your app have? Answer: Not enough
This is why I'm a fan of feature flags over feature branches.

Are you ready to join these customers?

Getting started is easy. Be up and running in minutes.
Copy link