Stages Dependencies and Conditions

In this guide, we explore how stages, dependencies, and conditions work together to create flexible, reliable CI/CD pipelines in Azure DevOps. By mastering these concepts, you’ll ensure your code moves smoothly from development through testing and into production with minimal manual intervention.

Defining Stages and Dependencies in Azure Pipelines

Stages represent the major phases of your pipeline (for example, Build, Test, and Deploy). By default, these stages run in the order they’re defined, but you can customize their execution sequence with the dependsOn keyword. In the example below, the Deploy stage waits for both Build and Test to finish before starting:

stages:
  - stage: Build
    jobs:
      - job: build_app

  - stage: Test
    jobs:
      - job: run_tests

  - stage: Deploy
    dependsOn:
      - Build
      - Test
    jobs:
      - job: deploy_app

Each stage can contain multiple jobs (such as build_app, run_tests, and deploy_app) that run in parallel or sequence according to your configuration.

Using Conditions for Conditional Execution

Conditions add intelligence to your pipeline by allowing stages, jobs, or steps to run—or be skipped—based on branches, variables, or the outcomes of previous tasks. You define these checks using the condition keyword. For example, you may want to deploy to production only when the pipeline runs on the main branch and every prior stage has succeeded.

Use conditions to optimize build time and resource usage by skipping unnecessary stages.
For more details, see Variables in Azure Pipelines.

Example: Branch-Aware Multi-Stage Pipeline

Below is a sample YAML that combines sequential stages with branch-based conditions. The Build stage compiles your code and runs unit tests, with an extra check to decide whether to proceed. The Deploy stage only triggers on refs/heads/main.

stages:
- stage: Build
  jobs:
  - job: BuildJob
    steps:
    - script: echo "Building the project"
      displayName: 'Build'
    - script: echo "Running unit tests"
      displayName: 'Run Tests'
    # Only proceed on the main branch
    - script: echo "Proceeding to deployment stage"
      displayName: 'Check Branch'
      condition: eq(variables['Build.SourceBranch'], 'refs/heads/main')

- stage: Deploy
  dependsOn: Build
  condition: succeeded()
  jobs:
  - job: DeployJob
    steps:
    - script: echo "Deploying the application"
      displayName: 'Deploy'
    # Add more deployment steps here

In this setup, Deploy runs immediately after Build, but only when the source branch is main. Otherwise, the deployment stage is skipped.

dependsOn vs condition: Side-by-Side Comparison

Aspect	dependsOn	condition
Execution Control	Enforces order or parallelism based on stages	Evaluates expressions (branches, variables, results)
Criteria	Completion status of specified predecessors	Custom criteria (e.g., branch name, variable values)
Application Scope	Stage or job level	Stage, job, or individual step level
Parallel Execution	Supports parallel runs when no dependencies	Skips or runs tasks based on evaluated expressions

The image is a comparison chart highlighting the differences between "DependsOn" and "Condition" in terms of execution management, criteria, support, and application scope.

Best Practices for Stages, Dependencies, and Conditions

Align stages with your development lifecycle (e.g., Build → Test → Deploy).
Use dependsOn to enforce critical order or allow safe parallelism.
Apply condition to skip unnecessary runs and save resources.

Overly complex dependencies and conditions can make pipelines hard to maintain. Keep configurations as clear and simple as possible.

The image outlines three best practices: organizing stages logically, using conditions to skip unnecessary runs, and clearly defining dependencies. It features a central thumbs-up icon surrounded by these points.

References

Watch Video

Release Strategies

Implementing Release Gates

Introduction

Configure Activity Traceability and Flow of Work

Configure Collaboration & Communication

Work with Azure Repos and GitHub

Configuring and Managing Repositories

Design and Implement Pipeline Automation

Design and Implement Pipelines

Implementing an Orchestration Automation Solution

Design and Implement Deployments

Design and Implement Infrastructure as Code (IaC)

Maintain Pipelines

Design and Implement Authentication and Authorization Methods

Design and Implement a Strategy for Managing Sensitive Information in Automation

Implement Security and Validate Code Bases for Compliance

Configure Monitoring for a DevOps Environment

Analyze Metrics

Branching Strategies for Source Code

Design and Implement a Package Management Strategy

Stages Dependencies and Conditions

Defining Stages and Dependencies in Azure Pipelines

Using Conditions for Conditional Execution

Example: Branch-Aware Multi-Stage Pipeline

dependsOn vs condition: Side-by-Side Comparison

Best Practices for Stages, Dependencies, and Conditions

References

Watch Video

​Defining Stages and Dependencies in Azure Pipelines

​Using Conditions for Conditional Execution

​Example: Branch-Aware Multi-Stage Pipeline

​dependsOn vs condition: Side-by-Side Comparison

​Best Practices for Stages, Dependencies, and Conditions

​References

Watch Video

Defining Stages and Dependencies in Azure Pipelines

Using Conditions for Conditional Execution

Example: Branch-Aware Multi-Stage Pipeline

dependsOn vs condition: Side-by-Side Comparison

Best Practices for Stages, Dependencies, and Conditions

References