AWS DVA · Domain 3 of 4

AWS DVA Domain 3: Deployment

This domain covers packaging and shipping applications on AWS: preparing artifacts, testing in development, automating deployment testing, and deploying with the AWS CI/CD services and deployment strategies.

Exam format
24%
Official tasks
4
Assessment estimate
~12
Suggested study time estimate
20–25 hrs

About 9 min read Reviewed October 2026

Overview

Deployment covers getting application code from a developer's machine into production safely. It has four tasks. Preparing artifacts covers packaging code and defining infrastructure with the Serverless Application Model (SAM), CloudFormation and the CDK, and managing dependencies. Testing in development covers running tests against development environments and mocking AWS services. Automating deployment testing covers integrating tests into pipelines. Deploying with CI/CD covers CodePipeline, CodeBuild, CodeDeploy and CodeArtifact, Lambda versions and aliases, and deployment strategies such as all-at-once, rolling, blue/green and canary.

At 24%, deployment is where many developers are soft because they write code more than ship it. The exam rewards knowing the CI/CD services and their roles, how SAM packages serverless apps, how Lambda aliases and versions enable safe rollouts, and which deployment strategy limits risk for a given need.

How it's tested

DVA-C02 questions describe a packaging, testing or release need and ask which CI/CD service, SAM feature or deployment strategy fits. This domain rewards knowing each tool's role and choosing the strategy that limits deployment risk. Read the release requirement before choosing.

  • Right CI/CD service

    A pipeline stage is described, and you choose CodeBuild, CodeDeploy, CodePipeline or CodeArtifact.

  • Package the app

    A serverless packaging need is described, and you choose SAM, CloudFormation or the CDK.

  • Safe release strategy

    A risk-sensitive release is described, and you choose blue/green, canary or another strategy.

Reasoning it through

A team must release a new Lambda version but limit exposure if it misbehaves. An all-at-once deployment sends all traffic to the new version immediately, maximizing risk. A canary deployment using a Lambda alias shifts a small percentage of traffic first, monitors it, then shifts the rest, so a bad version affects few users and can be rolled back. That controlled shift is what the exam expects for risk-sensitive releases.

Tasks 4

Official tasks from the Amazon Web Services outline, in outline order.

3.1 Prepare application artifacts to be deployed to AWSSAM, CloudFormation, the CDK, and dependency management.
What it means
This covers packaging application code and dependencies, defining infrastructure as code with the Serverless Application Model (SAM), CloudFormation and the CDK, managing dependencies and container images, and preparing artifacts for deployment.
What to understand
SAM is a simplified CloudFormation syntax for serverless applications that transforms into CloudFormation. Artifacts must bundle code and dependencies correctly, for example as Lambda packages or container images in ECR. Infrastructure as code makes deployments repeatable.
How it shows up
A packaging or infrastructure-definition need is described, and you must choose SAM, CloudFormation, the CDK or the right artifact format.
Common confusion
Confusing SAM with plain CloudFormation; SAM is a serverless-focused shorthand that transforms into CloudFormation.
3.2 Test applications in development environmentsTesting against development, mocking and local testing.
What it means
This covers testing applications in development environments, running unit and integration tests, mocking or emulating AWS services locally, using SAM local testing, and validating behavior before deployment.
What to understand
Developers test against development environments and can emulate some AWS services locally, for example with SAM, to validate before deploying. Separating development from production environments prevents test activity from affecting live systems.
How it shows up
A testing need is described, and you must choose the local or development-environment testing approach.
Common confusion
Testing against production instead of a dedicated development environment.
3.3 Automate deployment testingIntegrating tests into the pipeline.
What it means
This covers automating tests within a deployment pipeline, running tests as a pipeline stage in CodeBuild, gating deployment on test results, and automating validation so only passing builds proceed.
What to understand
Automated tests run in the pipeline, typically in a CodeBuild stage, so a failing test stops the deployment. This catches regressions before release without manual intervention, which is central to safe continuous delivery.
How it shows up
A test-automation need in a pipeline is described, and you must choose where and how to run tests.
Common confusion
Running tests manually outside the pipeline instead of gating the pipeline on automated tests.
3.4 Deploy code by using AWS CI/CD servicesCodePipeline, CodeBuild, CodeDeploy, versions and aliases, and deployment strategies.
What it means
This covers CodePipeline for orchestrating pipelines, CodeBuild for building and testing, CodeDeploy for deploying, CodeArtifact for packages, Lambda versions and aliases, CodeDeploy lifecycle hooks and the AppSpec file, and deployment strategies such as all-at-once, rolling, blue/green and canary.
What to understand
CodePipeline orchestrates stages, CodeBuild builds and tests, and CodeDeploy performs the deployment. Lambda aliases point to versions, enabling traffic shifting for canary and blue/green. Deployment strategies trade speed against risk: all-at-once is fastest and riskiest, canary and blue/green limit blast radius. Lifecycle hooks run tasks at deployment stages.
How it shows up
A release need is described, and you must choose the CI/CD service, the alias strategy or the deployment approach.
Common confusion
Confusing CodeBuild with CodeDeploy; CodeBuild builds and tests, while CodeDeploy deploys the built artifact.

