The Update Data Node modifies values within the workflow's internal data store — form fields and global constants — without calling any external system. It reads a value from one place in the Data Center, resolves it, and writes it to another. This is the primary tool for moving data between forms, populating calculated values, and maintaining workflow-level variables as a process advances.

The Update Data Node executes instantly, requires no human interaction, and has a single output handle.

When to Use

Use an Update Data Node when your workflow needs to:

Copy a value from one form to another. For example, after a user submits a leave request, copy the manager's name from the employee profile into the approval form so the approver can see it.
Populate a form field with the output of a previous Action or Function Node. For example, write a ticket number returned by a ServiceNow action into a summary form that will be shown to the requester.
Update a global constant to track workflow state. For example, change a "Status" constant from "Pending" to "In Review" after an approval step completes.
Combine or rearrange data before a Decision Node. For example, copy a calculated total into a field that the Decision Node will evaluate for threshold-based routing.
Pre-fill fields on an upcoming Input or Approval form with values collected earlier in the process, so users don't have to re-enter information.
Write API response data from an Action Node's execution output into a human-readable form field for display to end users.

Configuration

Mapping Rules

The Update Data Node is configured with a list of mapping rules. Each rule defines a single data movement — one source value written to one destination.

Field	Description
Source (Output Field)	A Data Center expression that resolves to the value you want to read. This can reference any data available in the Data Center: form fields, node execution outputs, global constants, global properties, or initiator details. Expressed in double curly braces, e.g., `{{forms.leaveRequest.startDate}}` or `{{nodes.createTicket.executionData.data.ticketNumber}}`.
Destination (Form Field / Global Constant)	The location where the resolved value should be written. Can be either a form field (e.g., `forms.approvalForm.ticketNumber`) or a global constant (e.g., `globalConstants.currentStatus`).

You can add multiple mapping rules to a single Update Data Node. Each rule is processed independently — if one rule has an empty source or destination, it is skipped without affecting the others.

Writing to Form Fields

When the destination is a form field (e.g., forms.summaryForm.totalAmount), the resolved value is written directly into that form's data. The updated value becomes visible the next time a user sees that form — typically in a downstream Input or Approval Node. This is the primary mechanism for pre-filling or enriching forms with data collected or computed earlier in the workflow.

Writing to Global Constants

When the destination starts with globalConstants. (e.g., globalConstants.approvalStatus), the resolved value is written to the workflow-level constant. Global constants are accessible from anywhere in the workflow — any downstream node can reference the updated value. Only global constants that are marked as updatable can be written to.

Selecting Available Fields

When configuring mapping rules in the workflow builder, the system presents you with the available source and destination fields:

Source fields include all Data Center expressions available at this point in the workflow: form fields from any published form, outputs from upstream nodes (Action, Function, Mapper, etc.), global constants, global properties, and initiator details.
Destination fields include all writable form fields (from published forms in the workflow) and all updatable global constants.

This ensures you can only configure mappings that reference real, reachable data and write to valid destinations.

How It Works at Runtime

Data Center is loaded — the node retrieves the full current state of the workflow's Data Center, including all form data, node outputs, global constants, and system properties. If the node is inside a loop, it loads the state for the current iteration.
Each mapping rule is processed — for every rule in the mapping list:
- The source expression (Output Field) is resolved against the Data Center. For example, {{nodes.lookupAction.executionData.data.employeeName}} is replaced with the actual employee name returned by that action.
- The resolved value is written to the destination. If the destination is a form field, the value is placed into that form's data store. If the destination is a global constant, the constant is updated.
- Rules with an empty or null source or destination are silently skipped.
Execution completes immediately — the node returns a completed status and the workflow advances to the next step. The updated form data and global constants are persisted and available to all downstream nodes.

Data Center Output

The Update Data Node does not produce its own output data in the Data Center the way an Action or Function Node does. Instead, it modifies existing data — form fields and global constants — in place. The changes are immediately visible to all downstream nodes that reference those fields.

After execution, the node stores an execution mapping log — a record of each mapping rule that was processed, showing the source expression, destination path, and the resolved value that was written. This log is available for debugging and auditing purposes.

Inside Loops and Synchronous Blocks

The Update Data Node works in all execution contexts:

Context	Behavior
Standalone	Executes asynchronously as part of the normal workflow graph traversal.
Inside a Synchronous Block	Executes immediately in real time as part of the sync block sequence. Useful for updating form data between two sync-block steps that happen while the user is waiting.
Inside a For Each Loop	Executes once per iteration. The Data Center is scoped to the current iteration's context, so each iteration reads and writes to iteration-specific data.
Inside a While Loop	Executes once per loop cycle. The Data Center reflects the current cycle's state, allowing the node to update values that the While condition evaluates.

Progress Path

The Update Data Node appears in the workflow item's progress tracker with timestamps:

Status	Displayed Fields
Executed	Triggered at, Completed at
Default	Triggered at

Two visibility settings control whether the node appears in the progress tracker:

Setting	Description
Hide	Completely hides the node from the progress tracker. Since Update Data Nodes are internal data operations, hiding them is common to keep the progress tracker clean for end users.
Hide if Skipped	Hides the node only if its execution was skipped. Shows it normally for all other statuses.

Validation Rules

The workflow builder validates Update Data Nodes at publish time using the generic node validation strategy:

The node must have at most one incoming edge and at most one outgoing edge.
The node must not be abandoned — it cannot have zero incoming and zero outgoing edges.
The node must have at least one incoming edge.
The node must have at least one outgoing edge (unless the target handle is explicitly hidden).
Each mapping rule's source (outputField) and destination (formField) must be strings (empty or null values are allowed — those rules are simply skipped at runtime).

Best Practices

Use Update Data Nodes to bridge forms. When information collected in one form needs to appear in a later form (e.g., copying employee details from a request form into an approval form), an Update Data Node placed between the two form steps is the cleanest approach.
Update global constants to track workflow state. If your workflow has a status variable that drives Decision Node logic or is displayed in the progress tracker, use Update Data Nodes at key transition points to keep it current (e.g., "Submitted" → "Under Review" → "Approved").
Place the node after the data source is available. An Update Data Node resolves source expressions at runtime — if the upstream node that produces the data hasn't executed yet, the expression will resolve to null. Ensure the node is positioned downstream of all data sources it references.
Use multiple mapping rules on a single node rather than chaining several Update Data Nodes in sequence. A single node with five rules is simpler and more readable than five separate nodes.
Hide the node from the progress path for internal data operations. End users typically don't need to see that a form field was copied behind the scenes — hiding it keeps the progress tracker focused on meaningful business steps.
Combine with Action Nodes for API response surfacing. A common pattern is: Action Node calls an external API → Update Data Node writes key response values (ticket number, status, reference ID) into a form → next Input or Approval Node displays the form with the updated values. This gives end users visibility into what the integration did.
Use inside loops for per-iteration updates. When processing a list with a For Each loop, an Update Data Node inside the loop can write iteration-specific values to form fields or constants that the loop body needs.
Keep mapping rules focused. Each rule should do one clear thing. Avoid complex chains where one rule depends on another rule in the same node — since all rules read from the Data Center as it was at the start of execution, they don't see each other's writes within the same node.
Once enabled, the constant label would start to reflect under the dropdown of Update Data node.