AWS Certified Developer Associate Exam Guide (2026)

AWS Certified Developer - Associate (DVA-C02) - Complete Exam Guide

Introduction: Why Become an AWS Certified Developer?

The AWS Certified Developer - Associate certification validates your expertise in developing, deploying, and debugging cloud-based applications using AWS.

This isn't a theoretical certification- it's designed for developers who write code that runs on AWS and need to understand how to leverage AWS services effectively in their applications.

This certification demonstrates to employers that you can develop serverless applications, implement CI/CD pipelines, write code that interacts with AWS services via SDKs and APIs, and troubleshoot distributed applications. In an era where cloud-native development is the standard, this certification proves you have the practical skills companies need.

____

Exam Overview: What You're Getting Into

Exam Details at a Glance

• Exam Code: DVA-C02
• Duration: 130 minutes
• Number of Questions: 65 questions
• Question Format: Multiple choice (1 correct answer) and multiple response (2+ correct answers)
• Passing Score: 720 out of 1000 (approximately 72%)
• Cost: $150 USD
• Validity: 3 years
• Delivery Method: Pearson VUE testing centers or online proctored exam
• Prerequisites: None (but AWS Cloud Practitioner recommended)
• Experience Level: Associate (requires 1+ years of hands-on AWS development experience)

What Makes This Exam Different

Unlike the Cloud Practitioner exam, the Developer Associate exam expects you to have hands-on coding experience with AWS.

You'll encounter questions that require you to understand code snippets, debug errors, choose the right SDK methods, and make architecture decisions based on development requirements. This is a practical exam for developers who live in code editors and terminals.

Scenario-based questions will test your ability to solve real-world development problems- handling Lambda timeouts, debugging DynamoDB throughput issues, implementing secure authentication flows, and optimizing API Gateway configurations. You need to think like a developer, not just an architect.

_____

Exam Domains: Breaking Down What's Tested

The DVA-C02 exam is divided into four domains, each weighted differently. Understanding these weightings helps you allocate your study time effectively.

Domain 1: Development with AWS Services (32% of exam)

What This Domain Covers:

This domain tests your ability to develop code for applications hosted on AWS, write Lambda functions, and use AWS data stores effectively. This is the largest domain and focuses heavily on practical development skills.

Key Topics You'll Encounter:

• AWS Lambda Development: Writing Lambda functions, handling events, configuring runtime settings, using layers and extensions
• API Development: Creating and managing REST and WebSocket APIs with API Gateway, implementing authentication and authorization
• Application Architecture: Implementing event-driven architectures, microservices patterns, and serverless applications
• AWS SDK Usage: Making API calls using AWS SDKs, handling pagination, implementing retry logic and error handling
• Data Store Integration: Working with DynamoDB, RDS, ElastiCache, and S3 in application code
• Messaging Services: Implementing SQS, SNS, EventBridge, and Step Functions for decoupled architectures

What Success Looks Like:

You should be able to write production-ready Lambda functions, design RESTful APIs with proper authentication, implement database access patterns, and build event-driven applications that scale automatically.

Exam Question Style:

"A Lambda function processes messages from an SQS queue. The function occasionally times out when processing large batches. What configuration changes will improve reliability? (Select TWO)"

__

Domain 2: Security (26% of exam)

What This Domain Covers:

Security is critical for developers. This domain tests your ability to implement authentication, authorization, encryption, and secure coding practices in AWS applications.

Key Topics You'll Encounter:

• IAM for Developers: Creating and managing IAM roles for services, implementing least privilege, using IAM policies effectively
• Amazon Cognito: Implementing user pools, identity pools, federated identities, and social authentication
• Encryption Implementation: Using AWS KMS for encryption, implementing encryption at rest and in transit, managing keys programmatically
• Secrets Management: Using AWS Secrets Manager and Parameter Store to handle credentials and configuration securely
• Secure Coding Practices: Input validation, sanitization, preventing injection attacks, secure API design
• AWS Security Services: Implementing AWS WAF, Shield, GuardDuty, and Macie in applications

What Success Looks Like:

