Stages and parallel tasks
How tasks group into stages and run in parallel.
The tasks in an automation don't just run one after another. They're organized into stages — and that's what lets an automation do several things at once, then wait, then do the next thing.
What a stage is
A stage is a group of tasks that run at the same time, in parallel. An automation can have several stages, and they execute in order: the next stage doesn't start until every task in the previous one has finished. That barrier between stages is the whole point — it's how you say "do these things together, and only once they're all done, move on."
The two rules
- Within a stage: parallel. Every task in the same stage runs concurrently. A stage holds up to 5 tasks.
- Between stages: in order. Stages run one at a time, with a barrier between them. The previous stage must fully finish before the next begins.
In the builder, each stage is a column. Drag a task onto another column to move it into that stage, or drop it in the gap between columns to start a new stage.
A worked example
Say you want to refresh a reporting model each morning. Three stages do it cleanly:
Stage 1 (parallel) Stage 2 Stage 3
- Pipeline: Salesforce ┐
- Pipeline: Stripe ┘──► SQL rollup ──► Semantic Model
(redeploy Finance)
- Stage 1 runs two ingestion pipelines in parallel — Salesforce and Stripe land at the same time.
- Stage 2 waits for both, then runs a single SQL Script that rolls the fresh data into a summary table.
- Stage 3 waits for the rollup, then redeploys the "Finance" semantic model on top of it.
Each stage starts only after the one before it succeeds, so the rollup never reads half-loaded data and the model never rebuilds on a stale table.
One thing to watch
The same pipeline can't genuinely run twice at once. If you put two tasks that trigger the same pipeline in one stage, the engine serializes them — both runs happen, but one after the other, not in parallel. The builder flags this with a warning. If you really need a pipeline to run twice, split the two runs across separate stages.
A stage is "things that are safe to run together." If task B reads what task A writes, they belong in different stages — put A first.