Study guide

6.1 Selecting a CI/CD Solution: Azure Pipelines vs. GitHub Actions

Microsoft Certified: Azure DevOps Engineer Expert AZ-400

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Flow of Work, Traceability & Work Tracking

1.1 Flow of Work, GitHub Flow & Feedback Cycles 1.2 Work Tracking with Azure Boards & GitHub Projects 1.3 End-to-End DevOps Traceability & Quality Tracking

2 Chapter 2: DevOps Metrics, Dashboards & Team Collaboration

2.1 DORA Metrics, Flow Metrics & Dashboard Design 2.2 Lifecycle Metrics Across the Six DevOps Phases 2.3 Work Item Queries, WIQL Charts & Analytics 2.4 Project Documentation: Wikis, Mermaid Diagrams & Release Notes 2.5 Webhooks, Service Hooks & Microsoft Teams ChatOps

3 Chapter 3: Git Branching Strategies & Pull Request Workflows

3.1 Git Branching Models & Strategy Design 3.2 Pull Request Workflows & Merge Strategies 3.3 Branch Policies, Quality Gates & Compliance Restrictions

4 Chapter 4: Repository Management, Optimization & Git Data Operations

4.1 Git LFS Architecture & .gitattributes Tracking 4.2 LFS History Migration, git-fat & File Locking 4.3 Git Repository Scaling, Scalar & Monorepo Governance 4.4 Repository Permissions & Git Tag Governance 4.5 Git Data Recovery & Sensitive-Data Scrubbing

5 Chapter 5: Package Management & Dependency Versioning

5.1 Selecting Package Tools: Azure Artifacts vs. GitHub Packages 5.2 Feed Scoping, Upstream Sources & Pipeline Authentication 5.3 Package Views, Immutability & Quality Promotion 5.4 Dependency Versioning: SemVer, CalVer & Automated Versioning 5.5 Pipeline Artifact Versioning & Artifact Storage Strategy

6 Chapter 6: Pipeline Infrastructure, Agents & Integration

6.1 Selecting a CI/CD Solution: Azure Pipelines vs. GitHub Actions 6.2 GitHub-Azure Pipelines Integration & Hybrid Migration 6.3 Hosted vs. Self-Hosted Agents & Runners 6.4 VMSS Elastic Pools, Container Jobs & Agent Governance 6.5 Pipeline Triggers, Filters & Concurrency Management

7 Chapter 7: YAML Pipeline Architecture & Reusable Elements

7.1 YAML Pipeline Anatomy: Stages, Jobs, Steps & Workspaces 7.2 Job Execution Order: DAG Dependencies, Parallelism & Conditions 7.3 Reusable Elements: Templates, Parameters & Variables 7.4 Variable Groups, Secret Variables & Key Vault Linking 7.5 YAML Environments, Checks & Deployment Approvals

8 Chapter 8: Testing Strategy, Quality Gates & Code Coverage

8.1 Test Strategy Design: Local, Unit & Integration Testing 8.2 Load, Stress & Performance Testing in Pipelines 8.3 Test Execution Tasks, Agents & Results Integration 8.4 Code Coverage Analysis & SonarQube Integration 8.5 Quality Gates, Release Gates & Governance Checks

9 Chapter 9: Modern Deployment Strategies & Zero-Downtime Delivery

9.1 Progressive Delivery: Blue-Green, Canary & Ring Deployments 9.2 Minimizing Downtime: Deployment Slots & Rolling Updates 9.3 Feature Flags with Azure App Configuration & Feature Manager 9.4 Designing the High-Priority Hotfix Path 9.5 Ordered Dependency Deployments, Resiliency & Rollback

10 Chapter 10: Artifact Deployment & Database DevOps

10.1 Containerized Application Delivery: ACR, AKS & Container Apps 10.2 Binary, Web App, Function & Scripted Deployments 10.3 Database DevOps: State-Based & Migration-Based Strategies

11 Chapter 11: Infrastructure as Code (IaC) & Azure Deployment Environments

