Microsoft AZ-400: Designing and Implementing DevOps Delivery Systems

Microsoft AZ-400, Designing and Implementing Microsoft DevOps Solutions, remains the current advanced exam for the Microsoft DevOps engineering path. Microsoft updated the English blueprint on July 27, 2026. The exam is less about knowing individual Azure DevOps or GitHub screens than about designing a delivery system that moves work from idea to production with reliable source control, automation, security, observability, and feedback.

The Microsoft DevOps Engineer Expert credential reflects that cross-functional role. Microsoft currently describes the DevOps engineer as someone who works across development, administration, site reliability, and security to improve the continuous delivery of value. Candidates should therefore be able to explain why a workflow is designed a certain way, not merely reproduce a pipeline from a tutorial.

The credential page still lists Azure Administrator Associate or Azure Developer Associate as prerequisite certifications. The administrator route remains available through AZ-104, while the AZ-204 exam retired on July 31, 2026. Candidates who do not already hold the developer credential should verify the live prerequisite rules before planning their certification sequence, because the retirement creates a practical difference between an existing credential and a newly available exam path.

DevOps starts with the flow of work, not with a pipeline file

A team can have sophisticated automation and still deliver slowly if work enters the system in large batches, ownership is unclear, handoffs create queues, or production feedback never reaches planning. AZ-400 therefore expects candidates to think about processes and communications as part of the delivery architecture. Boards, work items, pull requests, documentation, notifications, and metrics should reinforce a shared operating model rather than become disconnected tools.

The broad software delivery and DevOps lifecycle context is useful when testing these relationships. Take a fictional feature from request to production and mark every approval, queue, automated check, artifact, deployment, and feedback signal. If a step exists only because “that is how the team has always done it,” ask whether it protects quality or merely adds delay.

Source control strategy should make change reviewable and recoverable

Git expertise for AZ-400 goes beyond clone, commit, and push. Candidates should understand repository structure, branch policies, pull-request protection, merge approaches, code ownership, large-file considerations, release tagging, and how teams isolate or integrate work. The correct strategy depends on release frequency, team size, regulatory needs, component boundaries, and the cost of keeping long-lived branches synchronized.

Practice by comparing trunk-based development with a heavier release-branch model for the same product. Define what happens when an urgent production fix appears while several features are in flight. Then decide which controls belong in the repository and which belong in the pipeline. A source-control design is strong when it reduces ambiguity about what changed, who reviewed it, what version was released, and how a previous state can be reconstructed.

Continuous integration should produce trustworthy evidence, not merely green builds

A CI pipeline normally compiles or packages code, runs automated tests, performs static or dependency analysis, and publishes an artifact. The deeper question is whether the pipeline gives the team evidence that a change is safe to move forward. A five-minute build that skips meaningful tests may be less valuable than a slightly slower workflow that catches integration, policy, or security failures before they reach a shared environment.

The DevOps engineering skill map is a useful way to connect CI with the rest of the system. Define fast checks that run on every pull request, deeper tests that run after merge, and expensive validation that runs before release. Decide how failed tests block progression and how flaky tests are handled so teams do not learn to ignore red pipelines.

GitHub Actions and Azure Pipelines solve similar problems with different operating models

Microsoft expects familiarity with both GitHub and Azure DevOps. Candidates should understand workflow triggers, reusable templates, environments, agents or runners, secrets, approvals, artifacts, variables, and service connections. The goal is not to declare one platform universally better. It is to recognize how repository location, enterprise controls, existing tooling, team experience, and integration requirements influence the choice.

When using GitHub Actions, study the security and lifecycle implications of third-party actions, pinned versions, permissions, reusable workflows, and environment protection. Then build the same simple CI/CD flow in Azure Pipelines. Comparing the two implementations forces you to separate the delivery concept from the product syntax, which is valuable in scenario questions.

Release design is about controlling risk while preserving delivery speed

Deployment is not complete when a package reaches a server. A release strategy should define environments, approvals, deployment waves, health checks, rollback or roll-forward behavior, configuration changes, database compatibility, and how traffic is shifted. Blue/green, canary, ring-based, feature-flag, and rolling approaches solve different risk problems and impose different operational costs.

For practice, take an API with a stateful database dependency and design a release that permits rollback without losing data. Add a requirement that only ten percent of users receive the new version initially. Then add a compliance requirement for an explicit production approval. The exercise becomes useful when you can show which control reduces which failure mode rather than treating every gate as universally necessary.

