19 Apr

Starting a new chapter and my message to prospective LD designers

Wow, what a journey.

I joined LaunchDarkly in 2015 as employee #3 and first design hire. Every day since then, I learned something new about the product, the team, and myself. I learned from the best and brightest: from John and Edith’s unparalleled enthusiasm and leadership – to the engineering prowess of Alexis, Patrick, and Dan – to the marketing wizardry of Andrea.

For me, success is not how much money you can make… or your job title… or how many people you can manage… Success is the ability to be proud of what you have accomplished, to have helped others along the way, and to take care of your loved ones. It is also the ability to learn every day, to have a sense of wonder at the possibility of advancement, and to make a positive impact through your work.

Every single team member at LaunchDarkly is a genuinely good person. They are not here to play the Silicon Valley game, they are here to solve a problem with software releases and truly help companies deliver better software, faster. They envision a world where the LaunchDarkly product enables companies to accelerate innovation, spur new technology, and deliver more reliable software.

Though I love the team and I’m thrilled with the product, I’ve made the tough decision to start a new chapter in Southern California, home to my family and friends, at Ten-X (a happy LaunchDarkly customer!). I will miss LaunchDarkly dearly, but I know I did the best I could during my tenure.

Design at LaunchDarkly

If you’re a designer interested in LaunchDarkly, let me give you some insight into what it’s like to work here.

Imagine a team of engineers who are brilliant, humble, supportive, and funny (gifs upon gifs!). Working with this team day after day has been a privilege and a whirlwind of a learning experience. They do not cut corners when it comes to code quality and product. You will absolutely learn best practices, innovative strategies, and work with a state-of-the-art stack. You will 100% become a better, smarter designer and make an immediate impact on the product. I guarantee you will be truly proud of what you design and the quality of its programmatic execution.

Your job will not be to push pixels. You will be a systemic thinker – someone who takes ownership of the design process from start to finish. You will learn to love our customers and take a personal interest in their happiness by building a world-class user experience.

Not only that, but every team member at LaunchDarkly is a designer in their own right. While you will be the one who will take ownership of design, the team enjoys contributing feedback and ideas, making the entire process collaborative and company-wide.

To infinity… and beyond!

And on this note, I say goodbye to my second family as I make my transition from proud employee to happy customer. LaunchDarkly will continue to be the industry leader in feature flag management – a true disruptor and unicorn in the software development space. If you’re a designer and you’re thinking about LaunchDarkly, just do it.

14 Apr

Go Serverless, not Flagless: Implementing Feature Flags in Serverless Environments

A demonstration of LaunchDarkly feature flags with AWS Lambda

Serverless architecture, while a relatively new pattern in the software world, is quickly becoming a valuable asset in a variety of use cases.

There are some notable business advantages to serverless architecture:

  • Faster development – easily harness existing backend services and third party APIs to quickly build and deploy apps.
  • Lower cost – substantially decreased operational costs by not having to manage infrastructure in addition to the componentization of the entire application (only scale what you need to scale).
  • Less maintenance – scaling, load balancing, and patches are a thing of the past, serverless platforms take care of it all for us.

Coupled with feature flags, a serverless application allows teams to control feature releases without having to redeploy, which is especially useful for serverless applications that tend not to focus on persistence and be more stateless in nature.

In this article, we’ll start with the assertion that you have already decided that serverless functions makes the most sense for your application architecture. What you really need is the ability to continue using feature flags in this type of architecture. This is where LaunchDarkly has got you covered.

Let’s start with a simple app model that stores a bit of user data on demand and that can retrieve values when requested. This app is going to include the use of two AWS Lambda functions an API Gateway, and ElastiCache to build a serverless pipeline. AWS Lambda lets you run code without provisioning or managing servers.  On the other hand, LaunchDarkly is a feature flag management platform that allows you to easily create and manage feature flags at scale.

Storing Flag Configurations

AWS turns out to be a well-equipped platform for serverless feature flagging. In our implementation, we create a webhook in LaunchDarkly to hit an API Gateway endpoint which acts as a trigger for invoking a lambda function.

