ArcGIS Blog

Nov 10, 2026

Dynamic choice input: Building smarter and more resilient forms

By Bekah Bollin

Forms are an excellent way to optimize attribute editing workflows across the ArcGIS Online platform. Now there’s a new tool (or rather, a new input type) in your toolkit to dynamically generate choices in a drop-down. No need to create coded value domains or maintain a static list of options, just write an ArcGIS Arcade expression to handle it for you! Read on to learn about:

What a dynamic choice input is and how it works
How to configure your own dynamic choice input
Building a choice expression & common examples to get started

Gif shows the choices in a dynamic choice input change as a point feature is moved around — Values in the Dynamic choice input can variably change. For example, returning the nearest addresses as a feature is moved.

What is dynamic choice and how does it work?

Forms have multiple ways to show a list of options, whether it is a combo box, radio buttons, or a multiple-choice input. Dynamic choice is a new input type that allows form authors to generate a focused list of choices for users that is powered by an Arcade expression. The expression defines the logic for the list and can draw values from a variety of sources, including another layer or table. This means that users find the correct value quickly and edit data more accurately.

Dynamic choice works similarly to a combo box or a generic drop-down, where a list of options is presented to the user. The choice expression determines the available options and runs each time the drop-down opens, provided the field is editable. As form values or source data change the expression can return a different list, meaning that the editor has the most up to date values to pick from. Choice expressions can also reduce the need for schema changes by filtering out irrelevant or retired domains from the drop-down, without removing them on the layer itself.

Gif shows simple choices changing based on other values in the form. — Dynamic choice values can change dependent the configured choice expression.

You might be curious what happens if an existing choice is no longer in the drop-down list due to a change in the choice expressions evaluation. Rather than removing a previously applied value, it will remain unchanged until the user selects a different choice or chooses No Value. When editing multiple features, the dynamic choice input displays only choices available for all selected features. Selecting a value applies it to every selected feature.

GIF shows a dynamic choice expression input opened on mobile — Dynamic choice inputs are saved in the form, meaning that they can be used on the web and mobile.

How to configure your own dynamic choice input type

Setting up a dynamic choice input is a breeze! Open the Forms builder in either Map Viewer or Field Maps Web Designer, then drag the Dynamic choice option from the choice list under Form elements onto the form. You can also convert an existing field (see the list of supported field types under Notes to consider) by choosing the input type of the field’s Properties panel.

A dynamic choice input is dragged onto the form builder and configured — Drag a new "Dynamic choice" input onto the canvas or convert an existing field.

To finish configuring the dynamic choice input, you will need to author an Arcade expression. Find the Logic section on the Properties panel and click the gear icon to launch the Arcade editor.

The image shows a dynamic choice input with the expression required in the logic field — You must create a choice expression before you can save the form.

Notes to consider

Dynamic choice supports hosted feature layers, subtype group layers, tables, and subtype group tables.
Dynamic choice is available as an input type for the following field types:
- String, GUID, Date, Date Only, Time Only, Double, Integer (short or long), or Big Integer field.
Dynamic choice expressions are not supported if there is
- A field that participates in a contingent value field group
- A floor aware field
- A subtype field
Fields with coded value domains and/or ranges are honored when using the dynamic choice input
Dynamic choice input authoring will be supported in ArcGIS Enterprise 12.3.
Taking dynamic choice offline
- Users can take forms with dynamic choice input types offline when the data required by the expression is available in the offline map area.
  If you plan to use dynamic choice offline, include any referenced layers or tables in the map and confirm that they support offline use before downloading the map area. If the expression uses standalone tables, enable Include standalone tables.

Building a dynamic choice expression

To author a dynamic choice expression in the Arcade editor, form authors must use the new Form Dynamic Choice profile. This profile supports the dictionary return type (a collection of key-value pairs) that is required to provide choices in a dynamic choice expression.

A dynamic choice expression must return a dictionary with a choices property containing a list of choices. Each choice includes a name, which is what will appear in the picker, and a code, which is stored in the field when the choice is selected. Let’s take a look at how this is structured in a simple example below:

Creating a choice list

// Example of the correct return structure for the choices list.
return {
    choices: [
        {
            name: "Choice A",
            code: "choice a"
        },
        {
            name: "Choice B",
            code: "choice b"
        }
    ]
};

As the form author, there are a few things you will want to keep in mind to ensure your expressions run smoothly and return the correct choices.

Make sure each code is unique, matches the field’s data type, and meets the field’s requirements (such as the maximum length of a String field).
If the field has a coded value domain, the form will only return choices that have matching code values (including case sensitivity).
As the expression author, you are also responsible for sorting choices when needed and handling queries that may exceed the service’s record limit.

