FlowsGuide

Parallel branches

A Parallel branches node starts two or more named branches together and waits for all of them. The step after it reads each branch’s result by the branch’s name — so a flow can write to the database, send an e-mail and call an API at the same time, and still know which result came from where.

9 min readBefore this: What a flow is, Passing values between stepsOpen in Waiso
What you will learn
  • Add a Parallel branches node and put steps in each branch
  • Read each branch’s result as output["Branch name"]
  • Decide what happens when a branch fails, with May fail
  • Run branches one at a time when order matters

How a parallel node works

A flow normally runs one step after another. A Parallel branches node splits it: every branch under the node starts at the same moment, each branch runs its own steps from top to bottom, and the node finishes when the last branch finishes. The step under the node’s join runs once, after all of them.

Three branches start together; the join waits for the slowest one.

Branches have names, and the names matter: the node’s output is an object with one entry per branch, keyed by its name, holding the output of that branch’s last step. Three branches that each wait two seconds take about two seconds together, not six — the node’s duration is close to its slowest branch.

Build one

  1. Add the node

    Click the + between two steps on the canvas and pick Parallel branches. The node arrives with two branches, Branch 1 and Branch 2.

  2. Name the branches

    In the side panel, type a name for each branch. Add more with Add branch, drag a row by its handle to reorder, and remove one with X — a node always keeps at least two. Names are trimmed, 1–80 characters, and unique ignoring case.

  3. Fill each branch

    Each column under the node is one branch. Use the + under a branch’s name to add steps to it — scripts, SQL, HTTP, e-mail, anything a flow can hold except an Approval step.

  4. Continue after the join

    The step under the join runs once every branch has finished. Bind its inputs to the branch results (next section).

Use each branch’s result

In a later step, bind an input to the parallel node’s output and pick the branch by name. The binding reads output["Branch name"]; the From node picker lists the branch names even before the flow has ever run. A branch whose last step returned nothing gives null.

Expected outputSuccessThe node’s output: one entry per branch
{
  "Invoice": {
    "id": "INV-1042",
    "total": 129.9
  },
  "Customer": {
    "name": "Ana Souza",
    "tier": "gold"
  },
  "Notify": null
}

Renaming a branch in the side panel rewrites the bindings that read it, so a later step never points at a name that no longer exists.

When a branch fails

If a branch fails, the others still finish what they are doing; then the node fails and its error names the branch (branch "Invoice": …). When several fail, the first in branch order is the one reported. The flow then follows its usual rules: the On error step runs and alerts fire.

Branches that may fail

Turn on May fail on a branch whose failure should not stop the flow — a notification, a best-effort cache write. That branch still shows its error on the canvas and in the run, its entry in the output is null, and the node succeeds. Retries and Continue on error from run settings work inside a branch exactly as anywhere else.

One branch at a time

Run one branch at a time keeps the names and the output but runs the branches in the order shown, each after the previous one. Use it when branches share something that cannot be used twice at once — one API key with a strict rate limit, a file both write. A branch that fails (and may not fail) stops the ones after it; they are marked skipped.

SettingBranches startA failing branch
Run together (default)All at onceOthers finish, then the node fails
Run one branch at a timeIn the order shownBranches after it are skipped
A branch with May failAs its node saysIts entry is null, the node succeeds

Watch it run

In a run, every branch shows its own status and time on the canvas, and the run panel lists the branches with theirs. The Timeline tab gives each branch its own lane: bars that overlap are branches that ran together.

Limits and rules

  • At least two branches per node. A node with fewer is refused at publish and at run (parallel_branches_min).
  • Every branch needs a unique name (parallel_branch_name) and, to publish, at least one step (parallel_branch_empty).
  • Branches may hold loops, conditions and other parallel nodes.

Related topics