Then, the lambda function can have LaunchDarkly populate a Redis ElastiCache cluster by initializing its SDK with the built-in “RedisFeatureStore” option. This lambda function built on the NodeJS runtime would look something like this:

Processing Feature Flags

Now that our flag configurations are neatly stored in the Elasticache cluster, a second Lambda function may be used to retrieve and process flags without waiting for any outbound connections to LD! This is achieved by enabling LaunchDarkly Relay mode in the SDK options. The function’s “event” parameter can be used to pass in a user to be evaluated by the LaunchDarkly SDK.

Take Aways

It’s important to understand that there are multiple ways to implement feature flags in your serverless architecture.  The method will depend on your app’s structure, your serverless provider, and your implementation timeline. You can check out this guide to feature flagging for best practices and ways to get started.

 

07 Apr

Feature Flag Transition & Setup Guide

A step-by-step guide for integrating LaunchDarkly into your app and adopting feature flagging best practices

You’re now at a decision point. You want to buy a feature flagging management solution, but you are not sure how difficult the switch might be. You either have an existing system in place or you’ve never tried feature flagging before.

The transition process is actually not as daunting as you think. In fact, it’s an opportunity to clean up technical debt, mitigate risk, and start deploying better software, faster. From start to finish, this guide will walk you through the process of successfully integrating LaunchDarkly into your development process.

1. New Team Member Orientation

  • Use the QuickStart tutorial.  Create a feature flag for the platform of your choice using the step-by-step tutorial. We provide well-documented SDKs for Java, JavaScript, PHP, Python, Go, Node.JS, .NET, Ruby, Python Twisted, iOS, and Android.
  • Install LaunchDarkly in a test app.  In the QuickStart section, select “Install an SDK”.  Use this guide to install a simple feature flag in the test app of your choice. LaunchDarkly provides “hello-world” test apps to help you get familiar.
  • Check out our documentation. It’s important to understand the LaunchDarkly fundamentals.  In LaunchDarkly, feature flags are evaluated in-memory using one of our SDKs. Our user interface (app.launchdarkly.com) lets you create feature flags and targeting rules that are streamed to our SDKs in real-time.  You pass user objects to our SDKs, which evaluate the appropriate flag values for those users in microseconds. These feature flag events are sent asynchronously to LaunchDarkly, allowing you to easily manage users via our dashboard.
  • Start targeting users and playing with percentage rollouts.  Go to your feature flag dashboard and select a feature flag (docs).
    • On the targeting tab, you can:
    • Target individual users
    • Create custom targeting rules
    • Manage percentage rollouts
    • Set a default rule
    • Set an off variation
  • Create a multivariate flag. LaunchDarkly can do more than just evaluate true and false feature flags. Create multivariate flags that have multiple flag variations. These variations can be strings, numbers, and JSON arrays/objects.

2. Select a coordinator and document the transition

Your coordinator will take ownership of the transition process.

  • This coordinator should be familiar with feature flagging best practices and serve as the primary contact between your organization and LaunchDarkly.
  • Construct a document and/or use your issue tracker to itemize the switch. This is an opportunity to implement best practices in your development and release process.

3. Separate feature flags from configuration values

Scan your application and identify your feature flags.

  • It’s important to understand what a feature flag is, and what it isn’t.
  • The primary purpose of a feature flag is to control access to a feature based on the context of a user. On the other hand, a configuration value is primarily used to configure a permanent parameter, irrespective of a user’s context.
  • Feature flag use cases
    • Roll out a new checkout flow to 1%, 10%, and 100% of your users
    • Toggle a new beta feature for your beta testers
    • Sunset a poorly performing feature
    • Manage a long-term state, like maintenance mode or subscription plans
    • Serve a new upgrade to users who live in Canada and have an Android phone
  • Configuration value use cases
    • Set the hostname for your application server
    • Set authentication credentials and settings for services and backend stores
    • Set static rate limits for your application service
    • Set a directory path for data storage

