← Back to Blog

Feature Flags (Feature Toggles) in Simple Terms

Enabling safe releases, quick rollbacks, A/B testing, and flexible configuration without code changes

May 3, 2023
8 min read
Feature Flags
DevOps
AWS
A/B Testing
Software Development

What Are Feature Flags?

Feature Flags (or Feature Toggles) are like switches in your code that allow you to enable or disable certain functions without having to change the code and make a new release. They act as conditional statements that determine whether a particular feature or code path should be executed, giving developers and product managers fine-grained control over application behavior.

At their core, feature flags are simple conditional statements in your code. However, when combined with a management system, they become a powerful tool for controlling software delivery, testing, and operations. Feature flags can be as simple as a configuration file or as sophisticated as a distributed system with a user interface for managing flags across multiple applications and environments.

Beyond Simple Toggles

Modern feature flag systems go beyond simple on/off toggles. They can target specific user segments, gradually roll out to increasing percentages of users, or even make decisions based on complex rules involving user attributes, time of day, geographic location, and more.

Why They're Needed

Safe Release

Enable a new feature for only a portion of users (e.g., 10%) and make sure everything works properly before rolling it out to everyone. This reduces the risk of introducing bugs that affect all users.

Quick Rollback

If something goes wrong, simply "turn off" the problematic feature without having to fix the code and deploy a new version. This provides an immediate safety mechanism when issues arise.

A/B Testing

Show different users different versions of the interface to understand which works better. This allows data-driven decision making based on real user behavior and preferences.

Flexible Configuration

Change application behavior without having to release a new version. This is particularly useful for adjusting features based on user feedback or business requirements.

Continuous Delivery

Feature flags enable continuous delivery by allowing developers to merge code into the main branch even if features aren't complete. The incomplete features can be hidden behind flags until they're ready for release, separating code deployment from feature release.

How It Works: A Real Example

Imagine you're developing a new version of the user dashboard on your website. Instead of immediately showing it to all users, you can use feature flags to control the rollout process.

Implementation Steps

  1. 1
    Write code for both old and new versions
  2. 2
    Add a condition like: "if the new_dashboard flag is enabled, show the new version, otherwise — the old one"
  3. 3
    Leave the flag turned off by default
  4. 4
    When everything is ready for testing, enable the flag for only 5% of users
  5. 5
    Gradually increase the percentage if everything goes well
  6. 6
    If problems arise — instantly revert to the old version just by turning off the flag

Code Example

1// Feature flag configuration
2const featureFlags = {
3  newDashboard: false,  // Initially disabled
4  betaFeatures: false,
5  darkMode: true
6};
7
8// In your application code
9function renderDashboard() {
10  if (featureFlags.newDashboard) {
11    return renderNewDashboard();
12  } else {
13    return renderOldDashboard();
14  }
15}
16
17// To enable the feature flag later (e.g., from a control panel)
18function enableNewDashboard() {
19  featureFlags.newDashboard = true;
20  // Re-render the dashboard with the new version
21  updateUI();
22}

Interactive Demo

Try out this interactive demo to see how feature flags work in practice. Toggle the switches to enable or disable different features and see how the application responds in real-time.

Feature Flag Controls

Application Preview

Demo Application
Feature flags in action

This is a classic design with light mode.

How This Demo Works

This interactive demo shows how feature flags can control different aspects of an application:

  • New Design - Changes the header style and button colors
  • Dark Mode - Toggles between light and dark color schemes
  • Beta Features - Shows additional UI elements and functionality
  • Animations - Enables subtle animations on interactive elements

In a real application, these flags would typically be controlled from a central management system and could be targeted to specific users or user segments.

Real-World Implementation

In a real-world scenario, these feature flags would typically be managed through a centralized system rather than directly in the code. The application would fetch the current flag values from a server or configuration service, allowing for remote updates without code changes.

AWS AppConfig for Managing Feature Flags

AWS AppConfig is a service from Amazon that helps manage these "switches" without having to change code or restart the application. It provides a centralized way to store, manage, and deploy feature flags and other configuration data to your applications.

How It Works

1. Configuration Creation

You create a configuration in AWS AppConfig in JSON format with your flags:

1{
2  "features": {
3    "new_dashboard": true,
4    "beta_mode": false
5  }
6}

2. Application Integration

