Create flag variations
Describes flag variations and how to create them in Optimizely Feature Experimentation.
A flag variation is a reusable group of flag variable values (also called remote feature configuration or remote variables) that let you avoid hard coding values in your code. Optimizely Feature Experimentation dynamically assigns those variable values to your flag based on your flag rules. For more information about what flag variations are, see Flag variations. To create flag variations, follow these steps:
Set up flags in Optimizely Feature Experimentation
(Prerequisite) Create default variables
Before you create variations, you must create default flag variables. You can create variables of type Boolean, String, Integer, Double or JSON. There is no character limit for a JSON variable value.
Take the following steps to create a flag variable with a default value in the Optimizely app:
- Navigate to Flags and select a flag.
- Navigate to Variables and click the add variable button (the "+" icon).
- Select the type, then edit the Key and Default Value.
- Create as many variables as you need for that flag.

Click to enlarge image
Create flag variations:
After creating default variables, take the following steps to create flag variations:
-
Navigate to Flags > Variations.
-
Click the add variation button (the "+" icon.
-
Configure new values for the flag variables you created in the previous section.

Click to enlarge the image
Use flag variations
To control the end-user's experiences, you deliver flag variations through flag rules. For more information, see:
Implement flag variations
In the Optimizely Feature Experimentation app, you see flag variations, which allow you to group and reuse variable values. In your code implementation, you could use the returned OptimizelyDecision's variation key to execute code conditionally, but to take full advantage of variables, we recommend getting the values of the variation's variables directly.
The following code sample shows how you would use flag variables.
Note
This code is indifferent about what type of flag rule the user is in (flag delivery or experiment), so you can re-use the same code to run different rules.
// Fetch enabled state for the "product_sort" flag.
// Then use flag variations to expose different sorting methods and pagation.
//Define flag variable defaults (if the flag is disabled, you fall back to these values)
sortMethod := "alphabetical"
pageLimit := 10
// Is the flag enabled for the user?
user := optimizely.CreateUserContext(userId, nil)
decision := user.Decide("product_sort", nil)
enabled := decision.Enabled
// In the online Optimizely app, go define flag variations using
// sort_method and page_limit variables.
// For example, variation_1 might sort by popularity and limit results to 15 pages.
if enabled {
// get flag variable values depending on the variation the user bucketed into
err1 := decision.Variables.GetValue("sort_method", &sortMethod)
err2 := decision.Variables.GetValue("page_limit", &pageLimit)
}
// Fetch products using the flag variables, using something like this pseudocode:
products := productProvider.get(sortMethod, pageLimit)
/**
* Fetch enabled state for the "product_sort" flag.
* Then use flag variations to expose different sorting methods and pagation.
*/
// Define flag variable defaults (if the flag is disabled, you fall back to these values)
var sortMethod = "alphabetical";
var pageLimit = 10;
// Is the flag enabled for the user?
var user = optimizely.CreateUserContext(userId: "userId");
var decision = user.Decide(key: "product_sort");
var enabled = decision.Enabled;
/**
* In the online Optimizely app, go define flag variations using
* sort_method and page_limit variables.
* For example, variation_1 might sort by popularity and limit results to 15 pages.
*/
if (enabled)
{
// get flag variable values depending on the variation the user bucketed into
sortMethod = decision.Variables.GetValue<string>("sort_method");
pageLimit = decision.Variables.GetValue<int>(jsonPath: "page_limit");
}
// Fetch products using the flag variables, using something like this pseudocode:
var products = productProvider.Get(sortMethod, pageLimit);
/**
* Fetch enabled state for the "product_sort" flag.
* Then use flag variations to expose different sorting methods and pagation.
*/
// Define flag variable defaults (if the flag is disabled, you fall back to these values)
String sortMethod = "alphabetical";
int pageLimit = 10;
// Is the flag enabled for the user?
OptimizelyUserContext user = optimizely.createUserContext("userId");
OptimizelyDecision decision = user.decide("product_sort");
Boolean enabled = decision.getEnabled();
/**
* In the online Optimizely app, go define flag variations using
* sort_method and page_limit variables.
* For example, variation_1 might sort by popularity and limit results to 15 pages.
*/
if (enabled)
{
// get flag variable values depending on the variation the user bucketed into
try {
sortMethod = decision.getVariables().getValue("sort_method", String.class);
pageLimit = decision.getVariables().getValue("page_limit", Integer.class);
} catch (JsonParseException e) {
e.printStackTrace();
}
}
// Fetch products using the flag variables, using something like this pseudocode:
List products = productProvider.get(sortMethod, pageLimit);
"""
Fetch enabled state for the "product_sort" flag.
Then use flag variations to expose different sorting methods and pagination.
"""
# Define flag variable defaults (if the flag is disabled, you fall back to these values)
sort_method = "alphabetical"
page_limit = 10
# Is the flag enabled for the user?
user = optimizely.create_user_context("user123")
decision = user.decide("product_sort")
enabled = decision.enabled
"""
In the online Optimizely app, go define flag variations using
sort_method and page_limit variables.
For example, variation_1 might sort by popularity and limit results to 15 pages.
"""
if enabled:
# get flag variable values depending on the variation the user bucketed into
sort_method = decision.variables["sort_method"]
page_limit = decision.variables["page_limit"]
# Fetch products using the flag variables, using something like this pseudocode:
products = ProductProvider.get(sort_method, page_limit)
# Fetch enabled state for the "product_sort" flag.
# Then use flag variations to expose different sorting methods and pagination.
# Define flag variable defaults (if the flag is disabled, you fall back to these values)
sort_method = "alphabetical"
page_limit = 10
# Is the flag enabled for the user?
user = optimizely.create_user_context(userId)
decision = user.decide("product_sort")
enabled = decision.enabled
# In the online Optimizely app, go define flag variations using
# sort_method and page_limit variables.
# For example, variation_1 might sort by popularity and limit results to 15 pages.
if (enabled)
# get flag variable values depending on the variation the user bucketed into
sortMethod = decision.variables["sort_method"]
pageLimit = decision.variables["page_limit"]
end
# Fetch products using the flag variables, using something like this pseudocode:
products = productProvider.get(sortMethod, pageLimit)
/**
* Fetch enabled state for the "product_sort" flag.
* Then use flag variations to expose different sorting methods and pagation.
*/
//Define flag variable defaults (if the flag is disabled, you fall back to these values)
var sort_method = "alphabetical"
var page_limit = 10
// Is the flag enabled for the user?
let user = optimizely.createUserContext(userId: userId)
let decision = user.decide(key: "product_sort")
let enabled = decision.enabled
/**
* In the online Optimizely app, go define flag variations using
* sort_method and page_limit variables.
* For example, variation_1 might sort by popularity and limit results to 15 pages.
*/
if (enabled) {
// get flag variable values depending on the variation the user bucketed into
let sortMethod: String? = decision.variables.getValue(jsonPath: "sort_method")
let pageLimit: Integer? = decision.variables.getValue(jsonPath: "page_limit")
}
// Fetch products using the flag variables, using something like this pseudocode:
let products = productProvider.get(sortMethod, pageLimit)
// Fetch enabled state for the "product_sort" flag.
// Then use flag variations to expose different sorting methods and pagination.
// Define flag variable defaults (if the flag is disabled, you fall back to these values)
let sort_method = 'alphabetical';
let page_limit = 10;
// Is the flag enabled for the user?
var user = optimizely.createUserContext(userId);
var decision = user.decide('product_sort');
var enabled = decision.enabled;
//In the online Optimizely app, go define flag variations using
// sort_method and page_limit variables.
// For example, variation_1 might sort by popularity and limit results to 15 pages.
if (enabled) {
// get flag variable values depending on the variation the user bucketed into
sortMethod = decision.variables['sort_method'];
pageLimit = decision.variables['page_limit'];
}
// Fetch products using the flag variables, using something like this pseudocode:
let products = productProvider.get(sortMethod, pageLimit);
/*
* Fetch enabled state for the "product_sort" flag.
* Then use flag variations to expose different sorting methods and pagation.
*/
// Define flag variable defaults (if the flag is disabled, you fall back to these values)
$sort_method = 'alphabetical';
$page_limit = 10;
$userId = "user123";
// Is the flag enabled for the user?
$user = $optimizely->createUserContext($userId);
$decision = $user->decide('product_sort');
$enabled = $decision->getEnabled();
/**
* In the online Optimizely app, go define flag variations using
* sort_method and page_limit variables.
* For example, variation_1 might sort by popularity and limit results to 15 pages.
*/
if ($enabled) {
// get flag variable values depending on the variation the user bucketed into
$sortMethod = (string) $decision->getVariables()['sort_method'];
$pageLimit = (int) $decision->getVariables()['page_limit'];
}
// Fetch products using the flag variables, using something like this pseudocode:
$products = $productProvider->get($sortMethod, $pageLimit);
// Fetch enabled state for the "product_sort" flag.
// Then use flag variations to expose different sorting methods and pagination.
// Define flag variable defaults (if the flag is disabled, you fall back to these values)
let sort_method = 'alphabetical';
let page_limit = 10;
// Is the flag enabled for the user?
var decision = useDecision('product_sort');
var enabled = decision.enabled;
//In the online Optimizely app, go define flag variations using
// sort_method and page_limit variables.
// For example, variation_1 might sort by popularity and limit results to 15 pages.
if (enabled) {
// get flag variable values depending on the variation the user bucketed into
sortMethod = decision.variables['sort_method'];
pageLimit = decision.variables['page_limit'];
}
// Fetch products using the flag variables, using something like this pseudocode:
let products = productProvider.get(sortMethod, pageLimit);
// Fetch enabled state for the "product_sort" flag.
// Then use flag variations to expose different sorting methods and pagination.
// Define flag variable defaults (if the flag is disabled, you fall back to these values)
var sort_method = "alphabetical"
var page_limit = 10
// Is the flag enabled for the user?
var user = await flutterSDK.createUserContext("user123");
var decisionResponse = await user!.decide(sort_method);
var decision = decisionResponse.decision;
var enabled = decision!.enabled
// In the online Optimizely app, go define flag variations using sort_method and page_limit variables.
// For example, variation_1 might sort by popularity and limit results to 15 pages.
if (enabled) {
// get flag variable values depending on the variation the user bucketed into
var sort_method = decision.variables["sort_method"]
var page_limit = decision.variables["page_limit"]
}
// Fetch products using the flag variables, using something like this pseudocode:
var products = ProductProvider.get(sort_method, page_limit)
For more detailed examples, see:
- Android example usage
- Go example usage
- C# example usage
- Flutter example usage
- Java example usage
- Javascript example usage
- Node example usage
- PHP example usage
- Python example usage
- React example usage
- Ruby example usage
- Swift example usage
Next steps
Use flag variations to build flag delivery rules or experiment rules:
Updated 2 months ago