11.1 Infrastructure as Code Strategy: Bicep, ARM & Terraform 11.2 Desired State Configuration & Azure Machine Configuration 11.3 Azure Deployment Environments (ADE) & Developer Self-Service

12 Chapter 12: Pipeline Maintenance, Health & Modernization

12.1 Pipeline Health, Flaky Tests & Reliability Engineering 12.2 Pipeline Optimization: Caching, Slicing & Concurrency 12.3 Artifact & Build Retention Governance 12.4 Modernizing CI/CD: Classic to YAML Migration

13 Chapter 13: Authentication, Authorization & Identity Governance

13.1 Microsoft Entra Service Principals & Managed Identities 13.2 Service Connections, Workload Identity & Personal Access Tokens 13.3 Azure DevOps Projects, Teams & Permission Evaluation 13.4 Access Levels, GitHub Roles & Outside Collaborators

14 Chapter 14: Secrets Management, Sensitive Data & DevSecOps Scanning

14.1 Azure Key Vault, Secret Variables & Secretless CI/CD 14.2 Security Scanning Strategy, GHAS & Secret Scanning 14.3 CodeQL SAST in Pipelines and Containers 14.4 Software Supply Chain, Container Scanning & Cloud Defender

15 Chapter 15: Telemetry Collection, Azure Monitor & Alerting

15.1 Azure Monitor Architecture, AMA & Data Collection Rules 15.2 Application Insights & Specialized Azure Monitor Insights 15.3 Alerting Rules, Action Groups & GitHub Repository Insights

16 Chapter 16: Telemetry Analysis, Distributed Tracing & SRE Practices

16.1 Distributed Tracing, Application Map & Exception Triage 16.2 KQL Log Analytics, SRE Observability & Error Budgets

6.1 Selecting a CI/CD Solution: Azure Pipelines vs. GitHub Actions

Key Takeaways Explain This Topic AI

Azure Pipelines is the only option that natively builds Team Foundation Version Control repositories and Azure Repos branch policies.

Azure Pipelines offers deeper release governance: multi-stage environment checks, exclusive locks, invoke-REST-API gates and business hours windows.

GitHub Actions keeps workflow, source and permissions in one product and uses repository or organisation secrets rather than a separate variable group plane.

Azure Pipelines evaluates ${{ }} template expressions at compile time and $() macros at runtime, while GitHub Actions uses ${{ }} for both with context-dependent evaluation.

Both products can deploy to Azure without a stored secret by using OpenID Connect workload identity federation.

Last updated: September 2026

6.1 Selecting a CI/CD Solution: Azure Pipelines vs. GitHub Actions

Modern DevOps engineering in the Microsoft ecosystem revolves around two premier Continuous Integration and Continuous Delivery (CI/CD) orchestration engines: Azure Pipelines (part of Azure DevOps) and GitHub Actions . While both platforms execute code compilation, automated testing, and cloud infrastructure deployment on underlying Azure virtual machine infrastructure, their architectural philosophies, workflow schemas, governance capabilities, and ecosystem integrations diverge significantly.

For the AZ-400 exam, candidates must master the architectural differences, evaluate organizational requirements using a structured decision framework, design hybrid CI/CD pipelines bridging both platforms, and plan migrations between Azure Pipelines and GitHub Actions.

1. Architectural Comparison: Azure Pipelines vs. GitHub Actions

Understanding the structural and runtime mechanics of both platforms is essential for designing resilient delivery systems.

YAML Schema and Execution Hierarchy

Both platforms utilize YAML for pipeline-as-code definitions, but their hierarchical models differ in scope and terminology:

Azure Pipelines Hierarchy : Structured into Stages → Jobs → Steps (Tasks/Scripts).

Stages represent major milestones or environment boundaries (e.g., Build , QA , Production ). Stages can run sequentially or in parallel based on dependsOn declarations.

Jobs execute on a single agent within an agent pool. Jobs can run concurrently or conditionally.

Steps are the linear execution units within a job (e.g., script , powershell , task ).

Syntax example: trigger:

- main

stages:

  • stage: BuildStage
  • displayName: 'Build and Package'

jobs:

- job: CompileJob

