What a flow is
A flow is a pipeline you draw instead of code: a vertical chain of steps that starts at the Start node and runs from top to bottom. Each step is a script, a SQL query, a decision, a loop or a ready-made action, and each one can use what the steps above it returned.
- Read the flow canvas and add a step with the + between two steps
- Know every kind of node a flow can hold, and when to pick each
- Tell the draft from the published version, and what publishing checks
- Follow a run as it walks the graph
A pipeline you can see
Open a flow and the canvas shows it as one column. At the top is the Start node: it declares the flow’s inputs (the parameters a person, a schedule or an API call passes in). Under it, every step hangs on the line in the order it runs. There is nothing to wire by hand and no position to manage — the canvas lays the flow out itself from its structure, so a condition opens its branches side by side, a loop draws a frame around its body, and every group closes with a cap where the flow continues.
A step’s result is its output — what a script returns, the rows a query reads, the answer an HTTP call gets. Any step below can take that output as one of its inputs; that link is a binding, and it is how data moves through a flow without any glue code.
Add a step
- Create the flow
On the project’s Code page click + New, pick Flow, type a Flow name and click Create flow. It opens with a Start node and nothing under it.
- Click a +
Every connector carries a +. Click the one where the step should go — under Start, between two steps, inside a branch or a loop body. The Add Node menu opens with a search box (Search node types…).
- Pick a node type
Choose a language under Scripts, a control node under Control, or a ready-made step under Apps & data. The step lands on the line and the steps below move down to make room.
- Configure it in the side panel
Clicking a step opens its panel on the right: the Parameters tab holds what it does, Run settings holds retries, time limit and cache. For a script step, Open code editor opens its code with the inputs beside it.
Copy, paste and undo work on steps the way they do in a text editor: select a step, copy it with Ctrl+C, select where it should follow and paste with Ctrl+V; the step’s right-click menu offers the same.
Every kind of node
The Add Node menu groups everything a flow can hold. Each kind has its own page.
| Node | What it does |
|---|---|
| Python, TypeScript, JavaScript, C, C++ | A script step with its own code, run in the same sandbox as any script. Existing Script links a script of the project instead, and always runs its current code. |
| PostgreSQL, MySQL | A SQL step: one query on a project connection; its rows feed the steps below. |
| Condition | If / else if / else: runs exactly one branch. |
| Loop | For each item of a list or of a query’s rows, one at a time or several at once. |
| Parallel branches | Named branches that run together; the next step reads each by name. |
| Approval | Pauses the run until a person approves or rejects it. |
| Flow, AI Scraper | Run another published flow, or a published scraper, as one step (subflows). |
| Send email, HTTP Request, Transform, AI step, File, Google Sheets, Google Drive | Built-in steps, no code: Send email, HTTP Request and Transform run today, configured in their side panel; the others are listed in the picker but not available yet. |
On error and Preprocessor
Two special steps sit outside the chain and appear as pills on the canvas instead of nodes on the line. The On error step runs once when the flow fails — to notify someone or record it; the run stays failed. The Preprocessor runs first, and only, when the flow is called through an API endpoint: it receives the request and returns the flow’s inputs. A flow has at most one of each.
Draft, publish, run
What you edit is the flow’s draft. Save stores it; Run Flow runs exactly what is on the screen, so you can try a change before anyone else depends on it. Publish checks the draft and freezes it as a numbered version — and the version is what everything outside the page runs: schedules, API endpoints, event triggers and other flows calling it as a subflow. Edits after that stay in the draft until you publish again; Version history lists every published version and can restore one.
What publishing checks
The same check runs when you publish and when you run, so a problem is named before any step executes. The answer names the step and carries a stable code:
missing_connection— a SQL step (or a built-in step that needs one) has no connection.unknown_variable/invalid_binding— a binding names a variable that does not exist, or mixes a variable with another source.invalid_parameter— a constant does not fit the type the script declares.approval_in_loop,approval_in_branch,parallel_branches_min— a step sits where it is not allowed.
How a run walks the graph
A run starts at Start with the inputs it was given and goes down the line. A step starts only after the one above it has finished; a condition runs only the branch it picks and marks the others skipped; a loop repeats its body once per item; parallel branches run side by side and meet at their join. The canvas shows it live — each step’s status and time on the node — and the run’s panel holds the details of every step (what a run shows).
Limits and rules
- A flow has one Start node, at most one On error step and at most one Preprocessor.
- A whole run has a time limit, 30 minutes by default, set in the flow’s settings; each step can have its own in Run settings.
- Script steps have no network access, like every script; reach outside services with the built-in steps or a project integration.