CloudPath Academy

Your guide to AWS certification success

AWS Certified Developer Associate (DVA-C02) Domain 3

Deployment

Official Exam Guide: Domain 3: Deployment
Skill Builder: AWS Developer Associate (DVA-C02) Exam Prep

Note: Some Skill Builder labs require a subscription.

How to Study This Domain Effectively

Study Tips

Build complete CI/CD pipelines from scratch - The best way to master deployment is to create actual pipelines. Set up CodeCommit repositories, configure CodeBuild projects with buildspec.yml files, create CodeDeploy applications with appspec.yml files, and orchestrate everything with CodePipeline. Deploy a real application through multiple environments (dev, staging, production) using different deployment strategies. Hands-on pipeline creation solidifies concepts that are difficult to grasp from documentation alone.
Master Infrastructure as Code with hands-on practice - Don’t just read about CloudFormation and SAM templates—write them. Create SAM templates that define Lambda functions, API Gateway APIs, and DynamoDB tables. Deploy these templates to different environments using parameters. Practice updating stacks, understanding drift detection, and troubleshooting failed deployments. The exam heavily tests your ability to read and modify IaC templates, so comfort with template syntax is essential.
Experiment with all deployment strategies - Implement blue/green deployments with CodeDeploy, test canary deployments with API Gateway stages, practice rolling deployments with Lambda aliases and traffic shifting. Observe what happens during failures, how rollbacks work, and how each strategy affects downtime. Understanding the mechanics of each deployment strategy through experimentation prepares you for scenario-based exam questions.
Practice SAM CLI workflow extensively - Install AWS SAM CLI and use it throughout the development lifecycle: sam init to create projects, sam build to prepare artifacts, sam local invoke to test locally, and sam deploy to deploy to AWS. Understanding SAM’s local testing capabilities and how it simplifies serverless deployment is critical for exam questions about testing and deployment workflows.
Create a deployment decision matrix - Build a reference table mapping deployment requirements to strategies: zero downtime required (blue/green), gradual rollout with testing (canary), simple updates (all-at-once), containerized apps (ECS deployment types). Include when to use Lambda versions vs aliases, API Gateway stages, and CodeDeploy deployment configurations. This matrix helps you quickly identify the right deployment approach during exam scenarios.

Recommended Approach

Start with artifact preparation fundamentals - Begin by understanding how to structure applications for deployment: managing dependencies with requirements.txt or package.json, organizing directory structures, creating deployment packages for Lambda, and building container images. Learn how configuration differs across environments and how to externalize configuration using environment variables and AWS AppConfig.
Master AWS SAM and CloudFormation - Study SAM templates in depth since SAM extends CloudFormation for serverless applications. Understand template anatomy (Resources, Parameters, Outputs), pseudo parameters, intrinsic functions (Ref, GetAtt, Sub, Join), and how SAM transforms simplify Lambda and API Gateway definitions. Practice deploying and updating stacks across multiple environments with different parameter values.
Deep dive into CI/CD services - Study each CI/CD service individually before understanding their integration: CodeCommit for source control, CodeBuild for compilation and testing (buildspec.yml), CodeDeploy for deployment automation (appspec.yml), and CodePipeline for orchestration. Understand how they pass artifacts between stages and how to configure each service for different application types.
Learn deployment strategies comprehensively - Study each deployment strategy (all-at-once, rolling, blue/green, canary) in detail. Understand CodeDeploy deployment configurations, Lambda traffic shifting with aliases, API Gateway canary releases, and ECS deployment types. Learn when each strategy is appropriate, how to configure them, and how rollback works for each.
Practice testing at every stage - Learn to test locally with SAM CLI, create integration tests, test APIs using different stages, implement automated testing in CodeBuild, and validate deployments in non-production environments. Complete with practice exams focused on Domain 3 to identify deployment knowledge gaps and reinforce CI/CD concepts.

Task 1: Prepare application artifacts to be deployed to AWS

Skills & Corresponding Documentation

Skill 3.1.1: Manage the dependencies of the code module (for example, environment variables, configuration files, container images) within the package

Why: Dependency management is fundamental to successful deployments and is tested through scenarios involving Lambda deployment packages, container image builds, and application configuration. You must understand how to include dependencies in Lambda packages (requirements.txt for Python, package.json for Node.js), build Docker images with proper layers for caching, manage environment-specific configurations, and handle binary dependencies. Exam questions present deployment failures and expect you to identify missing dependencies or incorrect packaging as the root cause.