You should be able to implement complete authentication flows with Cognito, encrypt sensitive data using KMS, store secrets securely, and write code that follows AWS security best practices.

Exam Question Style:

"An application needs to access a database password stored in Secrets Manager. The password rotates automatically every 30 days. What is the most secure way for the Lambda function to retrieve the current password?"

__

Domain 3: Deployment (24% of exam)

What This Domain Covers:

This domain tests your ability to prepare application artifacts, implement CI/CD pipelines, automate testing, and deploy code using AWS services.

Key Topics You'll Encounter:

• CI/CD Pipelines: Implementing CodePipeline, CodeBuild, CodeDeploy, and CodeCommit for automated deployments
• Deployment Strategies: Blue/green deployments, canary deployments, rolling deployments, immutable deployments
• Elastic Beanstalk: Deploying applications using Elastic Beanstalk, managing configurations, implementing deployment strategies
• Containerization: Working with ECS, Fargate, and ECR for containerized applications
• Infrastructure as Code: Using CloudFormation, SAM (Serverless Application Model), and CDK for deployment automation
• Testing Strategies: Implementing unit tests, integration tests, and automated testing in CI/CD pipelines
• Environment Management: Managing multiple environments (dev, staging, production), configuration management

What Success Looks Like:

You should be able to build complete CI/CD pipelines, implement safe deployment strategies with automatic rollback, use CloudFormation templates effectively, and automate testing and deployment processes.

Exam Question Style:

"A development team wants to deploy a Lambda function update with 10% of traffic routed to the new version initially, then gradually increase to 100% over 10 minutes. Which CodeDeploy deployment configuration should they use?"

__

Domain 4: Troubleshooting and Optimization (18% of exam)

What This Domain Covers:

This domain tests your ability to debug issues, implement observability, optimize application performance, and analyze application behavior.

Key Topics You'll Encounter:

• CloudWatch Integration: Implementing custom metrics, logs, and alarms in application code
• AWS X-Ray: Implementing distributed tracing, analyzing trace data, identifying bottlenecks
• Debugging Techniques: Reading CloudWatch Logs, analyzing error patterns, debugging Lambda functions
• Performance Optimization: Optimizing Lambda cold starts, implementing caching strategies, database query optimization
• Cost Optimization: Right-sizing resources, implementing efficient data access patterns, reducing API calls
• Monitoring and Alerting: Creating dashboards, setting up alarms, implementing automated remediation

What Success Looks Like:

You should be able to implement comprehensive logging and tracing, diagnose performance issues using X-Ray and CloudWatch, optimize Lambda function performance, and set up effective monitoring and alerting.

Exam Question Style:

"An API Gateway endpoint is experiencing high latency. After enabling X-Ray tracing, you notice the DynamoDB queries are taking 2-3 seconds. What optimization should you implement to reduce latency?"

_____

The Must-Know Services: Your Priority List

Not all AWS services are tested equally. Here's your strategic focus list for the Developer exam.

Critical Services (Master These)

Compute & Application Services:

• AWS Lambda: Function configuration, event sources, layers, destinations, error handling, performance tuning
• API Gateway: REST APIs, WebSocket APIs, authentication, throttling, caching, stages, custom domains
• Elastic Beanstalk: Application deployment, environment management, configuration files (.ebextensions)

Development & Deployment:

• CodePipeline: Building CI/CD workflows, pipeline stages, action groups
• CodeBuild: Build specifications (buildspec.yml), environment variables, artifacts
• CodeDeploy: Deployment configurations, deployment groups, appspec files, rollback strategies
• CodeCommit: Git repository management, triggers, pull requests
• AWS SAM (Serverless Application Model): Template syntax, local testing, deployment
• CloudFormation: Template structure, intrinsic functions, stack operations, change sets

Data Services:

• DynamoDB: Primary keys, indexes (GSI/LSI), query vs scan, capacity units, streams, transactions
• RDS: Connection management, read replicas, Multi-AZ, backup and restore
• ElastiCache: Redis vs Memcached, caching strategies, lazy loading vs write-through
• S3: Bucket policies, CORS configuration, presigned URLs, storage classes, lifecycle policies

