End

The End node defines the termination point of a Flow.

It finalizes Flow execution, performs persistent data saving, and defines the response returned to the Flow caller.

A Flow may contain one or multiple End nodes, typically used to represent different execution outcomes (e.g. success, failure, alternative branches).

Execution Behavior

During execution, the End node:

• finalizes the Flow execution

• persists all pending Create and Update operations to the database

• evaluates and prepares output variables

• returns the response to the calling system

Once an End node is reached, no further nodes are executed.

Data Persistence

All Create and Update nodes operate in memory during Flow execution.

Actual persistence to the database occurs only when an End node is executed.

This design ensures:

• transactional consistency

• predictable rollback behavior

• safe Flow experimentation and debugging

If the Flow reaches an End node successfully, all accumulated changes are committed.

Output Variables

The End node can define output variables that are returned to the Flow caller.

Each output variable has:

• a name

• a defined data type

• a value definition

Output variables form the external response contract of the Flow.

Output Value Definition

Output values can be defined using the same mechanisms as other nodes:

Static Values

Fixed values defined directly.

Typical use cases:

• status codes

• result flags

• constant response values

DataStore References

Values can be referenced directly from the DataStore, such as:

• input variables

• loaded objects

• created or updated entities

• calculated variables

This allows returning process results without duplication.

Expression Language Values

Output values can be defined using Expression Language.

Expressions allow:

• transforming internal data into API-friendly output

• formatting values

• conditional response construction

• aggregating multiple values

Expressions are evaluated at runtime against the final DataStore state.

For syntax rules, functions, and type compatibility, see Expression Language (Low-Code Syntax).

Expression Evaluation Context

Expressions in the End node:

• are evaluated after all process logic is completed

• operate on the final state of the DataStore

• must resolve to values compatible with declared output types

• do not modify process state

This makes the End node ideal for response shaping, not business logic.

Multiple End Nodes

A Flow can contain multiple End nodes.

This is commonly used to:

• represent different outcomes (e.g. success vs. error)

• return different response structures

• separate logical execution branches

Each End node defines its own output configuration.

Typical Usage

The End node is typically used to:

• commit Create and Update operations

• return created or updated entity identifiers

• expose calculated results

• signal process completion to the caller

In most Flows, the End node represents the boundary between internal process execution and external system interaction.

Interaction with Expression Language

While the End node does not control Flow logic, it is a key integration point for Expression Language when:

• shaping responses

• converting internal data structures

• applying final formatting or calculations

Expressions in the End node should remain focused on presentation and output, not decision making.

Notes and Limitations

• At least one End node is required for a valid Flow

• Once an End node is reached, execution stops

• Data persistence occurs only at End node execution

• Complex business logic should not be placed in End node expressions

• Output types must match declared variable types or be convertible