Introduction
Understanding organizationsUnderstanding componentsManage organizationsManage componentsManage component Jira integrations
Set up your first organizationUnderstanding users and teamsUnderstanding role-based access controlManage usersManage teamsConfigure role-based access controlRBAC permissions reference
Understanding authentication in CloudBees UnifySet up multifactor authenticationConfigure SAML single sign-onConfigure OIDC authenticationConfigure network security policiesNetwork security reference
Understanding platform configurationUnderstanding environmentsManage properties and secretsManage environmentsTrack environment inventoryConfigure containersSet up preconfigured actionsConfigure notifications
Accessibility policy referenceShared responsibility model referenceSubscription and services agreementSupport policiesSupported browsers and external tools
Introduction
Understanding feature managementUnderstanding Configuration as CodeGet started with feature managementCreate and manage feature flagsConfigure feature flag targetingOrganize feature flagsImplement feature flag governanceConfiguration as Code reference
Understanding flag impressions and activity statusUnderstanding flag healthUnderstanding code referencesReview and clean up feature flagsSet up code references
Understanding Jira integration for feature flagsSet up the Jira integrationLink Jira tickets to feature flags
Understanding multiple SDK keysBuild your first mobile app with feature flagsBuild your first feature-flagged web applicationBuild your first feature-flagged backend serviceInstall client-side SDKsInstall server-side SDKsConfigure multiple SDK keysMobile SDK referenceWeb SDK referenceBackend SDK referenceClient SDK referenceFlag implementation reference
Introduction
Understanding CI workflowsCreate a build workflowCreate and manage workflowsCreate reusable workflowsTest and validate containers in workflowsCheck out source codeTrigger workflows remotelyWorkflow syntax referenceJobs syntax referenceSteps syntax referenceServices syntax reference
Monitor workflow runsView test results in runsView evidence in runsView deployments in runsManage workflow artifactsPublish test resultsPublish evidence itemsGenerate a software bill of materialsManage ServiceNow change requests
Configure workflow credentialsConfigure AWS credentialsConfigure container registry credentialsConfigure Git credentialsIntegrate external secret providers
Understanding GitHub Actions integrationSet up GitHub Actions integrationDisplay GitHub Actions workflows and runsRegister GHA build artifactsPublish GHA deployed artifactsPublish GHA test resultsPublish GHA evidence itemsTrigger CloudBees workflows from GitHub ActionsScan with GitHub Actions
Understanding CloudBees CI and Jenkins® integrationConnect CI and Jenkins controllersMonitor CI and Jenkins buildsRegister CI build artifactsRegister CI deployed artifactsPublish CI test resultsConfigure CI security scanningCI and Jenkins integration reference
Build and publish container imagesUnderstanding external CI/CD integrationsRun external CI/CD jobsExternal CI/CD action reference
Introduction
Understanding release orchestrationManage applicationsCreate deployer workflowsCreate staged workflowsCreate and manage releasesOrchestrate multi-workflow releasesRelease management reference
Understanding artifact managementRegister and track artifactsStore and retrieve artifactsPromote artifactsGenerate a software bill of materialsArtifact management reference
Deploy with HelmDeploy to KubernetesContainer deployment reference
Deploy to AWSAWS deployment reference
Deploy with enterprise platformsExecute remote deployment commandsEnterprise deployment reference
Verify deployments with New RelicDeployment verification reference

Create and manage feature flags

5 minute read

Create, configure, and manage feature flags using both the CloudBees Unify interface and code-based definitions to control feature rollouts across your applications.

Prerequisites

Before creating feature flags, ensure you have:

  • Access to CloudBees Unify with feature management enabled.

  • An application configured and linked to at least one environment.

  • SDK installed and configured if creating flags in code.

For SDK installation guidance, refer to Install client-side SDKs or Install server-side SDKs.

Access the flags interface

Navigate to the feature flags management interface to view, create, and manage your flags.

  1. Sign in to CloudBees Unify and navigate to Feature management.

  2. Select your application from the application list.

    The flags overview page displays all feature flags for the selected application.

  3. (Optional) Select the installation icon if you need to access SDK setup instructions or copy your SDK key.

    The SDK key authenticates your application’s connection to CloudBees Unify feature management.

Filter and organize flag displays

Use filtering options to locate specific flags in applications with many feature flags:

  1. Select Filter from the flags overview page.

  2. Apply filters by:

    • Environment: Select a specific environment or "All environments" to view flags across multiple environments.

    • Flag name: Enter text to search for flags by name.

    • Status: Filter by flag health status (active, inactive, stale).

    • Labels: Filter by organizational labels assigned to flags.

  3. Select Apply to update the flag list based on your filter criteria.

Clear filters by selecting Clear all filters to return to the complete flag list.

Create flags in the UI

Create feature flags directly in the CloudBees Unify interface for immediate availability across all linked environments.