Security & Identity:

• IAM: Roles for services (Lambda execution role, EC2 instance role), policies, AssumeRole
• Amazon Cognito: User pools, identity pools, authentication flows, JWT tokens, federated identities
• AWS KMS: Encryption/decryption APIs, key policies, envelope encryption, context-specific encryption
• Secrets Manager: Secret rotation, retrieval in code, integration with RDS
• Parameter Store: Standard vs advanced parameters, hierarchical parameters, SecureString type

Messaging & Integration:

• SQS: Standard vs FIFO queues, visibility timeout, dead-letter queues, long polling
• SNS: Topics, subscriptions, message filtering, fanout patterns
• EventBridge: Event patterns, rules, targets, custom events
• Step Functions: State machines, task states, error handling, parallel execution

Monitoring & Debugging:

• CloudWatch Logs: Log groups, log streams, filter patterns, insights queries
• CloudWatch Metrics: Custom metrics, dimensions, alarms, composite alarms
• AWS X-Ray: Trace segments, subsegments, annotations, sampling rules, service maps

Important Services (Know These Well)

• ECS/Fargate: Task definitions, services, container deployment
• ECR: Container registry, image management
• Kinesis Data Streams: Shards, stream processing, Lambda integration
• AWS Systems Manager: Parameter Store advanced features, Session Manager
• AWS AppSync: GraphQL API development
• AWS Amplify: Full-stack application deployment

High-Frequency Exam Topics

These concepts appear repeatedly across multiple questions:

1. Lambda Best Practices - Environment variables, VPC configuration, layer usage, memory/timeout settings
2. DynamoDB Access Patterns - Choosing partition keys, using indexes effectively, avoiding hot partitions
3. IAM Roles vs Users - When to use roles (almost always for services), temporary credentials via STS
4. API Gateway Authentication - Cognito authorizers, Lambda authorizers, IAM authentication
5. SQS Visibility Timeout - Understanding how it works and common timeout-related bugs
6. CodeDeploy Deployment Types - AllAtOnce, HalfAtATime, OneAtATime, Custom, Canary, Linear
7. S3 Security - Bucket policies vs IAM policies, CORS configuration, presigned URLs
8. CloudFormation Intrinsic Functions - Ref, GetAtt, Sub, Join, ImportValue
9. X-Ray Integration - Instrumenting code, trace data interpretation
10. Error Handling and Retries - Exponential backoff, SDK retry behavior, idempotency

Services You Can Deprioritize

These services rarely appear on the Developer exam:

• Advanced networking (Transit Gateway, Direct Connect, PrivateLink)
• Most machine learning services (SageMaker basics are enough)
• IoT services
• Media services (MediaConvert, Elemental)
• AWS Organizations and Control Tower
• Migration services (Database Migration Service, Server Migration Service)

_____

Study Strategy: Your Path to Success

Phase 1: Foundation Building (2-3 Weeks)

Start with Lambda, API Gateway, and DynamoDB—these are the core of AWS development.

Focus Areas:

• Write actual Lambda functions with different event sources
• Create APIs with API Gateway (REST and WebSocket)
• Build DynamoDB tables and write query code
• Practice using AWS SDKs (Python/boto3, JavaScript/aws-sdk, or Java SDK)

Phase 2: Security Deep-Dive (2 Weeks)

Security is heavily tested and critical for developers.

Focus Areas:

• Implement complete authentication with Cognito
• Practice encrypting/decrypting data with KMS
• Store and retrieve secrets using Secrets Manager
• Understand IAM policies and roles inside-out

Phase 3: CI/CD and Deployment (2-3 Weeks)

Learn the AWS deployment ecosystem thoroughly.

Focus Areas:

• Build complete CI/CD pipelines with CodePipeline
• Write CloudFormation and SAM templates
• Implement different deployment strategies
• Practice with Elastic Beanstalk deployments

Phase 4: Troubleshooting and Optimization (2 Weeks)

Master observability and debugging.

Focus Areas:

