A free, open study guide for the AWS Certified Developer – Associate (DVA-C02) exam: revision notes for every domain, side-by-side comparisons of commonly confused services, a glossary, 20 worked sample questions, and the official syllabus as a checklist with a full free lesson for every topic.
Maintained by SaveMyCert, where you can read every lesson free, practice with explained questions and take timed mock exams.
Exam version change. AWS is replacing DVA-C02 with DVA-C03. Registration for DVA-C03 opens October 27, 2026, and the last day to take DVA-C02 is December 1, 2026. If you are booking for December 2026 or later, check the official DVA exam page for the DVA-C03 exam guide. This guide covers DVA-C02.
- Exam at a glance
- Exam domains
- What is in this repo
- Syllabus checklist
- How to study for DVA-C02
- Sample questions
- Free resources
| Exam code | DVA-C02 |
| Level | Associate |
| Questions | 65 |
| Time limit | 130 min |
| Passing score | 720 / 1000 |
| Format | Multiple choice & response |
| Exam fee | $150 |
| Valid for | 3 years |
Exam details change. Always confirm them in the official AWS Certified Developer – Associate (DVA-C02) exam guide from Amazon Web Services.
| # | Domain | Weight | Topics |
|---|---|---|---|
| 1 | Development with AWS Services | 32% | 3 |
| 2 | Security | 26% | 3 |
| 3 | Deployment | 24% | 4 |
| 4 | Troubleshooting and Optimization | 18% | 3 |
That is 4 domains and 13 topics. Spend your time in proportion to the weights: the heaviest domain decides more of your score than the lightest.
| File | What it gives you |
|---|---|
| Domain 1 notes | Development with AWS Services: condensed revision notes per topic |
| Domain 2 notes | Security: condensed revision notes per topic |
| Domain 3 notes | Deployment: condensed revision notes per topic |
| Domain 4 notes | Troubleshooting and Optimization: condensed revision notes per topic |
| Commonly confused services | Side-by-side tables of the services questions set against each other |
| Glossary | Every in-scope term and service in one sentence |
| Sample questions | 20 worked questions with answers and reasoning |
| Exam-day guide | Booking, testing options, scoring, results and retakes |
Tick each topic off once you can explain it without notes. The "Must know" facts are the ones questions turn on. Each lesson link goes to the complete, free lesson.
Weight: 32%. Writing cloud-native application code, developing AWS Lambda functions, and integrating data stores.
📝 Revision notes: Domain 1: Development with AWS Services
- 1 Develop code for applications hosted on AWS
1 (guide v2.1). Architectural patterns — event-driven, microservices, monolithic, choreography vs orchestration, fanout; stateful vs stateless and tight vs loose coupling; sync vs async; fault-tolerant, resilient code (retry logic, circuit breakers, error handling); creating and extending APIs (transformations, validation, status-code overrides); messaging services, SDK/API calls, streaming data; unit tests (e.g. AWS SAM); event-driven patterns with Amazon EventBridge; development assistance with Amazon Q Developer.- 📖 Lesson: Application Development Patterns on AWS: Architecture, APIs and Messaging
- Must know: Loose coupling with asynchronous messaging is the exam's default answer for resilience, burst absorption, and independent scaling
- Must know: Choreography = services reacting to events via EventBridge or SNS; orchestration = Step Functions centrally coordinating a visible workflow
- 1.2 Develop code for AWS Lambda
Function configuration — memory, concurrency, timeout, runtime, handler, layers, extensions, triggers, destinations; accessing VPC-private resources; the event lifecycle and error handling (Lambda Destinations, dead-letter queues); integrating Lambda with other AWS services; testing and performance tuning; near-real-time data processing and transformation.- 📖 Lesson: AWS Lambda for Developers: Configuration, Events, Concurrency and Tuning
- Must know: CPU scales with memory — memory is the primary performance dial, with roughly one vCPU at 1,769 MB
- Must know: Maximum timeout is 900 seconds (15 minutes); longer workloads need Step Functions or different compute, not a bigger timeout
- 1.3 Use data stores in application development
DynamoDB data modeling — high-cardinality partition keys, keys and indexing, query vs scan, strong vs eventual consistency; serialization/deserialization for persistence; managing data stores and data lifecycles; caching services; choosing specialized data stores by access pattern (e.g. Amazon OpenSearch Service).- 📖 Lesson: DynamoDB and AWS Data Stores for Developers (DVA-C02)
- Must know: Choose a high-cardinality partition key — a low-cardinality key creates hot partitions that no capacity setting can fix.
- Must know: LSI: same partition key, alternate sort key, table-creation only, supports strongly consistent reads. GSI: any keys, created anytime, eventually consistent only.
Weight: 26%. Authentication and authorization for applications, encryption with AWS services, and handling sensitive data in code.
📝 Revision notes: Domain 2: Security
- 2.1 Implement authentication and/or authorization for applications and AWS services
Federated access via identity providers (Amazon Cognito, IAM); bearer tokens; programmatic AWS access and authenticated service-to-service calls; assuming IAM roles and defining permissions for IAM principals; application-level authorization for fine-grained access control; cross-service authentication in microservice architectures.- 📖 Lesson: Authentication and Authorization on AWS: Cognito, IAM, and STS
- Must know: User pool = authentication (who are you, JWTs); identity pool = authorization to AWS (temporary credentials).
- Must know: Only identity pools support unauthenticated guest access to AWS services.
- 2.2 Implement encryption by using AWS services
Encryption at rest vs in transit; client-side vs server-side encryption; certificate management (e.g. AWS Private CA) and generating certificates/SSH keys for development; encrypting and decrypting with AWS KMS keys; cross-account encryption; enabling and disabling key rotation.- 📖 Lesson: AWS KMS and Encryption for Developers: Keys, Envelopes, and Certificates
- Must know: KMS Encrypt takes at most 4 KB of plaintext — anything larger means envelope encryption with GenerateDataKey.
- Must know: Envelope encryption: GenerateDataKey → encrypt locally → store the encrypted data key with the data → Decrypt to unwrap.
- 2.3 Manage sensitive data in application code
Data classification (PII, PHI); encrypting sensitive environment variables; secret management services (Secrets Manager, Systems Manager Parameter Store); sanitizing sensitive data; application-level data masking; data access patterns for multi-tenant applications.- 📖 Lesson: Managing Sensitive Data: Secrets Manager vs Parameter Store
- Must know: "Automatic rotation" or rotating database credentials means Secrets Manager; "free" or "no additional cost" configuration means Parameter Store standard tier.
- Must know: Parameter Store SecureString values are encrypted with KMS but never rotate themselves; retrieving one requires GetParameter with WithDecryption set to true.
Weight: 24%. Preparing artifacts, testing in development environments, automating deployment testing, and CI/CD deployments.
📝 Revision notes: Domain 3: Deployment
- 3.1 Prepare application artifacts to be deployed to AWS
Managing code-module dependencies via environment variables, configuration files, and container images; file/directory structure for deployment; code repositories in deployment environments; resource requirements (memory, cores); per-environment application configuration (e.g. AWS AppConfig).- 📖 Lesson: Preparing Application Artifacts for AWS Deployment
- Must know: Lambda zip packages: 50 MB zipped for direct upload, 250 MB unzipped including layers; Lambda container images go up to 10 GB via ECR.
- Must know: Match artifact to target: zip or container image for Lambda, ECR images for ECS/EKS, and a root-level zip source bundle for Elastic Beanstalk.
- 3.2 Test applications in development environments
Testing deployed code with AWS services and tools; integration tests and mock APIs for external dependencies; development endpoints (e.g. API Gateway stages); deploying stack updates to existing environments (e.g. a SAM template to staging); testing event-driven applications.- 📖 Lesson: Testing Applications in AWS Development Environments
- Must know: sam local invoke runs one function in Docker; sam local start-api emulates API Gateway for HTTP calls; sam local start-lambda exposes the Lambda invoke API to SDKs and test code.
- Must know: Unit tests mock AWS SDK calls for fast logic feedback; integration tests against real dev-stage resources catch what mocks cannot — IAM, configuration, and service behavior.
- 3.3 Automate deployment testing
Creating test events (JSON payloads for Lambda, API Gateway, SAM); deploying API resources to environments; approved-version strategies (Lambda aliases, container image tags, Amplify branches); implementing and deploying infrastructure-as-code templates (SAM, CloudFormation); managing per-service environments (dev/test/prod in API Gateway); generating automated tests with Amazon Q Developer.- 📖 Lesson: Automate Deployment Testing: Test Events, Approved Versions, and IaC
- Must know: Lambda receives a service-specific JSON event — API Gateway wraps the whole HTTP request, while SQS and S3 deliver a Records array.
- Must know: sam local generate-event prints realistic sample payloads you can commit to the repo and replay in automated tests.
- 3.4 Deploy code by using AWS CI/CD services
Lambda deployment packaging; API Gateway stages and custom domains; updating IaC templates; configuring blue/green, canary, and rolling deployment strategies and rollbacks; orchestrated workflows across environments; commit-triggered build/test/deploy (CodeBuild, CodeDeploy, CodePipeline); labels and branches for version and release management; dynamic deployments via runtime configuration (e.g. API Gateway stage variables read from Lambda).- 📖 Lesson: AWS CI/CD Services: CodePipeline, CodeDeploy, and Deployment Strategies
- Must know: CodePipeline orchestrates; CodeBuild builds and tests; CodeDeploy deploys; CodeArtifact hosts packages.
- Must know: buildspec.yml drives CodeBuild (install, pre_build, build, post_build); appspec.yml drives CodeDeploy.
Weight: 18%. Root-cause analysis, instrumenting code for observability, and optimizing applications on AWS.
📝 Revision notes: Domain 4: Troubleshooting and Optimization
- 4.1 Assist in a root cause analysis
Debugging code and service-integration issues; interpreting and querying metrics, logs, and traces; custom metrics (e.g. CloudWatch embedded metric format); dashboards and insights for application health; troubleshooting deployment failures from service logs.- 📖 Lesson: Root Cause Analysis on AWS: Reading Logs, Metrics, and Error Codes
- Must know: Metrics say something is wrong, logs say why, traces say where — alarm, query, trace, in that order.
- Must know: A 502 from API Gateway with a healthy Lambda function almost always means a malformed proxy response: statusCode missing or body not a string.
- 4.2 Instrument code for observability
Logging vs monitoring vs observability; effective and structured logging strategies; emitting custom metrics from code; distributed tracing with annotations (AWS X-Ray); notification alerts (quota limits, deployment completions); health checks and readiness probes.- 📖 Lesson: Instrument Code for Observability: CloudWatch, X-Ray, and Alarms
- Must know: Logging records events, monitoring watches known thresholds, observability lets you diagnose problems you never predicted from telemetry you already emit.
- Must know: Never log secrets, tokens, or PII; log state transitions and identifiers at a level set by environment variable, and set log group retention explicitly.
- 4.3 Optimize applications by using AWS services and features
Concurrency and profiling; determining minimum memory/compute sizing; subscription filter policies for messaging; content caching by request headers and application-level caching; optimizing resource usage, analyzing performance issues, and finding bottlenecks through application logs.- 📖 Lesson: Optimize AWS Applications: Concurrency, Caching, and Right-Sizing
- Must know: Concurrency is requests in flight: for Lambda, concurrent executions ≈ request rate × average duration, so faster code needs less concurrency.
- Must know: Provisioned concurrency answers "consistently low latency"; reserved concurrency caps a function to protect downstream systems.
- Read the lesson for each topic in the checklist above, starting with the heaviest domain. Every lesson is free on the DVA-C02 revision notes.
- Practice straight after reading. Answer DVA-C02 practice questions on the topic you just read. Each option comes with an explanation of why it is right or wrong.
- Review what you got wrong, re-read that lesson section, and tick the topic off only when you get its questions right.
- Take a full-length DVA-C02 mock exam under the real time limit. Aim to pass mocks comfortably before you book.
- On the last day, skim the DVA-C02 cheat sheet instead of starting anything new.
sample-questions.md has 20 worked DVA-C02 questions with the answer, why each option is right or wrong, and the reasoning steps.
- AWS Certified Developer – Associate (DVA-C02) exam guide: the official source (Amazon Web Services)
- DVA-C02 certification overview
- DVA-C02 revision notes: every lesson, free to read
- DVA-C02 practice questions: with an explanation on every option
- DVA-C02 mock exams: full-length and timed
- DVA-C02 cheat sheet: the key facts on one page
- All certification study guides
Spotted an error or an out-of-date fact? Open an issue with the topic and a link to the official source. See CONTRIBUTING.md.
This guide is licensed under CC BY 4.0. You can reuse and adapt it, including commercially, as long as you credit SaveMyCert with a link to https://www.savemycert.com/.
This is an independent study resource. It is not affiliated with or endorsed by Amazon Web Services. AWS Certified Developer – Associate and DVA-C02 are trademarks of their respective owner. Exam domains and weights are taken from the official exam guide linked above.