Infrastructure as code turns environments into reviewable change

Infrastructure as code allows networks, compute, identity assignments, platform services, and policy to be versioned and changed through the same disciplined process as application code. Candidates should understand declarative versus imperative approaches, state, modules, environments, parameterization, secret handling, drift, and how deployment failures are detected. Bicep, ARM templates, Terraform, and configuration technologies differ, but the operational principles are transferable.

A good lab provisions an application environment from an empty subscription or resource group, changes one component through code, and then repeats the deployment to confirm idempotent behavior. Add a manual portal change and observe how the chosen tooling detects or reconciles drift. The objective is not to memorize syntax; it is to understand how infrastructure change becomes reviewable, testable, and repeatable.

Container images can make build and runtime environments more predictable, but teams still need to manage base images, registries, vulnerability scanning, configuration, secrets, orchestration, health probes, and rollout behavior. The containerization model becomes especially relevant when a pipeline promotes the same immutable image across environments while environment-specific settings remain external.

Build a small container pipeline that tags images with an immutable identifier, scans them, pushes them to a registry, and deploys by digest or precise tag. Then model what happens if a base image vulnerability appears after release. A mature delivery process can identify affected artifacts and rebuild or redeploy them without guessing which source commit produced which image.

Security and compliance controls belong inside the delivery path

DevSecOps is not a final security scan added before production. Credentials should use least privilege, secrets should be kept out of source, pipeline identities should be bounded, dependencies should be assessed, protected environments should enforce policy, and evidence should be generated automatically where possible. Federated identity and short-lived credentials can reduce the risk of long-lived secrets in CI/CD systems.

Threat-model a pipeline itself: source repository compromise, malicious dependency, tampered build agent, leaked token, unreviewed infrastructure change, or artifact substitution. For each threat, identify a preventative or detective control. This turns security into a delivery-system design problem and helps explain why repository policy, artifact integrity, environment permissions, and audit trails are connected.

Instrumentation closes the loop between deployment and product behavior

A pipeline can report success while the released application is failing for users. AZ-400 therefore includes instrumentation strategy: logs, metrics, traces, alerts, dashboards, application performance data, and feedback from production. Teams should decide what healthy behavior looks like before deployment, then use that definition to evaluate releases and prioritize engineering work.

Choose a service and define a small set of service-level indicators for availability, latency, errors, and saturation. Add business signals such as completed transactions or failed checkouts. Then decide which deployment metrics—change failure rate, lead time, recovery time, deployment frequency—help explain how the engineering system is performing. Observability is valuable when it changes decisions, not when it simply creates more dashboards.

Current preparation should connect legacy development skills to a broader delivery role

Candidates arriving from the retired developer route can use the Azure development-to-DevOps transition to identify what changes at AZ-400 level. Application development knowledge remains useful, but the scope expands to repositories, environments, release governance, shared platforms, telemetry, and organizational flow. An administrator entering through AZ-104 brings operational strength but still needs equivalent depth in development workflows and application delivery.

Finish with a capstone rather than isolated labs. Put application and infrastructure code in source control, enforce pull-request checks, build and scan an artifact, deploy it through at least two environments, protect production, collect telemetry, and rehearse a failed release. Document every design choice and its tradeoff. If you can explain how the system preserves speed, traceability, security, recoverability, and feedback at the same time, you are studying the role AZ-400 is designed to measure.

Software-supply-chain integrity deserves a separate practice pass because pipelines increasingly consume external packages, actions, containers, and build tools. Record where dependencies enter the build, how versions are pinned, where artifacts are stored, and how a release can be traced back to source and build evidence. Add a scenario in which a dependency is compromised after an artifact has already been promoted. The response should identify affected builds without rebuilding history from memory. Provenance, immutable artifacts, protected registries, and dependency review turn the delivery chain itself into something the team can audit.

Also evaluate developer experience as an operational constraint. A secure process that takes hours to give basic feedback will encourage workarounds, while an extremely fast process with weak controls simply moves defects faster. Measure pull-request feedback time, queue time, build duration, and deployment delay separately. Then decide which checks must be immediate and which can run later without weakening safety. This makes pipeline optimization a systems problem: the aim is not the fewest steps, but a flow in which useful evidence arrives early enough to influence the developer before context is lost.