AWS Documentation:

Skill 3.1.2: Organize files and a directory structure for application deployment

Why: Proper file organization is tested because deployment tools expect specific directory structures. You must understand Lambda’s file structure requirements, SAM project layout (template.yaml, function folders), CodeDeploy’s expected structure with appspec.yml, Elastic Beanstalk’s .ebextensions directory, and how build tools organize output artifacts. Exam questions may present deployment failures caused by incorrect file placement or missing configuration files.

AWS Documentation:

Skill 3.1.3: Use code repositories in deployment environments

Why: Version control integration with deployment pipelines is essential for modern CI/CD workflows. You must understand how to use CodeCommit for source control, integrate GitHub/GitLab with CodePipeline, configure repository triggers, manage branches and pull requests, and use repository webhooks for automated deployments. Exam questions test your knowledge of triggering deployments from repository events and configuring source stages in pipelines.

AWS Documentation:

Skill 3.1.4: Apply application requirements for resources (for example, memory, cores)

Why: Resource configuration directly impacts application performance and cost, and is tested through scenarios involving Lambda memory settings, EC2 instance types, ECS task definitions, and capacity planning. You must understand how Lambda memory affects CPU allocation, how to configure ECS task CPU and memory, how to select appropriate EC2 instance types, and how resource limits affect application behavior. Exam questions present performance requirements and expect you to configure appropriate resource allocations.

AWS Documentation:

Skill 3.1.5: Prepare application configurations for specific environments (for example, by using AWS AppConfig)

Why: Environment-specific configuration is tested because applications need different settings for dev, staging, and production. You must understand AWS AppConfig for dynamic configuration management, Systems Manager Parameter Store for environment variables, how to use CloudFormation parameters for environment differentiation, Lambda environment variables per stage, and API Gateway stage variables. Exam questions present multi-environment deployments and expect you to configure appropriate environment-specific settings.

AWS Documentation:

AWS Service FAQs:

AWS Whitepapers:

Task 2: Test applications in development environments

Skills & Corresponding Documentation

Skill 3.2.1: Test deployed code by using AWS services and tools

Why: Testing deployed code is essential for validating functionality before production release. You must understand how to test Lambda functions using the console and AWS CLI, invoke functions with test events, use CloudWatch Logs for debugging, test API Gateway endpoints, use X-Ray for distributed tracing, and validate application behavior in AWS environments. Exam questions present testing scenarios and expect you to identify appropriate AWS testing tools and methods.

AWS Documentation:

Skill 3.2.2: Write integration tests and mock APIs for external dependencies

Why: Integration testing is critical for validating component interactions without depending on external services. You must understand how to write integration tests, use mocking libraries to simulate AWS service calls, create mock APIs with API Gateway, use LocalStack for local AWS service emulation, and test service integrations. Exam questions test your knowledge of testing strategies that isolate components and verify integration points.

AWS Documentation:

Skill 3.2.3: Test applications by using development endpoints (for example, configuring stages in Amazon API Gateway)

Why: Development endpoints and API stages enable testing without affecting production systems. You must understand API Gateway stages for environment separation, stage variables for environment-specific configuration, Lambda aliases for version testing, and how to configure multiple endpoints for testing. Exam questions present testing requirements and expect you to configure appropriate non-production endpoints.

AWS Documentation:

Skill 3.2.4: Deploy application stack updates to existing environments (for example, deploying an AWS SAM template to a different staging environment)

Why: Updating existing deployments is fundamental to iterative development and is tested through scenarios involving stack updates, environment promotion, and change management. You must understand CloudFormation stack updates, change sets for previewing changes, SAM deployments to different environments using parameters, and how to manage stack dependencies. Exam questions present update scenarios and expect you to identify safe update strategies and handle update failures.

AWS Documentation:

Skill 3.2.5: Test event-driven applications

Why: Event-driven architectures require specialized testing approaches because components react to asynchronous events. You must understand how to create test events for Lambda, simulate SQS messages, trigger SNS notifications for testing, generate EventBridge events, test Kinesis stream processing, and validate event-driven workflows. Exam questions present event-driven scenarios and expect you to implement appropriate testing strategies.

