Configure AWS CloudWatch Evidently Features

The aws:evidently/feature:Feature resource, part of the Pulumi AWS provider, defines a CloudWatch Evidently feature flag: its variations, default behavior, and user-specific overrides. This resource is deprecated; AWS recommends using AppConfig feature flags instead. This guide focuses on four capabilities: variation definition, default variation selection, user-specific overrides, and evaluation strategy control.

Features belong to Evidently projects and must reference an existing project by name or ARN. The examples are intentionally small. Combine them with your own project infrastructure and application integration.

Define a feature with a single variation

Feature flags start with a name, a project, and at least one variation that defines what value the feature returns.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.evidently.Feature("example", {
    name: "example",
    project: exampleAwsEvidentlyProject.name,
    description: "example description",
    variations: [{
        name: "Variation1",
        value: {
            stringValue: "example",
        },
    }],
    tags: {
        Key1: "example Feature",
    },
});

import pulumi
import pulumi_aws as aws

example = aws.evidently.Feature("example",
    name="example",
    project=example_aws_evidently_project["name"],
    description="example description",
    variations=[{
        "name": "Variation1",
        "value": {
            "string_value": "example",
        },
    }],
    tags={
        "Key1": "example Feature",
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := evidently.NewFeature(ctx, "example", &evidently.FeatureArgs{
			Name:        pulumi.String("example"),
			Project:     pulumi.Any(exampleAwsEvidentlyProject.Name),
			Description: pulumi.String("example description"),
			Variations: evidently.FeatureVariationArray{
				&evidently.FeatureVariationArgs{
					Name: pulumi.String("Variation1"),
					Value: &evidently.FeatureVariationValueArgs{
						StringValue: pulumi.String("example"),
					},
				},
			},
			Tags: pulumi.StringMap{
				"Key1": pulumi.String("example Feature"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Evidently.Feature("example", new()
    {
        Name = "example",
        Project = exampleAwsEvidentlyProject.Name,
        Description = "example description",
        Variations = new[]
        {
            new Aws.Evidently.Inputs.FeatureVariationArgs
            {
                Name = "Variation1",
                Value = new Aws.Evidently.Inputs.FeatureVariationValueArgs
                {
                    StringValue = "example",
                },
            },
        },
        Tags = 
        {
            { "Key1", "example Feature" },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Feature;
import com.pulumi.aws.evidently.FeatureArgs;
import com.pulumi.aws.evidently.inputs.FeatureVariationArgs;
import com.pulumi.aws.evidently.inputs.FeatureVariationValueArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new Feature("example", FeatureArgs.builder()
            .name("example")
            .project(exampleAwsEvidentlyProject.name())
            .description("example description")
            .variations(FeatureVariationArgs.builder()
                .name("Variation1")
                .value(FeatureVariationValueArgs.builder()
                    .stringValue("example")
                    .build())
                .build())
            .tags(Map.of("Key1", "example Feature"))
            .build());

    }
}

resources:
  example:
    type: aws:evidently:Feature
    properties:
      name: example
      project: ${exampleAwsEvidentlyProject.name}
      description: example description
      variations:
        - name: Variation1
          value:
            stringValue: example
      tags:
        Key1: example Feature

The variations array defines possible feature values. Each variation has a name and a value object containing the actual data. The stringValue property holds the variation’s content. Without a defaultVariation property, Evidently serves the first variation in the list to users not allocated to experiments or launches.

Set a default variation for unallocated users

When multiple variations exist, you control which one serves users who aren’t part of any active experiment or launch.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.evidently.Feature("example", {
    name: "example",
    project: exampleAwsEvidentlyProject.name,
    defaultVariation: "Variation2",
    variations: [
        {
            name: "Variation1",
            value: {
                stringValue: "exampleval1",
            },
        },
        {
            name: "Variation2",
            value: {
                stringValue: "exampleval2",
            },
        },
    ],
});

import pulumi
import pulumi_aws as aws

example = aws.evidently.Feature("example",
    name="example",
    project=example_aws_evidently_project["name"],
    default_variation="Variation2",
    variations=[
        {
            "name": "Variation1",
            "value": {
                "string_value": "exampleval1",
            },
        },
        {
            "name": "Variation2",
            "value": {
                "string_value": "exampleval2",
            },
        },
    ])

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := evidently.NewFeature(ctx, "example", &evidently.FeatureArgs{
			Name:             pulumi.String("example"),
			Project:          pulumi.Any(exampleAwsEvidentlyProject.Name),
			DefaultVariation: pulumi.String("Variation2"),
			Variations: evidently.FeatureVariationArray{
				&evidently.FeatureVariationArgs{
					Name: pulumi.String("Variation1"),
					Value: &evidently.FeatureVariationValueArgs{
						StringValue: pulumi.String("exampleval1"),
					},
				},
				&evidently.FeatureVariationArgs{
					Name: pulumi.String("Variation2"),
					Value: &evidently.FeatureVariationValueArgs{
						StringValue: pulumi.String("exampleval2"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Evidently.Feature("example", new()
    {
        Name = "example",
        Project = exampleAwsEvidentlyProject.Name,
        DefaultVariation = "Variation2",
        Variations = new[]
        {
            new Aws.Evidently.Inputs.FeatureVariationArgs
            {
                Name = "Variation1",
                Value = new Aws.Evidently.Inputs.FeatureVariationValueArgs
                {
                    StringValue = "exampleval1",
                },
            },
            new Aws.Evidently.Inputs.FeatureVariationArgs
            {
                Name = "Variation2",
                Value = new Aws.Evidently.Inputs.FeatureVariationValueArgs
                {
                    StringValue = "exampleval2",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Feature;
import com.pulumi.aws.evidently.FeatureArgs;
import com.pulumi.aws.evidently.inputs.FeatureVariationArgs;
import com.pulumi.aws.evidently.inputs.FeatureVariationValueArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new Feature("example", FeatureArgs.builder()
            .name("example")
            .project(exampleAwsEvidentlyProject.name())
            .defaultVariation("Variation2")
            .variations(            
                FeatureVariationArgs.builder()
                    .name("Variation1")
                    .value(FeatureVariationValueArgs.builder()
                        .stringValue("exampleval1")
                        .build())
                    .build(),
                FeatureVariationArgs.builder()
                    .name("Variation2")
                    .value(FeatureVariationValueArgs.builder()
                        .stringValue("exampleval2")
                        .build())
                    .build())
            .build());

    }
}

resources:
  example:
    type: aws:evidently:Feature
    properties:
      name: example
      project: ${exampleAwsEvidentlyProject.name}
      defaultVariation: Variation2
      variations:
        - name: Variation1
          value:
            stringValue: exampleval1
        - name: Variation2
          value:
            stringValue: exampleval2

The defaultVariation property specifies which variation name to serve by default. This variation must exist in the variations array. Users not allocated to experiments or launches receive this variation.

Override variations for specific users

Testing often requires serving specific variations to known users or accounts, bypassing normal allocation rules.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.evidently.Feature("example", {
    name: "example",
    project: exampleAwsEvidentlyProject.name,
    entityOverrides: {
        test1: "Variation1",
    },
    variations: [
        {
            name: "Variation1",
            value: {
                stringValue: "exampleval1",
            },
        },
        {
            name: "Variation2",
            value: {
                stringValue: "exampleval2",
            },
        },
    ],
});

import pulumi
import pulumi_aws as aws

example = aws.evidently.Feature("example",
    name="example",
    project=example_aws_evidently_project["name"],
    entity_overrides={
        "test1": "Variation1",
    },
    variations=[
        {
            "name": "Variation1",
            "value": {
                "string_value": "exampleval1",
            },
        },
        {
            "name": "Variation2",
            "value": {
                "string_value": "exampleval2",
            },
        },
    ])

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := evidently.NewFeature(ctx, "example", &evidently.FeatureArgs{
			Name:    pulumi.String("example"),
			Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
			EntityOverrides: pulumi.StringMap{
				"test1": pulumi.String("Variation1"),
			},
			Variations: evidently.FeatureVariationArray{
				&evidently.FeatureVariationArgs{
					Name: pulumi.String("Variation1"),
					Value: &evidently.FeatureVariationValueArgs{
						StringValue: pulumi.String("exampleval1"),
					},
				},
				&evidently.FeatureVariationArgs{
					Name: pulumi.String("Variation2"),
					Value: &evidently.FeatureVariationValueArgs{
						StringValue: pulumi.String("exampleval2"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Evidently.Feature("example", new()
    {
        Name = "example",
        Project = exampleAwsEvidentlyProject.Name,
        EntityOverrides = 
        {
            { "test1", "Variation1" },
        },
        Variations = new[]
        {
            new Aws.Evidently.Inputs.FeatureVariationArgs
            {
                Name = "Variation1",
                Value = new Aws.Evidently.Inputs.FeatureVariationValueArgs
                {
                    StringValue = "exampleval1",
                },
            },
            new Aws.Evidently.Inputs.FeatureVariationArgs
            {
                Name = "Variation2",
                Value = new Aws.Evidently.Inputs.FeatureVariationValueArgs
                {
                    StringValue = "exampleval2",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Feature;
import com.pulumi.aws.evidently.FeatureArgs;
import com.pulumi.aws.evidently.inputs.FeatureVariationArgs;
import com.pulumi.aws.evidently.inputs.FeatureVariationValueArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new Feature("example", FeatureArgs.builder()
            .name("example")
            .project(exampleAwsEvidentlyProject.name())
            .entityOverrides(Map.of("test1", "Variation1"))
            .variations(            
                FeatureVariationArgs.builder()
                    .name("Variation1")
                    .value(FeatureVariationValueArgs.builder()
                        .stringValue("exampleval1")
                        .build())
                    .build(),
                FeatureVariationArgs.builder()
                    .name("Variation2")
                    .value(FeatureVariationValueArgs.builder()
                        .stringValue("exampleval2")
                        .build())
                    .build())
            .build());

    }
}

resources:
  example:
    type: aws:evidently:Feature
    properties:
      name: example
      project: ${exampleAwsEvidentlyProject.name}
      entityOverrides:
        test1: Variation1
      variations:
        - name: Variation1
          value:
            stringValue: exampleval1
        - name: Variation2
          value:
            stringValue: exampleval2

The entityOverrides property maps user identifiers to variation names. Each key is a user ID, account ID, or other identifier; each value is a variation name. These users always receive their assigned variation regardless of experiments, launches, or default settings.

Control traffic allocation with evaluation strategy

The evaluation strategy determines whether Evidently uses launch and experiment rules or always serves the default variation.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.evidently.Feature("example", {
    name: "example",
    project: exampleAwsEvidentlyProject.name,
    evaluationStrategy: "ALL_RULES",
    entityOverrides: {
        test1: "Variation1",
    },
    variations: [{
        name: "Variation1",
        value: {
            stringValue: "exampleval1",
        },
    }],
});

import pulumi
import pulumi_aws as aws

example = aws.evidently.Feature("example",
    name="example",
    project=example_aws_evidently_project["name"],
    evaluation_strategy="ALL_RULES",
    entity_overrides={
        "test1": "Variation1",
    },
    variations=[{
        "name": "Variation1",
        "value": {
            "string_value": "exampleval1",
        },
    }])

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := evidently.NewFeature(ctx, "example", &evidently.FeatureArgs{
			Name:               pulumi.String("example"),
			Project:            pulumi.Any(exampleAwsEvidentlyProject.Name),
			EvaluationStrategy: pulumi.String("ALL_RULES"),
			EntityOverrides: pulumi.StringMap{
				"test1": pulumi.String("Variation1"),
			},
			Variations: evidently.FeatureVariationArray{
				&evidently.FeatureVariationArgs{
					Name: pulumi.String("Variation1"),
					Value: &evidently.FeatureVariationValueArgs{
						StringValue: pulumi.String("exampleval1"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Evidently.Feature("example", new()
    {
        Name = "example",
        Project = exampleAwsEvidentlyProject.Name,
        EvaluationStrategy = "ALL_RULES",
        EntityOverrides = 
        {
            { "test1", "Variation1" },
        },
        Variations = new[]
        {
            new Aws.Evidently.Inputs.FeatureVariationArgs
            {
                Name = "Variation1",
                Value = new Aws.Evidently.Inputs.FeatureVariationValueArgs
                {
                    StringValue = "exampleval1",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Feature;
import com.pulumi.aws.evidently.FeatureArgs;
import com.pulumi.aws.evidently.inputs.FeatureVariationArgs;
import com.pulumi.aws.evidently.inputs.FeatureVariationValueArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new Feature("example", FeatureArgs.builder()
            .name("example")
            .project(exampleAwsEvidentlyProject.name())
            .evaluationStrategy("ALL_RULES")
            .entityOverrides(Map.of("test1", "Variation1"))
            .variations(FeatureVariationArgs.builder()
                .name("Variation1")
                .value(FeatureVariationValueArgs.builder()
                    .stringValue("exampleval1")
                    .build())
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:evidently:Feature
    properties:
      name: example
      project: ${exampleAwsEvidentlyProject.name}
      evaluationStrategy: ALL_RULES
      entityOverrides:
        test1: Variation1
      variations:
        - name: Variation1
          value:
            stringValue: exampleval1

The evaluationStrategy property controls how Evidently evaluates which variation to serve. Set it to ALL_RULES to activate traffic allocation from launches and experiments. Set it to DEFAULT_VARIATION to bypass all rules and serve the default variation to everyone. This example combines entity overrides with evaluation strategy, showing how specific users can still receive overridden variations even when the strategy is set.

Beyond these examples

These snippets focus on specific feature flag capabilities: variation definition and default selection, user-specific overrides, and evaluation strategy control. They’re intentionally minimal rather than full experimentation workflows.

The examples reference pre-existing infrastructure such as CloudWatch Evidently projects. They focus on configuring the feature flag rather than provisioning the surrounding project infrastructure.

To keep things focused, common feature flag patterns are omitted, including:

Variation value types (LONG, DOUBLE, BOOLEAN)
Launch and experiment integration
Evaluation rules configuration

These omissions are intentional: the goal is to illustrate how each feature flag capability is wired, not provide drop-in experimentation modules. See the Evidently Feature resource reference for all available configuration options.

Let's configure AWS CloudWatch Evidently Features

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Deprecation & Migration

Should I still use CloudWatch Evidently Feature?

No, this resource is deprecated. Use AWS AppConfig feature flags instead for new projects.

Feature Configuration

What are variations and why are they required?

Variations define the different versions of your feature (e.g., different UI layouts, algorithm versions). Each variation has a name and value (string, long, double, or boolean).

What happens if I don't specify a default variation?

The first variation in your variations list automatically becomes the default variation served to users not in active launches or experiments.

What's the difference between ALL_RULES and DEFAULT_VARIATION evaluation strategies?

ALL_RULES activates traffic allocation from ongoing launches or experiments, while DEFAULT_VARIATION serves the default variation to all users regardless of rules.

How do I serve a specific variation to certain users?

Use entityOverrides to map user IDs, account IDs, or other identifiers to variation names. These users will always receive their assigned variation.

Resource Management

What properties can't be changed after creating a feature?

The name and project properties are immutable. Changing them requires destroying and recreating the resource.

What are the naming requirements for a feature?

Feature names must be between 1 and 127 characters long.

Can I specify a project by name or ARN?

Yes, the project property accepts either the project name or its full ARN.

How do I import an existing Evidently feature?

Use pulumi import aws:evidently/feature:Feature <resource_name> <feature_name>:<project_arn>, for example:

pulumi import aws:evidently/feature:Feature example exampleFeatureName:arn:aws:evidently:us-east-1:123456789012:project/example

Validation & Errors

What happens if my defaultVariation doesn't exist in the variations list?

The defaultVariation must match a variation name in your variations list. If it doesn’t exist, the configuration will be invalid.

Using a different cloud?

Explore analytics guides for other cloud providers:

Azure Guides GCP Guides