feature flag

As software development cycles accelerate, effective and reliable deployment practices are more crucial than ever. Feature Flags—a powerful technique—allow teams to manage feature releases without relying on separate code branches or waiting for full-scale deployments.

But what exactly are feature flags, and how can they streamline your development workflow?

What Are Feature Flags?

Feature flags (also known as feature toggles) are a development practice that enables or disables features in a live system without deploying new code. By wrapping feature code in conditional statements, developers can control whether a feature is visible to all users or specific groups.

In simple terms, feature flags let you “toggle” a feature on or off for specific users, groups, or environments without modifying the codebase or waiting for a new deployment.

Why Use Feature Flags?

Continuous Delivery & Deployment

Feature flags are essential for teams practicing continuous integration and continuous delivery (CI/CD). They allow new features to be deployed to production but exposed only to selected users (e.g., beta testers). This enables faster code pushes, lower risks, and valuable user feedback before full feature rollouts.
Instant Rollback

If a feature causes issues in production, feature flags allow you to disable it instantly, minimizing downtime and maintaining system stability—without needing to roll back the entire deployment.
A/B Testing & Experimentation

Feature flags are perfect for A/B testing and canary releases. By enabling different users to see different versions of a feature, you can experiment and gather real-time data on which variant performs better.
Reducing Deployment Risk

Feature flags help mitigate the risk of breaking changes. You can keep features hidden until they’re fully tested, reducing the risk of exposing bugs to end-users while still pushing regular code changes.
Granular User Control

With feature flags, you can target specific users, regions, account types, or beta testers. This enables you to roll out features to specific groups and experiment with variations, giving you granular control over your application’s behavior.

How to Implement Feature Flags

While tools like LaunchDarkly and Flagsmith can help implement feature flags, you can also create your own custom solution. Here’s a step-by-step guide for implementing feature flags in your project.

Global Settings vs. User Settings

To manage feature flags effectively, you’ll need two configurations:

Global Settings: Manage feature flags for all users at once. Flags are either enabled (true) or disabled (false).

Example of global settings in JSON:
```
  {
    "global": {
      "settings": {
        "IsAbcEnabled": true,
        "IsSomethingEnabled": false
      }
    }
  }
```
User Settings: Control feature flags for individual users. If a feature is ready for testing, you can enable it for specific users by setting the flag to true.

Example of user settings in JSON:
```
  {
    "someUser": {
      "settings": {
        "IsAbcEnabled": true,
        "IsSomethingEnabled": true
      }
    }
  }
```

Note: User settings always take precedence over global settings. Even if a feature flag is off globally, it will be enabled for a user if the flag is set to true in their individual settings.

How These Settings Work in Your Application

You can store your global and user feature flags on a remote server, or use services like Azure Storage (Table, File Share, etc.) or a remote database. The key is to store global settings and user settings separately.

Example of global settings:

{
  "global": {
    "settings": {
      "IsAbcEnabled": true,
      "IsSomethingEnabled": false
    }
  }
}

Example of user settings:

{
  "someUser1": {
    "settings": {
      "IsAbcEnabled": true,
      "IsSomethingEnabled": true
    }
  },
  "someUser2": {
    "settings": {
      "IsAbcEnabled": false,
      "IsSomethingEnabled": true
    }
  }
}

Final merged settings for someUser1:

{
  "someUser1": {
    "settings": {
      "IsAbcEnabled": true,
      "IsSomethingEnabled": true
    }
  }
}

If user-specific settings differ:

{
  "someUser1": {
    "settings": {
      "IsSomethingEnabled": false
    }
  }
}

Then the final settings would be:

{
  "someUser1": {
    "settings": {
      "IsAbcEnabled": true,
      "IsSomethingEnabled": false
    }
  }
}

In this case, the user would only see the feature enabled by the IsAbcEnabled flag.

Note: If a feature flag is missing from both global and user settings, it’s considered disabled by default.

Web Applications

When a user logs in, your application will first check the global settings to determine which features are enabled for everyone. Then, it will fetch user-specific settings using their ID (or another unique key). The application can adjust the user interface accordingly. For better performance, these settings can be cached until the session ends, reducing repeated server calls.

Desktop/Mobile Applications

For desktop or mobile apps, global and user settings should be stored locally (e.g., in a database or cache). Upon user authentication, the app can download the latest settings and adjust the interface based on the enabled features. Ensure the local cache is updated on each launch to keep it in sync with the server.

Example of a conditional statement which can be used to manipulate user interface/business logic:

if (IsAbcEnabled == true)
{
    // Show Abc feature
}
else
{
    // Hide Abc feature
}

This approach ensures that the application dynamically adjusts based on the feature flags available to the user or environment.

Manage Feature Flags Remotely

Managing feature flags remotely allows you to switch features on or off globally or for individual users or groups. This is especially useful when handling large user bases (e.g., beta testers). For large-scale management, consider building an API to update feature flags in user settings, as manually managing this for hundreds of users can be error-prone.

You might also create a portal to manage both global and user-specific settings, allowing you to easily control feature flag toggling in a streamlined way.

Best Practices for Using Feature Flags

Keep Flags Temporary

Feature flags should not be permanent. Once a feature is fully rolled out or the experiment concludes, remove the flags to avoid unnecessary complexity in your codebase.
Have a Flag Management Strategy

As the number of feature flags increases, use tools or systems to manage them effectively. Track which flags are active, which are pending removal, and which are associated with specific environments or user groups.
Test Flags Across Environments

Feature flags should be tested in all environments (development, staging, and production) to ensure they function correctly and do not cause issues when toggled.
Automate Flag Removals

Automate the removal of feature flags once a feature is fully rolled out. This avoids technical debt and keeps the codebase clean.
Monitor Flag Behavior

Monitor the behavior of features controlled by flags to ensure they perform as expected. This will help you identify issues early and ensure smoother rollouts.

Conclusion

Feature flags provide an agile and flexible approach to managing feature releases, reducing risk, and enabling continuous delivery. They help development teams deploy faster, experiment more, and deliver features with greater confidence. However, like any tool, they should be used wisely and managed carefully to prevent unnecessary complexity. By following best practices and using the right tools, feature flags can be a game-changer in your software development workflow.

Mastering Feature Flags: A Powerful Tool for Agile Development