AWS Documentation:

AWS Service FAQs:

AWS Whitepapers:

Task 3: Automate deployment testing

Skills & Corresponding Documentation

Skill 3.3.1: Create application test events (for example, JSON payloads for testing AWS Lambda, API Gateway, AWS SAM resources)

Why: Test event creation is fundamental for automated testing pipelines. You must understand how to create JSON test events for Lambda functions, structure API Gateway request events, define SAM test events, create EventBridge event patterns, and generate realistic test data. Exam questions may present code that requires testing and expect you to create appropriate test event structures.

AWS Documentation:

Skill 3.3.2: Deploy API resources to various environments

Why: Multi-environment API deployment is tested because APIs need separate instances for development, testing, and production. You must understand how to deploy API Gateway to multiple stages, use stage variables for environment differentiation, configure stage-specific settings, promote APIs between environments, and manage API versions. Exam questions present API deployment scenarios and expect you to configure appropriate multi-environment strategies.

AWS Documentation:

Skill 3.3.3: Create application environments that use approved versions for integration testing (for example, Lambda aliases, container image tags, AWS Amplify branches, AWS Copilot environments)

Why: Version management is critical for reliable testing and deployment. You must understand Lambda versions and aliases for traffic management, container image tagging strategies, Amplify branches for frontend environments, and how to maintain multiple environment versions simultaneously. Exam questions test your ability to implement version control strategies that enable safe testing and gradual rollouts.

AWS Documentation:

Skill 3.3.4: Implement and deploy infrastructure as code (IaC) templates (for example, AWS SAM templates, AWS CloudFormation templates)

Why: Infrastructure as Code is extensively tested because it’s the foundation of modern deployment automation. You must understand CloudFormation template structure, SAM template syntax and transforms, template parameters and mappings, intrinsic functions (Ref, GetAtt, Sub), resource dependencies, and stack deployment. Exam questions frequently present IaC templates and expect you to read, modify, or troubleshoot them.

AWS Documentation:

Skill 3.3.5: Manage environments in individual AWS services (for example, differentiating between development, test, and production in API Gateway)

Why: Service-level environment management is tested because different AWS services have different mechanisms for environment separation. You must understand API Gateway stages, Lambda aliases, ECS service environments, Elastic Beanstalk environments, and how to configure service-specific environment settings. Exam questions present multi-environment scenarios and expect you to use appropriate service features for environment separation.

AWS Documentation:

Skill 3.3.6: Use Amazon Q Developer to generate automated tests

Why: Amazon Q Developer represents AWS’s AI-assisted development approach and is tested as a modern tool for accelerating test creation. You must understand how Q Developer can generate test cases, create unit tests for Lambda functions, suggest test scenarios, and help with test automation. Exam questions may test your knowledge of when and how to leverage Q Developer for testing tasks.

AWS Documentation:

AWS Service FAQs:

AWS Whitepapers:

Task 4: Deploy code by using AWS Continuous Integration and Continuous Delivery (CI/CD) services

Skills & Corresponding Documentation

Skill 3.4.1: Describe Lambda deployment packaging options

Why: Lambda deployment packaging is tested because different packaging methods suit different scenarios. You must understand .zip file packages for small functions, container images for custom runtimes and large dependencies, Lambda layers for shared code, and deployment package size limits. Exam questions present Lambda deployment requirements and expect you to select the appropriate packaging approach.

AWS Documentation:

Skill 3.4.2: Describe API Gateway stages and custom domains

Why: API Gateway stage and domain management is tested because production APIs require professional URLs and environment separation. You must understand how stages separate environments, stage variables for configuration, custom domain names with certificates, base path mappings for multiple APIs, and API versioning strategies. Exam questions present API publishing requirements and expect you to configure stages and custom domains correctly.

AWS Documentation:

Skill 3.4.3: Update existing IaC templates (for example, AWS SAM templates, CloudFormation templates)

Why: Updating IaC templates is fundamental to iterative development and is heavily tested. You must understand how to modify CloudFormation resources, add parameters, update SAM function definitions, handle stack updates and rollbacks, use change sets to preview changes, and manage template versioning. Exam questions present templates that need modification and expect you to make correct changes while avoiding disruption.

AWS Documentation:

Skill 3.4.4: Manage application environments by using AWS services