4. Clean up technical debt by removing old flags

Remove the feature flags you don’t want anymore

  • This process is an opportunity to mitigate technical debt and remove all of the clutter from the past. LaunchDarkly has flag statuses that indicate when you particular feature flags are safe for removal.

5. Identify components that you would like to flag

Now that feature flagging will be easy, you should identify components of your application or particular processes that you would like to feature flag.

  • LaunchDarkly supports both boolean and multivariate feature flags. Boolean flags return true and false, but multivariate flags can return strings, number, JSON objects/arrays. You should hold a brainstorming session where everyone can identify the existing components they would like to flag.

6. Setting up your feature flags

If you have existing flags, you can use LaunchDarkly’s REST API to import your existing flags.

  • You can also use the API to bulk create new flags or simply use the LaunchDarkly UI.

To organize and document your feature flags, LaunchDarkly lets you add a name, description, and tags to each feature flag.

  • You can also name and provide descriptions for variations
  • Your team should decide the best ways to standardize naming conventions

7. Invite your team and start releasing faster with less risk

The coordinator should onboard team members, help set up projects and environments, and ensure that permissions are properly calibrated.

  • Develop guidelines for what new features need to flagged and how you will use LaunchDarkly to practice feature flag-driven development

We’re here to help!

We want to make the transition fast, easy, and productive for you and your entire team. Contact us at support@launchdarkly.com and we will answer all of your questions, provide guidance, and help you get started.

04 Apr

We got your RBAC

How LaunchDarkly gives teams granular access and security control for their feature flag management

Enterprise companies take security and privacy very seriously: risk must be mitigated, customer privacy must be protected, and software releases must be controlled.  Feature flags are essential tools to granularly control software releases, but with great power comes great responsibility.  When you have hundreds of stakeholders using a product, you need to make sure that every team member has the exact permissions they need: no more, no less.

Powerful tools demand powerful access controls.  This means that your demoing account executive should not be able to toggle off live production features unless they are explicitly allowed to enable for a customer.  Likewise, your developers should be able to use feature flags in their own environments, but might not have access to disable functionality that customers depend on.

Custom Roles

To make this a reality, LaunchDarkly has built an extremely powerful and granular access control system that we call custom roles.

Custom roles let you control access for every team member and every feature in LaunchDarkly, from a particular flag’s percentage rollout to the ability to toggle a flag on or off.  You can create a role using our custom roles builder.

Here are some possible custom roles:

  • Lock your production environment down to a small set of trusted users
  • Distinguish infrastructure-level feature flags (controlled by your devOps team) from experiments (controlled by product management or marketing)
  • Allow QA members to control feature flags on designated QA environments only
  • Allow your designers to add users to betas
  • Allow sales to turn a feature “on” for a user

Security

Equally essential for security is the ability to prevent nefarious access and brute force attacks.  Companies want to make sure that the platform controlling their feature releases conforms to security best practices.

As such, LaunchDarkly provides multi-factor authentication and session control for all customers.  Multi-factor authentication (MFA) improves the security of your account by requiring a second verification step in addition to your password to login. In LaunchDarkly, you can enable multi-factor authentication for your team’s account, which requires you to enter a verification passcode from a free authenticator application you install on your mobile device.  You can also require all team members to enable MFA before accessing their accounts.

Moreover, LaunchDarkly’s session control offers administrators a set of controls to manage how long users stay logged in to their account, and how often they need to re-authenticate.  This allows admins to take proactive measures when an account is compromised or a laptop is lost, providing full control over LaunchDarkly account access.

Summary

Feature flagging is increasingly becoming central to a company’s software development and release lifecycles.  As part of a company’s critical infrastructure, feature flag management platforms must have enterprise-grade security to ensure that customer data is safe and that every team member has the exact access they need.

03 Mar

Launched: Feature Flag Variation Editing

LaunchDarkly Feature Flag Variation Editor

Feature flags are powerful when serving variations like true and false. However, they are even more powerful when you can serve variations that are strings, numbers, JSON objects, and JSON arrays — which we call multivariate feature flags.