Flag names and data types cannot be changed after creation. Choose these settings carefully.

  1. Navigate to Feature management and select Create flag.

  2. Configure the required flag settings:

    1. Enter a descriptive Name for your flag.

      Flag names are case-sensitive and must exactly match references in your application code.

    2. Enter a Description explaining the flag’s purpose and intended usage.

    3. Select a Type:

      • Boolean: Simple on/off toggle functionality.

      • String: Text-based values for feature variants or configuration.

      • Number: Numeric values for thresholds, limits, or parameters.

  3. Configure type-specific settings:

    For Boolean flags, no additional configuration is required.

    For String and Number flags: .. Select Define variations to enable multiple predefined values. .. Select Add variation to enter each possible flag value. .. Add as many variations as needed for your use case.

    + Variations provide predefined options that your application can evaluate, enabling complex feature configurations beyond simple boolean toggles.

  4. (Optional) Configure additional settings:

    1. Add Labels to organize and categorize flags across your application.

      Labels help team members locate related flags and support filtered views in the interface.

    2. Select Permanent flag if this flag serves a static configuration purpose.

      Permanent flags ignore impression data and are excluded from cleanup recommendations. Use this setting for configuration flags like timeout values, API endpoints, or logging levels that are not intended for A/B testing or gradual rollouts.

  5. Select Save to create the flag.

    The flag becomes immediately available in all environments linked to your application, though it remains disabled until you configure and activate it.

  6. Enable the flag by navigating to its configuration page and turning the Configuration status to On.

Create flags in code

Define feature flags directly in your application source code using the SDK’s static API approach.

Flags created in code appear automatically in the CloudBees Unify interface after your application runs and connects to the feature management service.

Set up flag container class

Create a container class to organize and define your feature flags:

Android/Java example
import io.rollout.configuration.RoxContainer;
import io.rollout.flags.RoxFlag;
import io.rollout.flags.RoxString;
import io.rollout.flags.RoxInt;

public class FeatureFlags implements RoxContainer {
    // Boolean flag for new feature toggle
    public RoxFlag enableNewFeature = new RoxFlag(false);

    // String flag with default value
    public RoxString buttonColor = new RoxString("blue",
        Arrays.asList("red", "blue", "green"));

    // Number flag for configuration
    public RoxInt maxRetries = new RoxInt(3,
        Arrays.asList(1, 3, 5, 10));
}
▼
JavaScript example
const Rox = require('rox-node');

const flags = {
    // Boolean flag
    enableNewFeature: new Rox.Flag(false),

    // String flag with variations
    buttonColor: new Rox.Configuration("blue"),

    // Number flag
    maxRetries: new Rox.Configuration(3)
};
▼

Register flags with the SDK

Connect your flag definitions to CloudBees Unify by registering the container class:

Android/Java example
// Initialize flags container
FeatureFlags flags = new FeatureFlags();

// Register with SDK
Rox.register("myNamespace", flags);

// Setup SDK with your environment key
Rox.setup("YOUR_SDK_KEY");
▼
JavaScript example
// Register flags
Rox.register('myApp', flags);

// Setup connection
Rox.setup('YOUR_SDK_KEY');
▼

Evaluate flags in application code

Use the registered flags to control feature behavior:

Android/Java example
// Check boolean flag
if (flags.enableNewFeature.isEnabled()) {
    // Show new feature
    showNewInterface();
} else {
    // Show existing interface
    showStandardInterface();
}

// Use configuration values
String color = flags.buttonColor.getValue();
int retries = flags.maxRetries.getValue();
▼
JavaScript example
// Evaluate boolean flag
if (flags.enableNewFeature.isEnabled()) {
    enableNewFeature();
}

// Get configuration values
const buttonColor = flags.buttonColor.getValue();
const maxRetries = flags.maxRetries.getValue();
▼

After running your application, the flags appear in the CloudBees Unify interface where you can configure targeting rules and manage their lifecycle.

Manage existing flags

Update flag settings and organize flags throughout their lifecycle.

Update flag configuration

Modify flag descriptions, labels, and variations after creation:

  1. Navigate to Feature management and locate your flag.

  2. Select the vertical ellipsis icon (⋮) next to the flag name.

  3. Select Edit flag settings.

  4. Update any modifiable settings:

    • Description: Modify the flag’s documentation.

    • Labels: Add or remove organizational labels.

    • Variations (string/number flags): Add, modify, or remove predefined values.

    • Permanent flag: Mark or unmark flags as permanent configuration.

      Remove variations by selecting the trash icon next to each variation, or disable all variations by toggling Define variations to off.

  5. Select Update to save your changes.

Organize flags with labels

Use labels to categorize and filter flags across your application:

  1. Access flag settings as described above.

  2. In the Labels field, add descriptive tags such as:

    • Team names: "frontend-team", "api-team"

    • Feature areas: "authentication", "checkout", "reporting"

    • Release cycles: "q1-release", "beta-features"

  3. Apply consistent labeling conventions across your organization to improve flag discoverability.

Labels support filtered views and help team members locate related functionality across large flag inventories.

Delete flags

Remove feature flags safely when they are no longer needed.

Flag deletion is irreversible and removes the flag from all environments. Ensure the flag is no longer referenced in your application code before deletion.

Before deleting a flag, check the Code references tab to verify where the flag is used in the codebase.

Prepare flags for deletion

  1. Turn off flag configurations in all environments:

    1. Navigate to each environment where the flag is active.

    2. Set the Configuration status to Off.

    3. Verify that the flag is disabled across all environments.

  2. Remove flag references from your application code.

  3. Deploy updated application code that no longer evaluates the flag.

Delete the flag

  1. Navigate to Feature management and locate the flag.

  2. Select the vertical ellipsis icon (⋮) next to the flag name.

  3. Select Delete flag.

  4. Confirm the deletion when prompted.

The flag is permanently removed from CloudBees Unify and all associated environments.

Consider using flag health indicators to identify candidates for deletion. Flags marked as stale or inactive often represent good deletion opportunities after confirming they are no longer needed.

Related pages

Get started with feature management
Configure feature flag targeting