Skip to content

Microsoft DevOps Engineer Expert (AZ-400)

Exam Overview

The DevOps Engineer Expert certification validates skills to combine people, processes, and technologies to continuously deliver valuable products and services that meet end user needs and business objectives. DevOps engineers design and implement strategies for collaboration, code, infrastructure, source control, security, compliance, continuous integration, testing, delivery, monitoring, and feedback.

Exam Details: - Exam Code: AZ-400 - Duration: 180 minutes - Number of Questions: 40-60 questions - Passing Score: 700 out of 1000 - Question Types: Multiple choice, multiple select, drag and drop, hot area, case studies, labs - Cost: $165 USD - Prerequisites: AZ-104 (Administrator) OR AZ-204 (Developer) certification

Exam Domains

1. Configure Processes and Communications (10-15%)

  • Configure Activity Traceability and Flow of Work
  • Plan and implement a structure for the flow of work and feedback cycles
  • Identify appropriate metrics related to flow of work
  • Integrate pipelines with work item tracking tools

  • Implement traceability policies decided by development teams

  • Configure Collaboration and Communication

  • Communicate actionable feedback
  • Document and share plans
  • Automate communication with team members

2. Design and Implement Source Control (15-20%)

  • Design and Implement a Source Control Strategy
  • Design and implement an authentication strategy
  • Design a strategy for managing large files
  • Design a strategy for scaling and optimizing a Git repository

  • Implement workflow hooks

  • Plan and Implement Branching Strategies for the Source Code

  • Define Pull Requests (PR) guidelines to enforce work item correlation
  • Implement branch merging restrictions
  • Define branch strategy (GitFlow, GitHub flow, etc.)

  • Configure branch policies

  • Configure Repositories

  • Configure permissions in the source control repository
  • Organize the repository with git-flow branching model
  • Configure git hooks
  • Configure authentication for Git repositories

3. Design and Implement Build and Release Pipelines (40-45%)

  • Design a Build Strategy
  • Design and implement build triggers, tools, integrations, and workflow
  • Design build orchestration (products that are composed of multiple builds)
  • Design build infrastructure and communication with deployment groups
  • Design and implement a dependency versioning strategy

  • Design and implement a versioning strategy for build artifacts

  • Design and Implement a Release Strategy

  • Design and implement a release strategy (blue/green, canary, ring)
  • Design a release pipeline workflow
  • Implement appropriate deployment patterns
  • Implement blue/green deployments
  • Implement canary deployments

  • Implement progressive exposure deployments

  • Design and Implement a Deployment Strategy

  • Design a deployment strategy (blue/green, canary, ring, progressive exposure)
  • Design and implement a deployment workflow
  • Implement deployment gates and approval processes

  • Implement database deployments

  • Design and Implement Infrastructure as Code (IaC)

  • Design and implement IaC solutions using ARM templates, Terraform, or other tools
  • Design and implement environment strategy and configuration management technology

  • Configure agents and agent pools, and manage agent health

  • Manage Pipeline Configuration and Secrets

  • Configure pipeline triggers
  • Configure and manage secrets in build and release pipelines
  • Configure task and agent pools
  • Configure parallel and multi-agent builds

4. Design and Implement a Dependency Management Strategy (10-15%)

  • Design a Dependency Management Strategy
  • Recommend package management tools (GitHub Packages, Azure Artifacts, etc.)
  • Abstract common functionality into a package
  • Inspect and validate code quality and security of packages

  • Inspect package dependencies for security and license rating

  • Manage Security and Compliance

  • Inspect open source software packages for security and license compliance
  • Configure build policies and compliance
  • Configure Package management security

5. Design and Implement Application Infrastructure (15-20%)

  • Design and Implement Infrastructure as Code (IaC)
  • Design and implement infrastructure as code using ARM templates, Terraform, Ansible, Chef, or Puppet
  • Manage infrastructure state and configuration across environments

  • Provision and configure infrastructure

  • Design and Implement a Container Build Strategy

  • Design a container build strategy
  • Implement multi-stage container builds
  • Implement container build strategies that include different tooling, languages, and environments

6. Implement Continuous Integration (10-15%)

  • Design Build Automation
  • Integrate the build pipeline with external tools (Maven, Gradle, npm, Grunt, Gulp, etc.)
  • Implement quality gates (code coverage, internationalization, peer review)
  • Design a testing strategy (unit, integration, load, fuzz, API, UI)

  • Set up an automated build workflow

  • Design a Test Strategy and Implement Test Automation

  • Design a comprehensive test strategy
  • Implement unit testing, integration testing, and load testing
  • Implement automated security testing
  • Implement automated performance testing

7. Implement Continuous Delivery (10-15%)

  • Design a Release Strategy
  • Design a release strategy (blue/green, canary, ring)
  • Implement a release strategy

  • Select an appropriate deployment pattern

  • Set Up a Release Management Workflow

  • Automate inspection of health signals for release candidates
  • Configure automated integration and functional test execution
  • Create a release pipeline (Azure DevOps, Jenkins, etc.)
  • Configure and manage release gates and approval processes
  • Configure automated deployment control using deployment gates

8. Implement Dependency Management (5-10%)

  • Design a Dependency Management Strategy
  • Identify and recommend standardized package types and versions across the solution

  • Refactor existing build pipelines to implement version strategy that publishes packages

  • Manage Security and Compliance

  • Inspect and validate code quality and security of packages and their dependencies
  • Configure Package management security and license compliance

9. Implement Application Infrastructure (10-15%)

  • Design an Infrastructure Strategy
  • Design a compute infrastructure strategy
  • Design a storage infrastructure strategy
  • Design a networking infrastructure strategy

  • Design an Infrastructure as Code (IaC) strategy

  • Implement Infrastructure as Code (IaC)

  • Create, maintain, and run IaC

  • Manage IaC configuration state and secrets

  • Manage Azure Kubernetes Service Infrastructure

  • Provision Azure Kubernetes Service (AKS)
  • Create deployment file for publishing to AKS
  • Develop a scaling plan

10. Implement Continuous Feedback (10-15%)

  • Recommend and Design System Feedback Mechanisms
  • Design practices to measure end-user satisfaction and analyze user feedback
  • Design processes to capture and analyze application feedback
  • Design routing for client application crash report data
  • Recommend monitoring tools and technologies

  • Recommend system and feature usage tracking tools

  • Implement Process for Routing System Feedback to Development Teams

  • Configure crash report integration for client applications
  • Develop monitoring and status dashboards
  • Implement routing for client application crash report data
  • Implement tools to track system usage, feature usage, and flow
  • Integrate and configure ticketing systems with development team's work management system

Remember: AZ-400 requires either AZ-104 or AZ-204 as a prerequisite and focuses on end-to-end DevOps practices and Azure DevOps tools.