Previously, we allowed you to create multivariate feature flags with defined variations, but we did not let you add, edit, or delete variations once they were created. Now, you can!

With support for edit variations, you can now edit feature flags after they are created.

You can now:

  • Manage pricing in an e-commerce app by serving number variations
  • Dynamically control configuration values
  • Serve hex values to control CSS styles
  • Sunset variations that are no longer necessary

Editing Variations

When you navigate to any feature flag, you will notice a new Variations tab. This is where you will be able to edit your flag’s variations.

For boolean flags, you can edit a variation’s name and description, but not the value. This is because boolean flags can only serve true and false values.

LaunchDarkly Feature Flag Variation Editor

For multivariate flags, you can now add, edit, and delete variations even after the flag is created. Moreover, you can edit any variation’s value, name, and description. Keep in mind that you cannot change the “type” of variation being served after the flag is created.

LaunchDarkly feature flag variation editor

When you add, edit, or delete a variation for a multivariate flag, the change will apply to all environments within that project. For example, if you have a feature flag called “Checkout Flow” with 4 variations: A, B, C, D and you deleted variation D, then every environment will only have 3 variations (A, B, C) for the “Checkout Flow” feature flag.

We’re excited to deliver this new feature to you and would love to hear your feedback at support@launchdarkly.com.  You can reference our docs for more info.

01 Mar

Implementing Feature Flags in an Angular E-commerce App

E-commerce applications can take on many forms. Whether they’re retail, goods exchange, or an auction website, online commerce is becoming more common than offline. Modern front-end frameworks, such as Angular and React, provide the tools necessary for creating fast and responsive single-page e-commerce apps. In this article, we’ll delve into the process of using the LaunchDarkly JavaScript SDK to introduce new functionality in an AngularJS e-commerce application.

E-Commerce + Real-Time Feature Flags

With the growing demand for quicker, more reliable releases, development teams should consider having feature toggles in their toolbox. The user-facing nature of web stores facilitates the perfect environment in which feature flagging promotes granular control and feature visibility.  Some of the use cases include:

  • Rolling out storewide discounts with minimal overhead
  • Gradually rolling out new checkout and payment systems and assessing performance and revenue impact before fully rolling out
  • Allowing customers to personalize their shopping experience
  • Serve promotions and recommend items based on a customer’s preferences and previous behavior

Having these implementations wrapped in feature flags creates a safety net for catching even the smallest discrepancies, such as outdated seasonal discounts and conflicting pricing rules.

Using Feature Flags in an E-commerce Environment

Feature flags prove to be incredibly valuable in an online store. In such a fast-paced environment, product pricing is constantly changing, with various discounts and markdowns being put into effect. We’ve created an open-source Angular application (based on Code Project’s ShoppingCart) demonstrating the power of feature flagging in an e-commerce application. In our app, we implement a multivariate feature flag named “store-discount” which returns a number indicating a percentage discount on all products.

Integrating

To integrate LaunchDarkly feature flags with our Angular app, we will need to begin by creating a service which will initialize the LaunchDarkly client. Using Angular’s $q dependency allows us to return a promise which will resolve when the client has prepared its initial set of feature flags.

Now, our main controller can use our newly defined LaunchDarklyService to initialize the feature flag client, and save it in the application’s root scope (a set of data available to any page in our app) once the client is ready.

Also, the controller starts a listener within the LaunchDarkly client to change the current value of the store’s universal discount whenever a flag is modified. This allows the app to dynamically render new information. In our case, prices are slashed, and a notification pops up, alerting the user of “amazing new discounts!” This is achieved by using an ngIf directive to slash through the original price, if a discount has been applied.

Here is a video showcasing our completed multivariate flag in action:

Try it out

This demo was built on top of Code Project’s ShoppingCart, and the code is available for your use on GitHub. You can checkout the JavaScript SDK functionality here.

—-

Primary Contributor:  Arnold Trakhtenberg, Engineering Content Consultant at LaunchDarkly