Common choice expression examples

As you have seen, dynamic choice expressions are extremely customizable. Let’s walk through a few examples that might inspire you to use choice expressions in your own forms!

Using data from City of Sydney, we have a map containing bike parking locations across urban areas in Australia. Editors currently enter values such as the bike rack type, nearest associated address, and suburb manually. This has led to inconsistent values, confusion, and additional time reviewing data after it has been entered. We will create multiple dynamic choice expressions to intelligently return options for editors, starting with the bike rack type. The form’s “Type” field already has a domain, and the expression below shows how to return its domain values as choices.

Returning coded-value domains as choices

// Create choices using list of values from a field with a coded value domain.  
var domainField = "Type";  

// Create an empty array to hold the choices.  
var choices = [];  
  
// Get the different bike rack types from the domain and put them into the new choices array.  
var domainInfo = Domain($feature, "type");  
 
for (var item in domainInfo.codedValues) {  
    Push(choices, domainInfo.codedValues[item]);  

}  

// Return the new choices. 
return {  
    choices: choices  
};

Image shows values returned from a dynamic choice expression for the type field — The Dynamic choice input now returns all the valid domains for the "Type."

This simple expression is returning all of the coded-value domains on the “Type” field, but you could add or remove values by adjusting the expression without making changes to the domain schema.

Next, we want to write an expression for the “Nearest address” field in the form so that it pulls in all the addresses within 50 ft of a placed point. The addresses are tracked via a “Name” field on a different layer of property boundaries in the web map. The example below lays out how we can leverage dynamic choice to create a list of spatially relevant attributes.

Return choices from a different layer in your web map

// Create a FeatureSet for the property boundary layer in the web map.  
var propBoundaries = FeatureSetByName( 
  $map, 
  "Property boundaries", 
  ["Address"], 
  true 
); 

// Create a buffer (in this example, 50ft) and a variable for property boundaries that intersect with the buffer. 
var featureBuffer = Buffer(Geometry($feature), 50, "feet"); 
var intersectingFeatures = Intersects(propBoundaries, featureBuffer); 
var addresses = []; 
 
// Loop through the returned intersecting features and put them into the new choices array. 
for (var feat in intersectingFeatures) { 
  if (!IsEmpty(feat.Address)) { 
    var domainEntry = { 
    code: feat.address, 
    name: feat.address 
    }; 

    Push(addresses, domainEntry); 

  } 
} 

// Return the new choices.  
return {choices: addresses}

GIF shows values changing as a feature is moved — Using the expression above, different addresses are returned as the bike rack location is moved.

Before dynamic choice input was introduced, you could only return one intersecting feature at a time via a calculated expression. Now, following the example above you can return a list of features that change dynamically based on your feature’s geometry!

Finally, let’s explore one more example of how to build a dynamic choice expression that references a table (or feature layer) outside of the web map. There is a separately maintained table that contains all the relevant suburbs around Sydney, and we would like to use those values to drive the choices returned in the dynamic choice input. Follow along to see how we can achieve this.

Return choices from an external layer

// Create a FeatureSet that references a portal item.
var Features = FeatureSetByPortalItem(
  Portal("https://www.arcgis.com"),
  "enterTheItemID",
  0,
  ["Name"],
  false
);

//Create a new variable that filters out Suburbs with empty "Name" values. Then, create a loop that returns all valid the features found in the referenced item. 
var namedSuburbs = Filter(Features, "Name IS NOT NULL AND Name <> ''");
var choices = [];

// Assign the key and value pair (using "code" as key and "name" as value) 
for (var suburb in namedSuburbs) { Push(choices, Dictionary("name", suburb.Name, "code", suburb.Name)); } 
// Return the new choices.  
return { choices: choices };

Image shows choices populated from an external table — In this example, the choices are populated from a table outside of the webmap.

By referencing values in an item to determine what appears in the choice list, you no longer need to maintain schema changes to coded values domains. If a value is added or removed from the referenced item, it will reflect accordingly in the dynamic choice input.

Conclusion

The dynamic choice input is a powerful new addition to Forms. Whether you want to pull in values from a layer or table outside of the web map, reduce the need for schema changes, or simplify the editing experience for your users, dynamic choice expressions allow you to customize the form to your needs.

Bekah Bollin

Bekah joined the ArcGIS Online team in 2022 as a Product Engineer. She contributes to a variety of projects in the ArcGIS Online space including GIS data editing, management, and visualization. When she is not making maps, she can be found hiking outside with her dog or finding a cozy coffee shop.