Microsoft AZ-400: Designing and Implementing DevOps Solutions in 2026

AZ-400 is an advanced DevOps exam, not a general introduction to Agile or cloud development. Microsoft expects candidates to design and implement the systems that move work from an idea to production: collaboration and traceability, source control, build and release pipelines, security and compliance, and instrumentation. The exam assumes you can connect people, process, Git, automation, Azure, GitHub, and Azure DevOps into one delivery system.

The English AZ-400 exam was updated on July 27, 2026 and currently has no listed retirement date. The weighting is unusually clear about where to focus: processes and communications 10–15%, source control 10–15%, build and release pipelines 50–55%, security and compliance 10–15%, and instrumentation 5–10%. More than half of the AZ-400 exam can therefore center on pipeline architecture and delivery behavior.

AZ-400 is also the required exam for the DevOps Engineer Expert certification, together with an eligible Azure associate prerequisite. The role expects experience with both GitHub and Azure DevOps solutions, so preparation should not treat either platform as an optional side topic.

Learn DevOps as a flow of work, not a list of tools

The first objective area covers processes and communications, but the point is not to memorize project-management terminology. You need to understand how work moves from requirement to code to deployment and how teams preserve traceability along the way.

Ask what evidence connects a business requirement to a commit, pull request, build, release, incident, and feedback item. Azure Boards, GitHub Issues, repositories, pull requests, dashboards, and notifications are useful because they make that flow visible. A strong design reduces handoffs that lose context and gives teams enough data to improve cycle time, lead time, recovery time, and quality.

DevOps engineering skills connect source control, delivery automation, infrastructure, observability, and reliability rather than treating them as separate certification chapters.

Traceability is especially important when something goes wrong. A production incident should be traceable back to the deployment, build, commit, pull request, and work item that introduced the change. If the delivery system cannot answer “what changed?” quickly, the team loses time during recovery and cannot reliably learn from failures.

Source control questions are really change-control questions

Git is the foundation of the delivery system because every downstream automation depends on controlled, reviewable change. AZ-400 candidates should be comfortable designing branching and repository strategies, managing large files, configuring permissions, recovering data, and applying branch policies or protection rules.

The right branching strategy depends on release cadence, team size, support obligations, and deployment model. A short-lived branch model can reduce merge complexity, while a product with multiple supported versions may need a different release structure. Avoid memorizing one branching strategy as universally correct.

Repository protections should enforce the quality boundary the organization needs: required reviews, status checks, restrictions on direct pushes, signed or trusted changes where appropriate, and clear ownership. The goal is to make the safest path the normal path without creating process that developers routinely bypass.

Also understand repository scale and recovery. Large binary assets, deeply fragmented repositories, accidental secret commits, or history that must be repaired can create operational problems that branch strategy alone does not solve. The exam can test whether you choose a control that addresses the actual repository problem rather than applying a generic policy.

Pipelines deserve most of your preparation time

Build and release pipelines account for 50–55% of the current blueprint. That means candidates need more than a conceptual definition of continuous integration and continuous delivery. You should be able to design triggers, stages, jobs, environments, artifacts, approvals, deployment strategies, package flows, variables, templates, and failure handling.

Start with the lifecycle described in CI/CD fundamentals: a change is committed, validated, built, tested, packaged, promoted through environments, deployed, observed, and either accepted or corrected. Every stage should have a purpose and an evidence signal.

For AZ-400, CI/CD pipeline architecture forces design decisions about stage boundaries, artifacts, approvals, environments, deployment methods, rollback, and reuse. Practice drawing a pipeline from source to production and explaining what would happen if each stage failed.

Do not design only the happy path. Decide what happens when a test fails, an artifact cannot be published, an approval expires, a deployment partially succeeds, a health check fails, or a rollback itself encounters an error. A reliable pipeline makes failure states observable and recoverable rather than leaving the team to reconstruct the deployment manually.

Know when GitHub Actions and Azure Pipelines change the design

Microsoft expects candidates to work with both GitHub and Azure DevOps. Do not study them as identical products with different syntax. The surrounding platform, identity model, repository location, environment controls, reusable components, package systems, approvals, and organization governance can affect the right design.

A useful lab is to implement the same simple application delivery in both systems. Trigger on a code change, build and test the application, publish an artifact or package, deploy to a protected environment, and require an approval or policy before production. Compare where secrets live, how identities authenticate to Azure, how reusable workflow or template logic is managed, and how evidence is surfaced.