• Integrate X-Ray into applications
• Write CloudWatch custom metrics and alarms
• Practice reading logs and identifying issues
• Optimize Lambda performance and costs

Phase 5: Practice and Refinement (2-3 Weeks)

Use practice exams to identify and fix knowledge gaps.

Strategy:

• Take Practice Set 1 under exam conditions
• Analyze weak domains thoroughly
• Target weak areas with hands-on labs
• Take Practice Set 2 and measure improvement
• Repeat until consistently scoring 85%+

_____

Hands-On Practice is Non-Negotiable

This exam requires actual coding experience. Set up these hands-on projects:

1. Serverless API Project: Build a complete REST API using Lambda, API Gateway, and DynamoDB
2. Authentication Implementation: Add Cognito user pools with email/password and social login
3. CI/CD Pipeline: Create a full pipeline that deploys your API automatically on code push
4. Monitoring Setup: Implement X-Ray tracing and CloudWatch dashboards for your application
5. Data Processing: Build an event-driven data pipeline using S3, Lambda, and SQS

Use the AWS Free Tier extensively- most of what you need to practice is free or very low cost.

_____

Exam Day Strategy: Maximizing Your Performance

Before the Exam

• Review code patterns the night before (Lambda event structures, SDK calls, CloudFormation syntax)
• Rest well—debugging questions require mental sharpness
• Have your AWS SDK documentation bookmarks ready (though you won't have access during the exam)

During the Exam

• Code Questions: Read code snippets carefully—look for subtle bugs like incorrect SDK methods
• Scenario Questions: Identify the core requirement (security? performance? cost?) before choosing answers
• "Most Appropriate" Questions: Often multiple answers work, but one is best practice
• Time Management: 130 minutes for 65 questions = 2 minutes per question
• Flag and Return: Don't get stuck on complex scenarios—come back to them

Common Traps to Avoid

• Overcomplicating Solutions: AWS often tests for the simplest working solution
• Confusing Similar Services: SQS vs SNS, Secrets Manager vs Parameter Store, X-Ray vs CloudWatch
• Missing Error Handling: Questions often hinge on proper retry logic or error handling
• Ignoring Security: The "working" solution isn't correct if it violates security best practices

_____

Resources for Success

Official AWS Resources

• AWS Free Tier: Build real projects hands-on
• AWS Developer Guide: Official documentation for each service
• AWS SDK Documentation: Learn SDK patterns for your preferred language
• AWS Workshops: Free hands-on labs (workshops.aws)
• AWS Skill Builder: Free developer training courses

CloudFluently Course Package Includes

• Comprehensive Study Notes: Developer-focused explanations with code examples
• 195 Practice Questions: Three full-length exams with detailed explanations
• Hands-On Projects: Practical exercises to build real-world skills
• Quick Reference Cheatsheets: SDK methods, service limits, deployment patterns
• Flashcards: Active recall for key concepts and service features

_____

After You Pass: What's Next?

Career Growth

• Update Your Credentials: Add certification to LinkedIn and resume
• Build a Portfolio: Showcase serverless projects on GitHub
• Contribute to Open Source: AWS-related projects value certified contributors
• Pursue Specialty Certifications: DevOps Engineer, Solutions Architect, or specialty certs

Continued Learning

• Stay Current: AWS releases new features constantly—follow AWS blogs
• Deep Dive: Master advanced patterns like event sourcing, CQRS, distributed tracing
• Learn Adjacent Skills: Terraform, Kubernetes, monitoring tools (Datadog, New Relic)

_____

Final Thoughts: You're Ready for This

The AWS Certified Developer - Associate exam rewards practical experience and hands-on skills. If you've built applications on AWS, debugged Lambda functions, and deployed through CI/CD pipelines, you have what it takes.

This exam isn't about memorizing facts- it's about proving you can build production-ready applications on AWS. The combination of study notes, practice exams, and hands-on projects in this package gives you everything you need to pass confidently.

Code daily, practice with real AWS services, and learn from your mistakes. When exam day comes, you'll recognize the scenarios because you've lived them.

Good luck, future AWS Certified Developer! 💻☁️