Your application periodically requests these settings and applies them:

1# Check if the new dashboard version is enabled
2if feature_flags["features"]["new_dashboard"]:
3    # Show the new version
4    show_new_dashboard()
5else:
6    # Show the old version
7    show_old_dashboard()

3. Flag Management

When you want to enable or disable a feature, just change the value in the AWS Console — without new releases!

Advantages of AWS AppConfig

User-friendly interface

Manage flags through AWS Console with a visual interface

Phased implementation

Configure changes to be applied gradually to users

Automatic rollback

System can automatically return to previous configuration if issues occur

Monitoring and audit

All changes are tracked and recorded for compliance

Implementation Considerations

When implementing AWS AppConfig for feature flags, consider caching strategies to reduce API calls, set up appropriate IAM permissions, and implement proper error handling in case the configuration service is unavailable. It's also important to plan your deployment strategy, including how often your application will check for configuration updates.

Alternatives to AWS AppConfig

If you don't use AWS or need other capabilities, there are several alternative solutions for managing feature flags:

LaunchDarkly

A popular commercial service with extensive capabilities for feature flag management, targeting, and experimentation. Offers SDKs for multiple languages and platforms.

Unleash

Open source feature flag solution that can be installed on your own server. Provides a UI for managing flags and APIs for integration with applications.

Flagsmith

Combination of cloud solution and self-hosting option. Offers user targeting, A/B testing, and remote configuration management.

Firebase Remote Config

Google's solution for feature flags and remote configuration, particularly well-suited for mobile applications. Integrates with other Firebase services.

ConfigCat

Easy-to-use service with an intuitive interface. Offers feature flags, targeting, and A/B testing capabilities with SDKs for multiple platforms.

Split.io

Feature delivery platform with advanced targeting and experimentation capabilities. Includes analytics and monitoring features.

Choosing the Right Solution

When selecting a feature flag management system, consider factors such as your team size, technical requirements, budget, and whether you need advanced capabilities like user targeting, A/B testing, or analytics. Some solutions are better suited for small teams and simple use cases, while others provide enterprise-grade features for complex scenarios.

Modern Approach: Flags as Code

A newer approach to feature flags is the "Flags as Code" pattern, which makes flags more maintainable and type-safe. Instead of using string identifiers for flags, each flag becomes a function in your codebase [^1][^2].

Implementation Example

1import { flag } from 'flags/next';
2
3export const newDashboardFlag = flag({
4  key: 'new-dashboard',
5  defaultValue: false,
6  decide() {
7    return false;
8  },
9});
10
11// Usage
12const showNewDashboard = await newDashboardFlag();

Advantages of Flags as Code

Consistently simple call sites

Just call the function instead of using string identifiers

Default values are declared with the flag

Ensures consistent behavior when flags can't be evaluated

Context establishment is centralized

Flag context is established when declared, not at each call site

Reduced vendor lock-in

Easier to switch between different feature flag providers

Type Safety and IDE Support

The Flags as Code approach provides better type safety and IDE support compared to string-based feature flags. This makes it easier to refactor code, find references to flags, and catch errors at compile time rather than runtime.

Conclusion

Feature Flags are a powerful tool for more flexible and secure development. They allow you to:

  • Safely test new features on real users
  • Respond quickly to problems
  • Conduct experiments with interface and functionality
  • Manage application behavior without having to release new versions

Implementing Feature Flags through AWS AppConfig is especially convenient if you already use AWS services. It allows you to centrally manage your application's functionality and quickly respond to changing requirements or issues. For those not using AWS, there are many alternative solutions available, from open-source options to commercial services with advanced capabilities.

The modern "Flags as Code" approach takes feature flags to the next level by making them more maintainable, type-safe, and integrated into your development workflow. This approach reduces errors, improves developer experience, and makes it easier to manage feature flags as your application grows.

Getting Started

To get started with feature flags, begin with a simple implementation in your codebase. As you become more comfortable with the concept, you can explore more sophisticated management systems and advanced techniques like user targeting and experimentation. The key is to start small and gradually expand your feature flag strategy as your needs evolve.

Need help implementing feature flags?

I offer expert consultation on implementing feature flags in your applications, setting up management systems, and developing strategies for safe releases and experimentation. Let's discuss how I can help you leverage feature flags for your specific needs.