GitHub Actions for Azure delivery exposes platform, identity, environment, reuse, and failure-mode differences that are hidden by workflow syntax alone.

Pay attention to reuse. A single pipeline can be easy to maintain; dozens of copied pipelines are not. Reusable workflows, templates, centralized policy, and shared components can reduce drift, but too much abstraction can make troubleshooting difficult. AZ-400 design questions often reward a balance between standardization and team autonomy.

Package management is part of pipeline architecture

AZ-400 includes package-management strategy because a reliable build should produce versioned, traceable dependencies and artifacts. Candidates should understand feeds, upstream sources, package views, semantic or date-based versioning where appropriate, and the difference between rebuilding from source versus promoting an immutable artifact.

A pipeline that downloads uncontrolled dependencies on every production deployment can be reproducible only in appearance. A stronger design knows which package was tested, where it came from, what version is approved, and how downstream stages consume the same artifact.

Think about failure and rollback as well. If a deployment fails, can the system identify and redeploy the last known-good artifact? If a dependency is compromised, can you determine which builds consumed it? Those questions turn package management from a storage topic into a supply-chain and recovery concern.

Security belongs inside the delivery lifecycle

The security and compliance domain is 10–15%, but security choices appear throughout source control and pipelines. Secrets, credentials, dependency risk, code scanning, infrastructure scanning, approvals, permissions, and environment protection all influence delivery safety.

Do not bolt security onto the final stage. A better model moves controls to the point where they can give the fastest useful feedback without losing required governance. Source and dependency scanning may run early. Deployment identities should use least privilege. Production environments may require additional approvals or evidence. Audit data should make high-risk changes traceable.

DevSecOps fundamentals places controls at the stage where they can reduce risk without unnecessarily slowing delivery. The exam may present several technically valid controls; the strongest answer often fits the risk at the correct stage rather than adding a generic security tool everywhere.

Credential design is especially important. Prefer short-lived or federated identity approaches where the platform supports them instead of distributing long-lived secrets to every pipeline. Separate build permissions from deployment permissions, and separate nonproduction access from production access. If one compromised credential can modify source, publish packages, and deploy everywhere, the pipeline has a dangerous blast radius.

Infrastructure and environment changes need the same discipline as code

Modern DevOps pipelines often deploy infrastructure, configuration, application code, and policy together. The design should preserve repeatability, review, environment separation, and recovery across all of them.

Infrastructure as code should be versioned and tested. Environment-specific values should be separated from reusable definitions. Deployment identities should have only the permissions needed for the target environment. Destructive changes deserve stronger review than routine updates. State and dependency behavior must be understood so that repeated pipeline runs remain predictable.

When a question describes drift between environments, manual production fixes, or configuration known only to one administrator, look for a design that moves the source of truth back into versioned automation.

Instrumentation closes the feedback loop

Instrumentation is the smallest objective area at 5–10%, but it is what tells the delivery system whether a release actually improved the service. Monitoring, logs, traces, dashboards, alerts, and business or reliability metrics create the evidence used for feedback and recovery.

Do not limit instrumentation to infrastructure health. A deployment can be technically successful while increasing error rates, latency, support incidents, or failed business transactions. A mature pipeline uses post-deployment evidence to decide whether to continue, roll back, or investigate.

Metrics such as lead time, deployment frequency, change failure rate, and time to recovery can expose bottlenecks in the delivery process. AZ-400 connects engineering automation to organizational outcomes; instrumentation is how the team learns whether the process is working.

Make observability part of release design. If a new version introduces a regression, the team should be able to correlate the change with telemetry quickly. Deployment markers, environment metadata, dashboards, and alerting thresholds can shorten that feedback loop and make automated or manual rollback decisions more reliable.

Prepare by designing complete delivery systems

Because pipelines dominate the blueprint, build preparation around complete scenarios. Start with a repository and work item, add branch protection, create a build and test path, publish a versioned artifact, deploy through environments, add security checks, protect production, and instrument the result. Then change one requirement.

What happens if the organization adopts GitHub instead of Azure Repos? If production requires manual approval? If deployments must be zero-downtime? If secrets can no longer be stored as static credentials? If a failed release must roll back automatically? If three teams need the same pipeline pattern?

Those changes reveal whether you understand the architecture. AZ-400 is difficult when candidates memorize YAML fragments or product screens without understanding delivery behavior. It becomes much more manageable when every tool is tied to traceability, source control, reproducibility, security, reliable deployment, and measurable feedback.

  • img