pool:

vmImage: 'ubuntu-latest'

steps:

- task: DotNetCoreCLI@2

inputs:

  • command: 'build'
  • stage: DeployProd
  • dependsOn: BuildStage

jobs:

  • deployment: DeployWeb
  • environment: 'Production'

strategy:

runOnce:

deploy:

steps:

- script: echo "Deploying to production..."

GitHub Actions Hierarchy : Structured into Workflows → Jobs → Steps (Actions/Scripts).

A Workflow is triggered by repository events (e.g., push , pull_request , schedule ).

Jobs execute on separate runners by default and run in parallel unless chained via needs: [job_id] .

GitHub Actions does not have an explicit "Stage" construct; instead, multi-stage delivery is modeled using job dependencies and job-level Environments ( environment: production ).

Syntax example: name: CI/CD Pipeline

on:

push:

branches: [ main ]

jobs:

build:

runs-on: ubuntu-latest

steps:

  • uses: actions/checkout@v4
  • name: Setup .NET
  • uses: actions/setup-dotnet@v4

with:

  • dotnet-version: '8.0.x'
  • run: dotnet build

deploy:

  • needs: build
  • runs-on: ubuntu-latest
  • environment: Production

steps:

  • run: echo "Deploying to production..."
  • Variable Expansion and Context Evaluation

Variable expansion mechanisms represent a frequent source of pipeline misconfiguration:

Azure Pipelines :

$(variableName) : Macro syntax . Expanded at runtime before a step runs. Values are treated as plain text strings or secrets.

$[variables.variableName] : Runtime expression syntax . Evaluated at runtime; commonly used in job and stage condition statements (e.g., condition: eq(variables['Build.SourceBranch'], 'refs/heads/main') ).

${{ parameters.paramName }} : Template expression syntax . Evaluated at pipeline compilation/parse time before the pipeline structure is finalized.

GitHub Actions :

${{ <expression> }} : Uniform expression syntax evaluated against workflow context objects (e.g., ${{ github.ref }} , ${{ env.TARGET_ENV }} , ${{ secrets.AZURE_CLIENT_ID }} ).

Environment variables inside runner steps: Accessed via standard shell syntax (e.g., $MY_VAR in Bash or $env:MY_VAR in PowerShell).

Marketplace and Extensibility Ecosystem

Azure DevOps Marketplace : Extensions deliver pre-packaged tasks ( task: TaskName@Version ) installed at the Organization level. Tasks are authored in TypeScript/Node.js or PowerShell and packaged with a strict task.json manifest. Enterprise governance allows organization administrators to restrict extension installations to approved publishers.

GitHub Marketplace : Hosts over 20,000 community and certified actions. Actions ( uses: owner/repo@vX ) are categorized into JavaScript Actions , Docker Container Actions , and Composite Actions . Actions are referenced directly by Git commit SHA, branch, or release tag, promoting rapid inner-sourcing and community contribution.

Release Management and Governance Capabilities

Release governance represents one of the sharpest contrasts between the two platforms:

Azure Pipelines Governance :

Supports both Classic Release Pipelines (visual canvas) and YAML Multi-Stage Pipelines .

Environments and Resource Checks : Environments in YAML link to physical or virtual deployment targets (Kubernetes clusters, Virtual Machines). Administrators configure granular Checks & Approvals that pause pipeline execution without consuming agent compute:

Manual Approvals : Designated users or security groups must approve progression.

Business Hours : Restricts deployment windows to specific timeframes.

Invoke REST API : Polls external Change Advisory Board (CAB) systems (e.g., ServiceNow) to verify approved change tickets.

Invoke Azure Function : Executes serverless validation logic.

Azure Monitor Alerts : Verifies that active alert rules are healthy before proceeding.

Branch Control : Ensures only code from protected release branches can target production.

Exclusive Lock : Enforces single-pipeline execution against a critical environment to prevent deployment races.

GitHub Actions Governance :

Governed through Environments configured in repository or organization settings.

Protection Rules include:

Required Reviewers : Up to 6 users or teams must approve.

