How execution flow works

Flovello pipelines are made up of nodes connected by two distinct types of connections. Understanding the difference is the key to building pipelines that do exactly what you intend.

The two kinds of pins

Every node in Flovello has one or more pins on its sides. There are two categories:

Execution pins (white triangles)

Execution pins look like small white triangles pointing in the direction execution flows. They define the order in which nodes run. An execution connection from node A to node B means "run node B after node A finishes". Most side-effecting nodes — nodes that write to a log, send an email, or make an HTTP request — have execution pins. These are called action nodes.

The Log message node, for example, has one execution input and one execution output. The execution input fires the node; after the log is written, the execution output fires to continue the pipeline.

The Branch node has one execution input and two execution outputs: true and false. Exactly one output fires per execution, depending on the value of the condition input.

Argument pins (colored circles)

Argument pins look like colored circles. Their color indicates the data type: pink for strings, green for integers, red for booleans, and so on. Argument connections pass data values from one node's output to another's input. They have no effect on execution order by themselves.

Pure nodes

A pure node is a node that has no side effects and no execution pins. It is simply a function that takes inputs and returns outputs. The Equals node is a good example — it takes two values and returns a boolean. It has no white triangles because it does not need to participate in execution order.

Pure nodes are evaluated lazily: Flovello only runs a pure node when a downstream action node actually needs its output. If nothing ever reads the result of an equals node, it is never run.

How lazy evaluation works

Consider this example pipeline:

1. A Receive HTTP trigger fires.
2. The method output is wired into an equals node that checks whether it equals "POST".
3. The result of equals is wired into the condition input of a Branch node.
4. The true pin of branch leads to a "Log message" node; the false pin leads to a "Fail" node.

Here is what happens at runtime:

1. Flovello starts executing from the trigger's execution pin.
2. It reaches the branch node and needs to evaluate condition.
3. condition is connected to equals.result, so Flovello evaluates equals now — reading receiveHTTP.method as a side effect.
4. equals returns true or false.
5. branch fires either the true or false execution pin.

Notice that equals itself is never explicitly scheduled — it runs only because branch needed its output. This is lazy evaluation.

Why this design?

Separating execution order from data flow lets you express complex logic clearly:

• Use argument connections freely to wire data wherever it is needed, without worrying about whether that computation "runs at the right time". Pure nodes run exactly when their output is first consumed.
• Use execution connections only where the side effect order matters — writing logs, sending requests, looping over items.

This mirrors how functional programming languages separate pure functions from impure (side-effecting) ones, and it is what makes Flovello pipelines both easy to read and easy to reason about.

Example: checking request method before logging

The equals node has no execution pins. It is evaluated lazily when branch reads its condition input. The branch node has one execution input (from the trigger) and two execution outputs. Only one output fires.

Summary

For more detail on individual nodes, visit the Node reference.