What Are Feature Flags?
Feature flags, also known as feature toggles, are a software development technique that turns certain features of your application on or off at runtime, without deploying new code. This provides greater control over your application’s functionality and lets you test new features in a safe and controlled manner.
Feature flags can be used to hide, enable, or disable a feature during runtime. For instance, during the development process, a developer can disable certain features that are not yet ready for the final version of the software. Once the feature is fully developed and tested, it can be enabled using the feature flag.
The main advantage of feature flags is that they provide a way to separate feature rollout from code deployment. In traditional software development, a feature is released when new code is deployed. However, with feature flags, release of the feature can be controlled independently from the deployment of the code.
This is part of a series of articles about Feature Flags
In this article:
How Feature Flags Work
Feature flags work by using conditional statements within the code that control the visibility and usage of certain features. When the flag is turned on, the feature is visible and usable, when it is turned off, the feature is hidden and cannot be used.
The state of the feature flag, whether it is turned on or off, can be controlled from outside the application. This control can be achieved through a simple configuration file or a feature flag management platform. When a feature is ready to be launched, the corresponding feature flag can simply be turned on. Similarly, if a feature is causing issues, its feature flag can be turned off, effectively removing the feature from the system without having to deploy new code.
Feature flags are not just used for feature rollout, they can also be used for testing features in a production environment, for canary releases, for enabling quicker release cycles, and for providing a rollback or kill switch in case a feature causes issues.
Feature Flag Use Cases and Benefits
Testing in Production
One of the major use cases of feature flags is testing in production. This is valuable because the production environment provides the best representation of the system and real user interactions.
With feature flags, you can expose a new feature to a limited set of users in the production environment and collect feedback. This allows you to identify and address any issues before the feature is rolled out to the broader audience. This approach reduces the risk of introducing new features and ensures users have a smooth experience.
Canary Releases
Canary releases are another popular use case of feature flags. In a canary release, a new feature is gradually rolled out to a small subset of users before being released to the entire user base. This strategy is named after the ‘canary in a coal mine’ concept, where canaries were used to detect toxic gasses in coal mines. If the canary showed signs of distress, the miners knew to evacuate.
Similar to the canary concept, a new feature is released to a small group of users, and the system is closely monitored for any issues. If any problems are detected, the feature can be rolled back immediately without impacting the entire user base.
Quicker Release Cycles
Feature flags significantly speed up the release cycle as they decouple feature rollout from code deployment. With feature flags, you can deploy the code and then control the feature rollout independently.
This means that you can deploy code more frequently and in smaller chunks, which makes it easier to spot issues and reduces deployment risk. It also allows you to get feedback on new features earlier in the development process.
Rollback / Kill Switch
Feature flags provide a safety net in the form of a rollback or kill switch. If a new feature is causing issues, you can use the feature flag to turn off the feature instantly, without having to redeploy the code. This rollback can be done in real-time, minimizing the impact on users.
Having a kill switch also reduces the risk of deployment and encourages a culture of experimentation. Developers can try out new features and ideas, knowing that they can quickly roll back if something goes wrong.
Related content: Working with Python Environment Variables
Tips From the Expert
In my experience, here are tips that can help you better leverage feature flags:
-
Use progressive rollout strategies for data-driven decisions Progressive rollouts, like feature flag percentage rollouts, allow you to release a feature gradually. However, you should also integrate analytics to monitor performance and user interactions for each phase, ensuring data-driven decisions for full rollout or rollback.
-
Group related feature flags for better control If multiple flags control interdependent features, group them logically to avoid conflicts and ease management. This can also prevent unexpected behaviors when toggling one flag affects another.
-
Implement dynamic flag updates without restarting services For high-availability systems, implement real-time feature flag updates, allowing toggles without service restarts or downtime. Ensure your infrastructure supports fetching updated flags from external systems on-the-fly.
-
Integrate flags with CI/CD pipelines for automated testing Automating feature flag toggling during CI/CD pipelines ensures all code changes are tested with different flag combinations. This catches issues early and provides better coverage of possible configurations in a controlled environment.
-
Develop separate flag configurations for different environments Avoid using the same feature flag setup in production, staging, and development environments. Customize each environment to reflect its specific testing or operational needs, ensuring safe experimentation in production while maintaining different flag behaviors elsewhere.
These advanced tips help ensure that your feature flag strategy remains scalable, maintainable, and efficient as your application grows.
Challenges of Feature Flags Management
While feature flags provide significant benefits for development projects, they also create some challenges for development teams. Here are some of the main challenges:
Complexity
Feature flags can be simple, such as a single on/off switch, or complex, such as multivariate flags that allow for a range of different feature combinations. As the number of flags and the complexity of their configurations increase, the management of these flags becomes increasingly difficult. It can be challenging to keep track of which flags are active, what each flag controls, and how they interact with each other.
Additionally, the use of feature flags can add a layer of complexity to code testing and debugging. When a bug is reported, it can be challenging to reproduce the issue if it depends on a specific combination of flags. Similarly, testing can become more complicated as each flag may need to be tested in various states and combinations.
Messy Code and Coordination
Feature flags can lead to messy code if not managed properly. Each flag adds conditional logic to the code, which can make it harder to read and understand. This can slow down development and make the code more prone to errors.
Coordination between team members can also be a challenge. If developers are not aware of each other’s flags, they may unintentionally interfere with each other’s work. For example, one developer might turn off a flag that another developer is using, causing unexpected behavior. Communication and coordination are crucial to prevent these issues.
Technical Debt
Lastly, feature flags can contribute to technical debt if not handled appropriately. When a feature controlled by a flag is ready to be released to all users, the flag and the associated conditional logic should be removed from the code. However, it can be easy to forget or neglect this step, especially in a fast-paced development environment. Over time, these unused flags can accumulate, leading to bloated and inefficient code.
Best Practices for Using Feature Flags Effectively
Despite these challenges, feature flags are an invaluable tool for agile development. The key is to implement best practices that mitigate these issues.
Control Access to Flags
One of the most important practices in feature flag management is controlling who has access to flags. Not everyone on your team needs to have the ability to toggle features on and off. To avoid potential confusion or mishaps, it’s best to limit access to those who need it. This requires a central platform for managing feature flags.
Furthermore, it’s essential to have a system in place for tracking changes to feature flags. This allows you to keep a record of who changed a flag and why, facilitating accountability and transparency.
Implement a Standard Naming Convention
Another best practice for managing feature flags is implementing a standard naming convention. A consistent, descriptive naming scheme helps your team quickly and easily understand what each flag does.
A good naming convention includes information about the flag’s purpose, the team or individual responsible for it, and the feature it controls. This enables anyone reading the code to understand what the flag does without having to check documentation or ask colleagues.
Conduct Regular Clean-Up of Your Flags
Feature flags are not meant to be a permanent part of your codebase. They are tools for managing risk during development and should be removed once they’ve served their purpose. Regular clean-up of your flags is crucial to maintaining clean, efficient code.
Left unchecked, feature flags can accumulate and create technical debt. They can make your code more complicated and difficult to maintain, leading to bugs and slower development times. Thus, it’s crucial to have a process in place for regularly reviewing and removing old flags. Automated feature flag management systems can automatically handle this aspect, and also archive old feature flags in case they are needed in the future.
Track Feature Flags Externally
While it’s important to have a record of changes to your flags in your codebase, it’s also beneficial to maintain an external log of your feature flags.
An external log enables you to track the history of your flags over time, providing a broader context for your feature flag usage. This can be particularly helpful for post-mortems or audits. It also allows non-technical team members to understand the state of different features without having to read code. Automated feature flag management systems provide a central dashboard that visualizes which feature flags are deployed across the code and their current status.
Learn more in our detailed guide to feature flags best practices
Feature Flags with Configu
Configu is a configuration management platform comprised of two main components:
Configu Orchestrator
As applications become more dynamic and distributed in microservices architectures, configurations are getting more fragmented. They are saved as raw text that is spread across multiple stores, databases, files, git repositories, and third-party tools (a typical company will have five to ten different stores). Configu can work as a stand-alone platform or as an orchestrator for secrets managers, feature flags and other stores. It has built-in support for popular feature flag managers, such as LaunchDarkly.
The Configu Orchestrator, which is open-source software, is a powerful standalone tool designed to address this challenge by providing configuration orchestration along with Configuration-as-Code (CaC) approach.
Configu Cloud
Configu Cloud is the most innovative store purpose-built for configurations, including environment variables, secrets, and feature flags. It is built based on the Configu configuration-as-code (CaC) approach and can model configurations and wrap them with unique layers, providing collaboration capabilities, visibility into configuration workflows, and security and compliance standardization.
Unlike legacy tools, which treat configurations as unstructured data or key-value pairs, Configu is leading the way with a Configuration-as-Code approach. By modeling configurations, they are treated as first-class citizens in the developers’ code. This makes our solution more robust and reliable and also enables Configu to provide more capabilities, such as visualization, a testing framework, and security abilities.
