Parallel group

A Parallel group stage is a container that holds multiple stages running simultaneously.

A Parallel group stage is a container that holds a set of child stages and runs them all at the same time. The group appears as a single node on the pipeline canvas. Stages inside the group start together and run concurrently; the group does not complete until all child stages finish.

What you will learn

• What a Parallel group stage is and how it runs child stages simultaneously

• How to create a parallel group and add stages to it using the canvas or YAML

• How failure of one child stage affects the group's outcome

• What execution settings (failure strategy, conditional execution, timeout) are available per child stage

When to use parallel groups

• You want to run independent stages simultaneously to reduce total pipeline time, for example, deploying to multiple regions at the same time, or running multiple test suites in parallel

• You have stages with no dependency on each other and want them to run as fast as possible

Create a parallel group and add stages

To create a Parallel group:

1. On the pipeline canvas, select + to add a stage.

2. In the Add stage panel, select Parallel group. This creates the group with an initial empty stage inside it.

3. Configure the first stage: add steps, set the runtime, and configure any stage-level settings.

To add more stages to the group:

1. Click the + button at the bottom of any existing stage inside the parallel group.

2. This adds a new stage alongside the existing ones within the same group.

3. Configure the new stage independently.

Repeat this for as many parallel stages as you need. Each stage in the group is fully independent; it has its own steps, runtime, and settings.

In YAML, stages inside a parallel group are defined under parallel.stages:

pipeline:
  id: my_pipeline
  name: My Pipeline
  stages:
    - name: parallel_group
      id: parallel_group
      parallel:
        stages:
          - name: branch-a
            id: branch_a
            steps:
              - name: step-a1
                id: step_a1
                run:
                  script: echo "branch A - step 1"
              - name: step-a2
                id: step_a2
                run:
                  script: echo "branch A - step 2"
          - name: branch-b
            id: branch_b
            steps:
              - name: step-b1
                id: step_b1
                run:
                  script: echo "branch B - step 1"
              - name: step-b2
                id: step_b2
                run:
                  script: echo "branch B - step 2"

How parallel groups work

1. When the pipeline reaches the parallel group, all child stages start at the same time.

2. Each child stage runs independently; a step failure in one branch does not automatically stop another branch.

3. The parallel group completes when every child stage finishes (success or failure).

4. If any child stage fails, the group is marked as failed.

Stage settings within a parallel group

There are no execution controls at the parallel group level. Each child stage inside the group has its own independent settings:

Setting	Configured on
Steps	Each stage individually
Failure strategy	Each stage individually: controls what happens if a step in that stage fails
Conditional execution	Each stage individually: a stage can be skipped based on an expression while others still run
Timeout	Each stage individually: each branch can have a different timeout
Runtime Environment	Each stage individually: branches can run on different infrastructure

Concurrent execution within a parallel group is subject to the account-level parallelism limit and the per-execution concurrency limit. If the group exceeds these limits, some child stages are queued until capacity is available.

Next steps

• Go to Serial group to run a set of stages in sequence instead of simultaneously.

• Go to Strategy to run a single stage multiple times using matrix, for, or while loops.

• Go to Stage overview to understand how stages work and how to add them to a pipeline.