Appearance
What are flows?
A flow is the automation half of FlowRunner. You wire a handful of nodes together on a canvas, and FlowRunner turns that picture into a real program that runs on the server and answers an HTTP endpoint — no code involved.
A flow is a graph of nodes
Every flow is made of two things:
- Nodes — the boxes on the canvas. Each node does one job: check a condition, loop over a list, call an API, send an email, read from a database, shape a response. See the Node reference for the full list.
- Connections — the wires between nodes. A connection leaves one node's output port and enters the next node's input port. The wires decide the order things happen in.
A flow always begins at a Start node and, when it has done its work, reaches an End node that shapes what the caller gets back.
Ports and the paths through a flow
Ports are how a node says "go this way next". Most nodes have a single next port and simply hand off to whatever is wired after them. Decision nodes have more than one:
| Node | Output ports | What picks the port |
|---|---|---|
| If | true, false | The result of its condition |
| Switch | one port per case, plus default | The value being matched |
| ForEach | loop (the body), then next | Runs the loop branch once per item |
| Most others | next | Always continues |
| End | none | The flow stops here |
Only the branch you wire actually runs. An If whose false port has nothing connected simply stops on that side — nothing downstream happens.
NOTE
Every node also has a hidden error port. Wire it up and a failure becomes a handled branch instead of a crashed run. See Error handling.
The run model
When the endpoint is called, the engine starts at the matching Start node, seeds it with the request's inputs, and walks the wires:
- It runs the current node.
- The node returns which output port is active.
- The engine follows every connection leaving that port to the next node, and repeats.
As it goes, each node can leave a value behind in a shared refs object — the running memory of the flow — so later nodes can read what earlier ones produced. That mechanism is covered in Data & references.
The walk stops when it reaches an End node (which shapes the HTTP response) or runs out of wired paths. Two guardrails keep a runaway or accidentally-cyclic flow from spinning forever: a hard cap of 10,000 execution steps and 10,000 iterations per ForEach.
TIP
A flow is exposed at /api/run/<project>/<flow-name>, and the HTTP method it answers (GET, POST, …) is set on the Start node. One flow can even have several Start nodes to answer several methods. See Testing & the trigger URL.
Every execution — whether triggered by an HTTP call or a schedule — is recorded so you can see exactly what happened. See Run history.