Why: Environment management with AWS services is tested through scenarios involving multiple deployment targets. You must understand Elastic Beanstalk environments, ECS clusters and services, Lambda aliases and versions, and how to manage configurations across environments. Exam questions present environment management requirements and expect you to use appropriate AWS services for environment orchestration.

AWS Documentation:

Skill 3.4.5: Deploy an application version by using deployment strategies

Why: Deployment strategies are heavily tested because they determine how updates roll out and affect downtime. You must understand all-at-once (simplest, has downtime), rolling (gradual replacement), blue/green (zero downtime, instant rollback), and canary (gradual traffic shift with testing) deployments. Exam questions present deployment requirements (zero downtime, gradual rollout, quick rollback) and expect you to select the appropriate strategy.

AWS Documentation:

Skill 3.4.6: Commit code to a repository to invoke build, test, and deployment actions

Why: Repository-triggered automation is fundamental to CI/CD and is tested through pipeline configuration scenarios. You must understand how CodeCommit triggers start pipelines, how CodePipeline detects source changes, configuring webhooks for GitHub integration, and automating build/test/deploy on commit. Exam questions present CI/CD requirements and expect you to configure automatic pipeline triggers.

AWS Documentation:

Skill 3.4.7: Use orchestrated workflows to deploy code to different environments

Why: Multi-stage deployment orchestration is tested because production deployments require progressive rollout through environments. You must understand CodePipeline stages and actions, manual approval actions, cross-account deployments, environment promotion workflows, and parallel execution. Exam questions present complex deployment workflows and expect you to configure appropriate pipeline structures.

AWS Documentation:

Skill 3.4.8: Perform application rollbacks by using existing deployment strategies

Why: Rollback capability is critical for production reliability and is tested through failure scenarios. You must understand Lambda alias version switching for instant rollback, CodeDeploy automatic rollback on failures, blue/green deployment rollback by redirecting traffic, CloudFormation stack rollback, and how to trigger manual rollbacks. Exam questions present deployment failures and expect you to identify appropriate rollback mechanisms.

AWS Documentation:

Skill 3.4.9: Use labels and branches for version and release management

Why: Version control strategies are tested because proper branching enables parallel development and controlled releases. You must understand Git branching strategies (GitFlow, trunk-based), semantic versioning, tagging releases, branch protection rules, and how CI/CD pipelines integrate with branches. Exam questions present version management requirements and expect you to configure appropriate branching and tagging strategies.

AWS Documentation:

Skill 3.4.10: Use existing runtime configurations to create dynamic deployments (for example, using staging variables from API Gateway in Lambda functions)

Why: Dynamic configuration enables flexible deployments without code changes. You must understand API Gateway stage variables passed to Lambda, Lambda environment variables per alias, parameter injection in CloudFormation, and how runtime configuration drives behavior across environments. Exam questions present scenarios requiring environment-specific behavior and expect you to use dynamic configuration mechanisms.

AWS Documentation:

Skill 3.4.11: Configure deployment strategies (for example, blue/green, canary, rolling) for application releases

Why: Configuring deployment strategies is extensively tested because strategy choice affects risk, downtime, and rollback capability. You must understand how to configure CodeDeploy deployment configurations, Lambda traffic shifting percentages, API Gateway canary settings, ECS deployment controllers, and when each strategy is appropriate. Exam questions present deployment requirements and expect you to configure the right strategy with correct parameters.

AWS Documentation:

AWS Service FAQs:

AWS Whitepapers:

Final Thoughts

Domain 3: Deployment is where development meets operations and represents the practical implementation of CI/CD principles on AWS. Success requires hands-on experience building complete deployment pipelines—reading alone is insufficient. Set up actual CodePipeline workflows that pull from CodeCommit, build with CodeBuild, and deploy with CodeDeploy. Practice creating and deploying SAM and CloudFormation templates across multiple environments. Master the different deployment strategies (all-at-once, rolling, blue/green, canary) by implementing each one and observing their behavior during updates and rollbacks. Understanding deployment automation is critical not just for the exam but for professional AWS development work, where reliable, repeatable deployments are essential. The skills you build in this domain—IaC, CI/CD pipelines, automated testing, and deployment strategies—form the foundation of modern DevOps practices and will serve you throughout your AWS career.