Serial group

A Serial group stage is a container that holds multiple stages running one after another in sequence.

A Serial group stage is a container that holds a set of child stages and runs them one after another in sequence. The group itself appears as a single node on the pipeline canvas. Stages inside the group run in the order they are defined; each must complete before the next begins.

What you will learn

• What a Serial group stage is and how it runs child stages in sequence

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

• How a failed stage affects the remaining stages in the group

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

When to use serial groups

• You want to visually group a related sequence of stages (for example, build → test → scan) without them appearing as separate top-level nodes

• You need a subset of your pipeline to always run in order, even when the surrounding pipeline uses parallelism

Create a serial group and add stages

To create a Serial group:

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

2. In the Add stage panel, select Serial 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 that appears after the last stage inside the serial group (to the right of the last stage, within the group boundary).

2. This adds a new stage at the end of the sequence within the group.

3. Configure the new stage independently.

Stages always execute left to right in the order they appear inside the group.

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

pipeline:
  id: my_pipeline
  name: My Pipeline
  stages:
    - name: serial_group
      id: serial_group
      group:
        stages:
          - name: stage-1
            id: stage_1
            steps:
              - name: step-1
                id: step_1
                run:
                  script: echo "stage 1"
          - name: stage-2
            id: stage_2
            steps:
              - name: step-2
                id: step_2
                run:
                  script: echo "stage 2"
          - name: stage-3
            id: stage_3
            steps:
              - name: step-3
                id: step_3
                run:
                  script: echo "stage 3"

How serial groups work

1. When the pipeline reaches the serial group, the first child stage starts.

2. Each subsequent stage starts only after the previous one completes successfully.

3. If a stage fails, the remaining stages in the group do not run (unless the failed stage's failure strategy says otherwise).

4. The serial group completes when the last child stage finishes.

Stage settings within a serial group

There are no execution controls at the serial 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 when a step in that stage fails
Conditional execution	Each stage individually: a stage can be skipped based on an expression while the group continues
Timeout	Each stage individually: each stage can have a different timeout
Runtime Environment	Each stage individually: stages in the same group can run on different infrastructure

Next steps

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

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