High-yield concepts

The terms, rules and formulas this domain turns into questions most often.

  • AWS SAM

    Serverless shorthand that transforms into CloudFormation.

    Remember
    It simplifies serverless infrastructure as code.
    Tested as
    Packaging questions.
    Trap
    Confusing it with plain CloudFormation.

  • CodePipeline

    Orchestrates CI/CD pipeline stages.

    Remember
    It ties build, test and deploy together.
    Tested as
    Pipeline questions.
    Trap
    Confusing it with CodeBuild or CodeDeploy.

  • CodeBuild

    Builds and tests code in the pipeline.

    Remember
    It compiles, packages and runs tests.
    Tested as
    Build questions.
    Trap
    Confusing it with CodeDeploy.

  • CodeDeploy

    Deploys artifacts using strategies and hooks.

    Remember
    It performs the actual deployment.
    Tested as
    Deployment questions.
    Trap
    Confusing it with CodeBuild.

  • CodeArtifact

    Stores and shares software packages.

    Remember
    It is a package repository.
    Tested as
    Dependency questions.
    Trap
    Confusing it with CodeBuild output.

  • Lambda versions and aliases

    Immutable versions and movable aliases that point to them.

    Remember
    Aliases enable traffic shifting.
    Tested as
    Release questions.
    Trap
    Deploying without versioning for rollback.

  • All-at-once deployment

    Shifts all traffic to the new version immediately.

    Remember
    Fastest but highest risk.
    Tested as
    Strategy questions.
    Trap
    Using it for risk-sensitive releases.

  • Blue/green deployment

    Runs new and old environments and switches traffic.

    Remember
    Enables fast rollback.
    Tested as
    Strategy questions.
    Trap
    Confusing it with canary.

  • Canary deployment

    Shifts a small percentage of traffic first, then the rest.

    Remember
    Limits blast radius of a bad release.
    Tested as
    Strategy questions.
    Trap
    Confusing it with all-at-once.

  • CodeDeploy AppSpec and hooks

    Defines deployment steps and lifecycle event hooks.

    Remember
    Hooks run tasks before or after traffic shifts.
    Tested as
    Deployment questions.
    Trap
    Overlooking lifecycle hooks.

Side by side

Concepts candidates mix up, compared on the point that decides the answer.

CodeBuild vs. CodeDeploy vs. CodePipeline

ConceptMeaningKey differenceCommon trap
CodeBuild Builds and tests code Produces artifacts Confusing it with CodeDeploy
CodeDeploy Deploys the artifact Applies the deployment strategy Confusing it with CodeBuild
CodePipeline Orchestrates the stages Ties the pipeline together Treating it as a build tool

All-at-once vs. blue/green vs. canary

ConceptMeaningKey differenceCommon trap
All-at-once All traffic to new version now Fastest, highest risk Using it for risky releases
Blue/green Switch between full environments Fast rollback Confusing it with canary
Canary Shift a small percentage first Limits blast radius Confusing it with all-at-once

SAM vs. CloudFormation vs. CDK

ConceptMeaningKey differenceCommon trap
SAM Serverless shorthand Transforms into CloudFormation Treating it as separate
CloudFormation General infrastructure as code Full resource coverage Writing verbose serverless by hand
CDK IaC in a programming language Synthesizes to CloudFormation Treating it as separate from CloudFormation

Exam traps

