⚡Supercharge Your Feature Flags Using OpenFeature + AWS Parameter Store

#featureflags #openfeature #cloud #aws

A feature flag is a mechanism that allows specific functionality within an application to be enabled or disabled dynamically, without deploying new code. Feature flags play a pivotal role in modern DevOps practices by enabling teams to manage feature rollouts, control exposure to end users, and reduce risk during deployments.

They are commonly used to disable incomplete or experimental features in production environments, enable gradual rollouts (such as canary or blue-green deployments), or restrict access to premium functionality based on user entitlements.

☁️ Managing Flags via AWS Parameter Store

For those of us working with AWS on a daily basis, AWS Systems Manager Parameter Store is a familiar and trusted service. It’s often used to store configuration values like URLs, hostnames, environment variables, and other runtime settings—allowing applications to reference them securely at build or execution time.

Beyond basic configuration management, Parameter Store also integrates seamlessly with AWS Secrets Manager, making it a convenient choice for managing sensitive data such as API keys, tokens, and credentials in a secure and auditable way.

Let us now imagine that we need to manage via Parameter Store a feature flag to enable the new version of the dashboard that we have just deployed to production.

feature/new-dashboard

Let's create the parameter within Parameter Store using the AWS CLI

aws ssm put-parameter \
  --name "/feature/new-dashboard" \
  --type "String" \
  --value "true"

At this point our feature flag is ready to be retrieved through the AWS SDK

import { SSMClient, GetParameterCommand } from "@aws-sdk/client-ssm";

const ssmClient = new SSMClient({ region: "us-east-1" });

async function getFeatureFlag() {
  const result = await ssmClient.send(
    new GetParameterCommand({ Name: "/feature/new-dashboard" })
  );
  return result.Parameter?.Value;
}

getFeatureFlag();

It might all seem great on the surface:

Simple setup
Solid integration,
No extra tools to manage

But there’s a catch.

🔒 The Cloud vendor lock-in problem

When you build your applications tightly around a specific cloud provider’s service you gain seamless integration and convenience. However, this also creates a dependency on that provider’s ecosystem, commonly referred to as cloud vendor lock-in.

Lock-in means that moving your application, data, or infrastructure to another cloud provider becomes difficult, costly, or risky. This can limit your flexibility to:

Switch to alternative cloud platforms for cost savings or compliance.
Adopt best-of-breed tools that work across multiple clouds.
Maintain a consistent deployment process in hybrid or multi-cloud environments.

In the context of feature flags, relying exclusively on AWS Parameter Store or a similar cloud-native service means your flag management is tightly coupled to AWS. Changing providers would require rewriting parts of your application, retraining your team, and potentially risking downtime or bugs.

📖 The role of OpenFeature

OpenFeature is an open specification that offers a vendor-neutral, community-driven API for feature flagging. It is designed to integrate seamlessly with any feature flag management tool or custom in-house solution.

By abstracting the feature flag evaluation process, OpenFeature allows you to switch between different platforms or consolidate multiple flag management systems with greater ease and flexibility.

Let's refactor the code.


import { OpenFeature } from '@openfeature/server-sdk';
import { AwsSsmProvider } from '@openfeature/aws-ssm-provider';

const providerConfig = {
 ssmClientConfig = { region : "eu-west-1" }
 cacheOpts = { enabled : false } // disable native caching feature 
}

await OpenFeature.setProviderAndWait(new AwsSsmProvider(providerConfig));

const client = OpenFeature.getClient();

const isEnabled = await client.getBooleanValue('feature/new-dashboard', false);

if (isEnabled) {
  console.log("New dashboard feature is enabled");
}

As demonstrated in the example, invoking setProviderAndWaitsuccessfully configures the OpenFeature SDK with the AWS SSM provider. This setup enables seamless retrieval of feature flag values from AWS Parameter Store.

Additionally, the getBooleanValue method includes support for a default fallback value, ensuring that the application maintains expected behavior even if the feature flag evaluation fails or the flag is not defined.

🏁 Wrapping Up

Leveraging AWS Parameter Store for feature flag management offers a seamless and secure way to control feature rollout in your applications. However, by integrating OpenFeature, you gain the flexibility of a vendor-neutral API that reduces cloud lock-in and simplifies multi-provider strategies.

Give OpenFeature a try in your next project and experience the freedom of standardized feature flag management across platforms!