Wait Timer : Introduces a delay (up to 30 days) before deploying.

Deployment Branches and Tags : Restricts deployments to specific branch name patterns or git tags.

Environment secrets and variables provide isolated credentials accessible only when the environment's protection rules are satisfied.

2. Decision Framework: Azure Pipelines vs. GitHub Actions

The AZ-400 exam requires candidates to evaluate business and technical constraints to recommend the correct CI/CD engine. [Organization Architecture Evaluation]

  • │
  • ┌──────────────────────────────┴──────────────────────────────┐
  • ▼ ▼
  • [Select Azure Pipelines] [Select GitHub Actions]
  • Deep enterprise Change Advisory Board gates • GitHub-native repositories and pull requests
  • Native Azure Boards & Test Plans integration • GitHub Marketplace ecosystem (20,000+ actions)
  • Legacy VCS requirements (TFVC, Subversion) • Developer-first microservices & open-source
  • Centralized repository resource governance • Co-located security scanning (Dependabot/CodeQL)
  • Complex manual approval and automated REST checks • Native Codespaces & GitHub Packages integration
  • When to Choose Azure Pipelines

Formal Enterprise Governance & CAB Integration : When deployments require automated Change Management ticket verification (e.g., ServiceNow integration via REST checks) and multi-team approval gates.

Unified Azure DevOps Suite Usage : When the organization relies on Azure Boards for portfolio and sprint tracking, Azure Test Plans for manual and automated test suite reporting, and Azure Artifacts for package management. Azure Pipelines provides native, out-of-the-box bi-directional traceability across all these services.

Legacy Version Control Systems : When enterprise repositories are hosted on Team Foundation Version Control (TFVC) or external Subversion (SVN) repositories. GitHub Actions operates exclusively on Git.

Complex Multi-Repository Resource Modeling : Azure Pipelines supports the resources: repositories: declaration, allowing a single pipeline to orchestrate, trigger from, and pull artifacts across multiple distinct repositories.

When to Choose GitHub Actions

Developer-Centric GitHub Workflows : When source code resides in GitHub and the team wants a frictionless, co-located workflow where CI/CD runs natively in the pull request interface.

Broad Community Action Ecosystem : When pipelines benefit from open-source actions for cloud providers, linters, and deployment targets without authoring custom task extensions.

Tight Integration with GitHub Security Products : Native synergy with Dependabot pull requests, Secret Scanning , and GitHub Advanced Security (GHAS) CodeQL analysis.

Inner-Source and Modular Engineering : Reusable workflows ( workflow_call ) and composite actions enable cross-organization sharing within GitHub Enterprise organizations.

3. Comprehensive Feature Comparison Matrix

  • Capability / Architectural Dimension Azure Pipelines GitHub Actions
  • Primary Workflow Hierarchy Stages → Jobs → Steps Workflows → Jobs → Steps

Version Control Support Azure Repos Git, GitHub, Bitbucket, Subversion, TFVC Git only (GitHub, GitHub Enterprise)

Execution Runners/Agents Microsoft-hosted, Self-hosted, Azure VMSS pools GitHub-hosted, Self-hosted, Runner scale sets (Actions Runner Controller - ARC)

Extensibility Model Azure DevOps Marketplace Tasks (Node.js, PowerShell) GitHub Marketplace Actions (JavaScript, Docker, Composite)

Deployment Approvals Manual approvals, Business hours, Branch control, Exclusive lock Required reviewers, Wait timers, Deployment branches

Automated Release Gates Invoke REST API, Invoke Azure Function, Azure Monitor Alerts Third-party GitHub Apps or custom workflow status checks

Secrets Management Secret Variables, Variable Groups, Azure Key Vault integration Repository Secrets, Environment Secrets, Organization Secrets

Work Tracking Traceability Native bi-directional linking to Azure Boards work items Links to GitHub Issues and GitHub Projects via syntax

Test Management Native test result publishing, flakiness tracking, Azure Test Plans Test reporter actions, workflow summary markdown

Container Job Execution Native container: and services: blocks on Linux agents Native container: and services: blocks on Linux runners