FlowsGuide

Steps in sequence

The simplest flow is a straight line: each step starts when the one above it has finished and can use everything the steps above returned. This page builds one — compute, then format, then report — and walks through everything a run records about each step.

8 min readBefore this: What a flow is, Passing values between stepsOpen in Waiso
What you will learn
  • Chain steps and pass each result to the next one
  • Read a step’s status, duration, waited and cold-start marks
  • Find a step’s inputs, output, bindings, logs and code in a run
  • Know what happens to the steps below one that fails

One step after another

Steps on the same line run in order, top to bottom, one at a time. A step’s output — the value a script returns, the rows of a query — is kept for the rest of the run, so the third step can read the first step’s output as easily as the second’s. Nothing is shared any other way: steps do not see each other’s variables or files, only the values you bind.

Each step turns green with its duration before the next one starts.

Each step runs in its own sandbox, in its own language — a Python step can feed a TypeScript step that feeds a C step. Values cross between them as JSON, so an output should be something JSON can hold: objects, lists, text, numbers, booleans, null.

Build a three-step chain

  1. Declare the input

    Click Start and add a Number parameter subtotal. That is what a run is started with.

  2. Add the first step

    Click the + under Start, pick a language and label the step Add tax. Use the code below and bind subtotal with From node → Start → subtotal.

  3. Chain the next ones

    Add a second step under it that takes total (bound to Add tax → total) and returns a formatted line, then a third that sends or stores it. Each + on the line inserts a step exactly there.

  4. Run it

    Click Run Flow, fill subtotal and start. The canvas follows the run live.

add_tax.py
def main(subtotal: float, rate: float = 0.1):
    tax = round(subtotal * rate, 2)
    print(f"tax on {subtotal}: {tax}")
    return {"subtotal": subtotal, "tax": tax, "total": round(subtotal + tax, 2)}
Expected outputSuccessAdd tax’s output for subtotal = 200
{
  "subtotal": 200,
  "tax": 20,
  "total": 220
}

What a run shows for each step

While a run is on the canvas, every step wears its outcome: running, succeeded (green), failed (red), skipped (dashed) or served from cache. Under the name sits the step’s duration — the time its own code ran — and two small marks when they apply: waited, the time it queued for a free worker, and cold start, the time a fresh interpreter took to start. Neither counts in the duration, so a slow step and a step that waited are told apart at a glance.

The Timeline: one bar per step, the wait drawn apart from the run.

A step’s run detail

Click a step on a run to open its detail in the side panel:

TabWhat it shows
DataWhat went in and what came out: the inputs the step received and its output.
BindingsWhere each input got its value — which step and path, which expression, which variable.
LogsWhat the step printed, in order.
CodeThe code this run executed — even if the step was edited since.

The flow’s own Run tab shows the run as a whole — its progress, its inputs and result, and a Timeline tab with every step on one time axis. Runs lists every run of the flow; pick one to put it back on the canvas.

When a step fails

A failing step stops the line: the steps below it do not run, the run ends Failed, and a banner above the run’s tabs names the step and the first line of its error, with Copy error. If the flow has an On error step it runs once, and the project’s alert rules fire.

Two run settings change that per step: retry tries the step again before giving up, and continue on error lets the flow go on — the step then shows Failed · the flow went on in amber, and the steps below it run.

  • The run’s progress bar is split by outcome — done, failed, skipped — against the number of steps in the flow, so how far a run got reads without opening anything.
  • A script error carries its frames: click a frame to jump to that line in the step’s code (script errors).

Limits

  • A whole run is bounded by the flow’s time limit — 30 minutes by default; a step can have its own shorter limit.
  • Script steps run without network access, like every script.
  • A step only reads outputs of steps that ran before it in this run; reading a later or skipped step fails the binding.

Related topics