Analysis of alternative Feature Flag software
Tags: featureflags, saas, productivity
Published: 2020-05-26 14:03:16

With such a fast-moving software industry, competing companies aiming to provide solutions to our development needs are popping up at a faster pace, with more impressive solutions than ever before. Too often, however, we may fall victim to using the most widely adopted software instead of looking at what alternative companies have to offer where we might find something rather special.

In this article, we are going to look at alternative Feature Flag services to use instead of the market leader Feature Flag service, LaunchDarkly. Since its launch in 2013, LaunchDarkly has gained definite market control over the SaaS Feature Flag industry. While there is no doubt that LaunchDarkly is a great service, there is a plethora of alternative software from companies aiming to deliver high-quality Feature Flags, with additional advantages over LaunchDarkly, such as price, functionality, and ease of use. So With that said this article has in no means been made to bring a negative light to the service, it is more to shed light on the other services that you could use. And hey, if none of these services are for you, you can always use LaunchDarkly.

So with that, all said let's start taking a look at other alternative companies and see what they bring to the table by discussing a bit about what the company offers, their pricing, as well as a small code example of showing how to use their software. All the necessities to get you caught up. And just to make it clear, these companies are not ordered by personal preference, I'm just a fan of alphabetical ordering. :)



## Appknobs
![Appknobs](https://dev-to-uploads.s3.amazonaws.com/i/bny35ol2amtohh49xh9s.png)

Appknobs have set themselves apart from the rest of the Feature Flag market by building a front-end, declarative feature-flag management solution that makes Appknobs the one-stop-shop for React-based developers or anyone who has the itch to flesh out their front-end projects. It's easy and intuitive for front end developers to use, and because Appknobs is declarative, they have a pretty neat flag auto-discovery tool that lets devs easily add feature tags, parse their code, and display flags in the admin panel all in a matter of seconds. However, where Appknobs falls short is by having a lack of external integrations and analytics, but this is a feature they are planning to add in the future.

**pricing**

Appknobs offer three package types for your ideal use case:

*   A free plan that allows one application and one flag feature to be created. 
*   A Startup plan which includes unlimited flags on one application for the price of £6.00/month
*   Finally, they offer a Premium plan that you can try for free for 30 days. This is the ideal package they offer for agencies or larger projects at a monthly rate of £29.00 per month.

**Example**

As you can see in the example below, inserting Appknobs is really simple and will fit into your programs without any problems while providing a great way to use Featuring Flags.

```
import * as React from 'react'

import {render} from 'react-dom'

import {Appknobs, Feature} from '@appknobs/react'

import {newBrowserClient} from '@appknobs/client'

const App = ({client, stage}) => (

  <Appknobs client={client} payload={{stage}}>

      <Feature name='first-feature'>

        <p>This feature is hidden behind a toggle!</p>

      </Feature>

  </Appknobs>

)

const client = newBrowserClient({apiKey: 'YOUR_API_KEY', appId: 'YOUR_APP_ID'})

render(<App client={client} stage={'dev'} />, document.querySelector('#root'))

```

**Available SDKs**

*   React
*   React Native
*   Angular
*   Electron
*   Node.js (server-side)



## Apptimize
![Apptimize](https://dev-to-uploads.s3.amazonaws.com/i/lr55yhyve0tjqr5ud18k.png)

What makes Apptimize stand out is its outstanding mobile first-class solution for quick and easy testing. They are the most widely used mobile A/B testing and release management solution, so if mobile is your preferred platform, this is most likely your service. Apptimize enables more stakeholders to test across the company using their visual editor for mobile devices and using "dynamic variables." Apptimize also enables goal-based results so that you can automatically pull events from third parties and see the direct business impact of your tests. They also offer a wealth of integration from [third party applications]([https://apptimize.com/docs/third-party-integrations.html)

**Pricing**

Apptimize works their pricing in a very fairway. Instead of paying for a certain amount of features that you may not actually make full use of, you are billed from each of your monthly devices. All customers have full access to Feature Flags, A/B Experiments, and Instant Updates with no limitations on metrics, experiments, events, or seats.

**Example**

Implementation of Apptimize is as easy as it can be. All you need is a simple property value and installed library, then you're good to go!

```
if (Apptimize.isFeatureFlagOn("risky_new_feature")){

 // ON

 [show risky new feature]

} else {

 // OFF

 [hide risky new feature]

}

```

**Available SDKs**

*   iOS
*   Android
*   React Native (mobile)
*   JavaScript
*   Roku
*   Java (server)
*   Node.js (Server)
*   PHP (Server)
*   Python (Server)



## Bullet Train
![Bullet Train](https://dev-to-uploads.s3.amazonaws.com/i/ipynvaoc6isuhe4vmve4.png)

Bullet Train has built its product by combining the concepts of feature toggles with the flexibility of remote configuration, all of which are integrated into a single stellar package. They offer a great deal of flexibility by enabling management across web, mobile, and server-side applications, and if that wasn't enough, they are completely open-source, allowing you to host all of their infrastructures on your own. Since Bullet Train is open-source, this also brings extra security benefits as you can inspect the code yourself to make sure there are no back doors. I have to commend Bullet Train, as I'm a sucker for anything open source, and it's great to see that they haven't decided to focus on the extra bells and whistles of Feature Flags that some users may not use (such as A/B testing analytics) and instead put all their effort into the key features of the Feature Flags.

**Pricing**

While Bullet Train is completely open-source, meaning you don’t have to give them a penny if you don’t want to, they do offer some priced plans with additional benefits:

*   Free: Up to 20k API calls per month, 1 Team Member
*   $29/month: Up to 250k API calls per month, 3 Team Members
*   $99/month: Up to 2M API calls per month, 10 Team Members
*   They also offer a negotiable custom plan which you can enquire about by calling them which offers Over 2M API calls or 10 team members

**Example**

The code below is a great example of the flexibility you have with BulletTrain. BulletTrain allows you to code your Feature Flags to your ideal use case with almost unlimited customization. 

```
var bulletTrain = require("bullet-train-nodejs");

bulletTrain.init({

    environmentID: "<YOUR_ENVIRONMENT_KEY>"

});

bulletTrain.hasFeature("header", '<My User Id>')

    .then((featureEnabled) => {

        if (featureEnabled) {

            //Show my awesome cool new feature to this one user

        }

    });

bulletTrain.hasFeature("header")

    .then((featureEnabled) => {

        if (featureEnabled) {

            //Show my awesome cool new feature to the world

        }

    });

```

**available SDKs**

*   Javascript/React/React Native
*   Node
*   Android
*   iOS
*   Java
*   Python
*   Ruby
*   .Net
*   REST



## ConfigCat
![ConfigCat](https://dev-to-uploads.s3.amazonaws.com/i/l3a5ntwlsd8ulxi8sxzt.jpeg)

ConfigCat was built with the idea of being the ideal Feature Flag service for teams. They've created a stress-free Feature Flag solution, in which they 've streamlined the process of using Feature Flags for their users so you don't have to mess around with unnecessary decisions while making sure their product is as intuitive as it's easy to set up and get started. If you choose ConfigCat as your flag feature service, you'll be up and running in 10 minutes, and if you have any issues, they have a Slack community channel that the teams devs almost immediately respond to, as well they offer a whole bunch of [integration options](https://configcat.com/#integrations). And if you weren't won over, they're also planting a tree for every subscription (10 trees for Unlimited Accounts!) and hey, we can't skip the fact that they have a lovely cat as their logo. Serious extra points for that in my eyes.

**Pricing**

ConfigCat offers an expansive, forever-free plan that includes all of the flag features that you may want to use such as segmentation, targeting, multi-factor authentication or support for SSO and more, but they do offer some very useful benefits if you decide to upgrade your flag feature game by purchasing a paid account:

*   Free plan: includes up to 10 Feature Flags, 1 product, and 2 environments
*   Professional plan: up to 100 Feature Flags, 3 products, 3 environments, and 1 tree planted all for the rate of €49/month.
*   Unlimited Plan: Well, this is as simple as it can be, everything they offer is unlimited! (Well, besides the trees, they plant 10 per month) at a rate of €199/month. 
*   Dedicated plan: This gives you the same benefits as the unlimited plan, as well as the dedicated infrastructure and domain name at a rate of €1499 per month.

**Example**

If the 10 minute startup guide found on ConfigCat 's homepage didn't win you over with how seamless integration is, I hope the example below will work. ConfigCat delivers a secure and easy Feature Flag implementation that you won't be disappointed with.

```
npm i configcat-node

```

```
const configcat = require("configcat-node");

let configCatClient = configcat.createClient("<SDK-KEY>");

const isDebugModeOn = await configCatClient.getValueAsync("isDebugModeOn", false);

console.log("Value of the Feature Flag called \"isDebugModeOn\": " + isDebugModeOn);

```

**Available SDKs**

*   .NET
*   Java
*   Server Side Javascript, such as NodeJS or Nuxt
*   Front-end JavaScript, such as Vanilla, Angular or React
*   React-Native
*   Android,
*   iOS
*   PHP, the plain-old one and frameworks like Laravel too
*   Python
*   Go
*   Ruby



## Flipt
![Flipt](https://dev-to-uploads.s3.amazonaws.com/i/3gxeah1006g09d4pxysg.png)

I have already gushed a bit about my love for open-source, so it shouldn't come as a surprise that I'm a fan of Flipt. Flipt is the only service in this article that doesn't offer any pricing plans, but that doesn't mean that they don't offer a great piece of technology. Their software comes with all the flagship services you would want, such as on/off toggles, rolling out features to a percentage of customers, and advanced segmentation. While there are advantages that the service is open source, such as greater security for the reasons mentioned earlier in this article, and that anyone can contribute, there are some caveats. Support is not as fast and reliable, there are no audit logs and there is currently no support for multiple environments and user management.

**Example**

Flipt's setup is simplicity at its finest, Flipt is a single binary with no external dependencies by default.

```
import flipt "github.com/markphelps/flipt-grpc-go"

client := flipt.NewFliptClient(conn)

flag, err := client.GetFlag(context.Background(), &flipt.GetFlagRequest{

                    Key: ‘show_coupon’,

            })

```

**available SDKs**

*   Any language supported by GRPC can be used by [generating a Flipt client](https://flipt.io/docs/integration/#generate)
*   GO
*   Ruby
*   Pythib
*   IOS
*   React



## Togglz
![Togglz](https://dev-to-uploads.s3.amazonaws.com/i/387t3mi1zc1gnfgizk4h.png)

Togglz has designed a Feature Flag service for businesses, such as start-ups and medium-sized organizations. The cool thing about Togglz is that they are language, framework, and platform agnostic. Another advantage of using Togglz is how seamless it is to set up since you don't need to install any libraries. Simply call the endpoint and digest the response, then you can store the result locally if you want to, or call the endpoint. Super simple right.

**Pricing**

Togglz has gone with a very simple way to set their prices that could leave something to be desired. On the one hand, I like the two simple options, but I also wish they had a middle ground.

*   Free: This includes 10 feature toggles, 2 environments, and 10,000 API requests per month
*   Pro: This comes with the added benefit of allowing more traffic, more environments and unlimited feature toggles, environments, and API requests 

**Example**

As discussed at the beginning of the Togglz section, we don't need any external libraries to get Togglz up and running. This makes integration seamless without fiddling around, which I'm sure you can appreciate.

```
const res = await fetch('<Togglz-API>');

const features = await res.json();

if (features.myNewThing) {

  // ...new feature code

}

```

**available SDKs**

Since Togglz is an agnostic platform, this means that Togglz does not have any SDKs out of the box, meaning that Togglz users need to write all that HTTP request logic (including caching, error handling, etc.).



## Unleashed-hosted
![Unleashed-hosted](https://dev-to-uploads.s3.amazonaws.com/i/9teqyqwn58qusc7j9p3d.png)

This brings us to the last Feature Flag service that we'll be looking at, but it's by no means the least favorable. Unleash-hosted is probably the most unique Feature Flag service I have discussed in this article. They offer two versions of their service, an open-source version, and a paid enterprise version. In a way, this combines the best of both worlds. If you want, you can self-host the entire service for free, or you can purchase an [enterprise version](https://www.unleash-hosted.com/open-source) bringing extra benefits such as premium support, and security/access benefits. They offer a vast range of Activation strategies from the get-go allowing you to enable or disable your features in production.

**Pricing**

Unleash-hosted offers a free trial for their type of paid account, starting at $50 a month.

**Example**

Similar to the example I've shown for Apptimize, Unleashed-hosted is just as easy to integrate. It's a simple library and property then you're in.

````
if (unleash.isEnabled("AwesomeFeature")){

 // some new magic

} else {

 // old boring stuff

}

```

**Available SDKs**

*   Java
*   Node.js
*   SinglePage JS
*   Go
*   Eliixir
*   .net
*   Ruby
*   Python



And with that, this brings us to the end of our look at the alternative Feature Flag software. As you can see, all of them share some similar traits. There's not one piece of software that I would criticize for the integration process, but it's the little things that count and will inevitably lead to your decision on which piece of software to use. I hope this article has drawn some attention to the alternative Feature Flag software that you can use and has given you some valuable information regarding each company I have discussed. They're all great on their own merits, and you're not going to be disappointed by whatever choice you choose.