Each trap is an answer that looks right. Learn the clue that should change your mind.

  1. All-at-once for risky release

    What candidates pick
    Deploy a new, unproven Lambda version to all traffic at once.
    Why it looks right
    It is the fastest release.
    Why it's wrong
    A canary or blue/green deployment limits exposure and enables rollback for risky releases.

    Clue to watch for The release must limit impact if the new version fails.

  2. CodeBuild deploys

    What candidates pick
    Use CodeBuild to deploy the application to production.
    Why it looks right
    It is part of the pipeline.
    Why it's wrong
    CodeBuild builds and tests; CodeDeploy performs the deployment.

    Clue to watch for The stage described is deploying, not building.

  3. SAM is separate

    What candidates pick
    Treat SAM as unrelated to CloudFormation.
    Why it looks right
    It has its own syntax.
    Why it's wrong
    SAM is a serverless shorthand that transforms into CloudFormation under the hood.

    Clue to watch for The question involves serverless infrastructure as code.

  4. No versioning

    What candidates pick
    Deploy Lambda changes directly without versions or aliases.
    Why it looks right
    It is simpler.
    Why it's wrong
    Versions and aliases enable traffic shifting and rollback; without them safe canary releases are not possible.

    Clue to watch for The release needs rollback or gradual traffic shifting.

  5. Test in production

    What candidates pick
    Run application tests directly against the production environment.
    Why it looks right
    It uses real infrastructure.
    Why it's wrong
    Tests belong in a development environment, automated in the pipeline, to avoid affecting live systems.

    Clue to watch for Testing could disrupt production.

Answer framework

For any Domain 3 scenario, use these steps to find the answer DVA-C02 expects.

  1. Package the application as code, using SAM for serverless apps, which transforms into CloudFormation, or the CDK or CloudFormation otherwise.
  2. Test in a development environment, and automate those tests as a pipeline stage so failures stop the deployment.
  3. Build and test with CodeBuild, orchestrate with CodePipeline, and deploy with CodeDeploy, keeping each service's role distinct.
  4. Use Lambda versions and aliases so traffic can be shifted and rolled back.
  5. Choose the deployment strategy that fits the risk, preferring canary or blue/green over all-at-once for sensitive releases, and use lifecycle hooks for validation. Where two options seem to fit, pick the one that most precisely matches the behavior the scenario requires.

Practice question

A developer must release a new version of a Lambda function behind an alias and wants to limit the impact if the new version has a problem, shifting traffic gradually. Which deployment strategy is MOST appropriate?

Want more like this? The AWS DVA practice test has questions for every domain.

Checklist

0 of 10

Tick each one you can do without notes. Your ticks stay in this browser.

Study strategy

Because many developers ship less than they code, invest real time here even though it may feel less familiar. Start by learning the CI/CD toolchain and keeping the roles distinct: CodePipeline orchestrates, CodeBuild builds and tests, CodeDeploy deploys, and CodeArtifact stores packages. This separation is a frequent exam trap.

Next, learn SAM as a serverless shorthand that transforms into CloudFormation, and how to package Lambda and container artifacts. Then master deployment strategies and Lambda versions and aliases, since safe rollouts depend on them: understand how canary and blue/green limit risk versus all-at-once, and how CodeDeploy lifecycle hooks and AppSpec files work.

Building a small pipeline that tests and deploys a Lambda with a canary strategy teaches this far better than reading. Afterwards, move to Domain 4, troubleshooting and optimization. Hands-on coding against the AWS SDK in a free-tier account cements these developer patterns far faster than reading, and reviewing missed practice questions by domain shows where to focus next.

FAQ

How much of DVA-C02 is Domain 3?

Deployment is 24% of the scored content, and together with security it makes up nearly half the exam.

What is the difference between CodeBuild and CodeDeploy?

CodeBuild compiles, packages and tests code. CodeDeploy takes the built artifact and deploys it using a chosen strategy and lifecycle hooks.

What is AWS SAM?

The Serverless Application Model, a simplified syntax for defining serverless applications that transforms into CloudFormation when deployed.

How do Lambda versions and aliases help deployment?

Versions are immutable snapshots, and aliases point to a version. Shifting an alias between versions enables canary and blue/green traffic shifting and quick rollback.

What is a canary deployment?

A strategy that shifts a small percentage of traffic to the new version first, monitors it, then shifts the rest, limiting the impact of a bad release.

Where should automated tests run?

As a stage in the pipeline, typically in CodeBuild, so a failing test stops the deployment before it reaches production.

How does Domain 3 connect to the rest of the exam?

It ships the code from Domain 1, applies the security of Domain 2 to pipelines, and produces the running systems that Domain 4 troubleshoots and optimizes.

Other Cloud Computing certifications

Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.

Test your Domain 3 knowledge

You have covered packaging, testing, CI/CD services and deployment strategies. Test whether you can choose the right tool and safe release approach under exam conditions.

Take the AWS DVA practice test Check your AWS DVA readiness

Keep going