> ## Documentation Index
> Fetch the complete documentation index at: https://docs.twine.se/llms.txt
> Use this file to discover all available pages before exploring further.

# Flow Engine

> Twine's orchestration engine for running workflows with side effects

The **Flow Engine** is Twine's orchestration engine. Where the [Data Engine](/data-engine) describes how a single value is derived from other values, the Flow Engine describes a process: a sequence of steps that read from source systems, transform data, write to target systems, branch on conditions, loop over collections, and log what happened along the way.

A **Flow** is a saved, editable directed acyclic graph of nodes. When a flow runs, the engine walks the graph from its root, invoking each node in turn and threading a shared state object (the **token**) through every node. Side effects - API calls, database writes, log entries - happen as the graph runs, in the order the graph defines.

## Flow Engine vs Data Engine

The two engines share the same underlying node-graph model and editor, but they serve different purposes.

|                      | Flow Engine                                                       | Data Engine                                                           |
| -------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------------- |
| **Purpose**          | Orchestration: run a process with side effects                    | Transformation: derive a value from other values                      |
| **Side effects**     | Yes - steps call source/target systems, write logs, persist state | No - pure computation over values                                     |
| **Values that flow** | Token assigns (string-keyed map of named values)                  | Dated properties                                                      |
| **Top-level driver** | A saved Flow with optional schedules                              | A property mapping, domain condition, or other value derivation       |
| **Runs**             | Each run is recorded as a `FlowRun` with logs and status          | No run records; evaluation happens on demand inside another operation |

Flows can embed Data Engine graphs inside them. Nodes like [FlowTransform](/flow-engine/transformation/flow_transform), [FlowFilter](/flow-engine/transformation/flow_filter), and [FlowSwitch](/flow-engine/flow-control/flow_switch) carry an inner Data Engine graph that the Flow Engine evaluates to produce a single value - the transformed payload, the predicate result, or the branch name. Inside that inner graph, values flow as dated properties just like they do anywhere else in the Data Engine.

## Where to start

Before building a flow, read the concept pages in order:

* [Flows and runs](/flow-engine/concepts/flows-and-runs) covers what a flow is, how it is triggered, and what a run records.
* [Steps and assigns](/flow-engine/concepts/steps-and-assigns) introduces the token threaded through a run and the assigns map that nodes use to share values.
* [Execution and error handling](/flow-engine/concepts/execution-and-errors) covers graph traversal, branching, looping, and the policies that decide what happens when a step fails.
* [Scheduling and observability](/flow-engine/concepts/scheduling-and-observability) covers cron schedules, per-node log floors, and the run history.

## Node reference

The rest of this section is a reference for every flow-mode node available in the Flow Engine, grouped by category. Nodes that work in both the Flow Engine and the Data Engine (for example, reading and writing assigns, end nodes) are documented under the [Data Engine](/data-engine) reference and can be used freely in both contexts.