Expressions and Data Flow

Workflows become powerful when steps can use data from previous steps. Sovereign uses a template expression syntax that lets you reference outputs, trigger data, and variables anywhere in your step configuration.

The Basics

Expressions use double curly braces: {{ path.to.value }}. When the workflow engine prepares a step for execution, it replaces each expression with the actual value from your workflow's data.

There are three main data sources you can reference:

Trigger Data

Data passed when the workflow was started — from a manual run, a schedule, or a webhook.

{{ trigger.customer_name }}
{{ trigger.payload.order_id }}

Step Outputs

Results from steps that have already completed. Reference them by the step's node ID and the field name in its output.

{{ context.data.step_id.result.field_name }}

For example, if a step with ID fetch_customer returned a result containing a name field:

{{ context.data.fetch_customer.result.name }}

Variables

Workflow-level variables passed via configurations or at execution time.

{{ vars.environment }}
{{ vars.api_endpoint }}

Type Preservation

When an expression is the entire value of a field (not mixed with other text), the original data type is preserved. This means:

• An array stays an array (important for ForEach loops)
• A number stays a number
• A boolean stays a boolean
• An object stays an object

When an expression is mixed with text (string interpolation), the result is always a string:

Hello, {{ context.data.lookup.result.name }}!

This produces a string like Hello, Jane!.

Common Patterns

Access a field from a previous step

{{ context.data.get_order.result.total }}

Use trigger data in a step

{{ trigger.webhook_payload.event_type }}

Pass variables through a workflow

{{ vars.target_environment }}

Combine values in a message

Order {{ context.data.create_order.result.id }} created for {{ trigger.customer_name }}

Template Engine

Sovereign uses the Scriban template engine, which supports more than simple variable substitution. You can use:

• Conditionals — {{ if condition }}...{{ end }}
• Loops — {{ for item in collection }}...{{ end }}
• Filters — {{ value | string.upcase }}
• Math — {{ value + 1 }}

However, for most workflows, simple path expressions are all you need. The built-in action nodes (like filter, map, and conditional logic) handle complex data transformations more reliably than template expressions.

Error Handling

If an expression references a variable that does not exist, the workflow engine raises an error at dispatch time rather than silently producing empty output. This fail-fast behavior helps you catch misconfigured templates before they cause downstream issues.

Next Steps

• Error Handling and Retries — what happens when expressions or steps fail
• Node Types — learn about ForEach nodes that consume collections from expressions
• Triggers and Scheduling — how trigger data gets into your workflow