AWS Certified Developer – Associate (DVA-C02): A Study Plan That Actually Works

Most AWS certification advice treats every exam the same: read the whitepapers, memorize the service list, take a practice test. That works for the Solutions Architect Associate. It fails for the Developer Associate — and the failure mode is predictable. DVA-C02 doesn't ask you to design architectures. It asks you to build, deploy, and debug them. The exam reads like a shift log from a real on-call rotation: a Lambda function timing out behind API Gateway, a DynamoDB table throttling under a hot partition key, a CI/CD pipeline deploying the wrong artifact to production. If your study plan doesn't include writing code and breaking things, you're preparing for the wrong exam.

There's also a clock running. AWS has confirmed the exam is being updated: DVA-C03 registration opens October 27, 2026, the last day to sit DVA-C02 is November 30, 2026, and DVA-C03 goes live December 1, 2026. The fundamentals below carry over either way — the four-domain structure and the core development skills stay — but book your date deliberately. If you can be exam-ready before the end of November, take DVA-C02 while the prep material is mature. If not, aim at DVA-C03, which adds AI-assisted development, AI security tasks, and stronger container coverage (ECR, ECS, EKS, Fargate) plus new services like Amazon Bedrock and Amazon Q. Either way, your credential is valid for three years from the pass date, and a DVA-C02 pass isn't invalidated by the version change.

The exam at a glance

65 questions in 130 minutes — multiple choice and multiple response, no penalty for guessing. The passing score is 720 on a 100–1000 scale. AWS recommends at least a year of hands-on experience developing and maintaining applications on AWS, and for once, that recommendation is honest: roughly a quarter of the questions assume you've actually debugged something in CloudWatch or wrestled with an IAM policy at 2 a.m.

The four domains, by weight:

1. Development with AWS Services — 32%. The heavyweight. Lambda, API Gateway, DynamoDB, S3, SQS, SNS, Step Functions, ElastiCache, plus the SDKs and CLI.
2. Security — 26%. IAM policies and roles, KMS encryption, Secrets Manager vs. Parameter Store, Cognito for auth, securing APIs.
3. Deployment — 24%. CI/CD with CodeCommit/CodeBuild/CodeDeploy/CodePipeline, Elastic Beanstalk, CloudFormation, SAM, deployment strategies (all-at-once, rolling, blue/green, canary).
4. Troubleshooting and Optimization — 18%. CloudWatch Logs/Metrics/Alarms, X-Ray tracing, reading error messages and choosing the fix.

Domain 1: Development with AWS Services (32%) — build the muscle memory

This domain rewards people who have written the code. The questions are scenario-driven: "Your Lambda function writes to DynamoDB and intermittently throws ProvisionedThroughputExceededException — what's the most likely cause and the fix?" You can't memorize your way to that answer. You need to know what a hot partition key feels like.

Prioritize in this order:

• Lambda inside and out. Event source mappings, reserved vs. provisioned concurrency, execution role permissions, environment variables, layers, destinations, and — the exam's favorite — timeout configuration. Lambda's max timeout is 15 minutes; API Gateway's is 29 seconds. A huge number of questions are really asking: "which timeout fired first?"
• DynamoDB. Partition keys and sort keys, GSIs vs. LSIs, eventually consistent vs. strongly consistent reads, DAX for caching, DynamoDB Streams with Lambda triggers. Hot partitions and throttling are evergreen exam topics.
• API Gateway. REST vs. HTTP vs. WebSocket APIs, stages and deployments, throttling/usage plans, Lambda authorizers, request/response mapping. Know that a deployment is required after changes — the "I changed the API but nothing happened" trap.
• Messaging and decoupling. SQS (standard vs. FIFO, visibility timeout, dead-letter queues, long polling) vs. SNS (fan-out, message filtering) vs. EventBridge. The exam loves "which service decouples these components" questions.
• The SDKs. Pagination, retries with exponential backoff and jitter, waiters. If you've never paginated a list_objects_v2 call, go write one now — it's five lines and it will earn you points.

Domain 2: Security (26%) — the developer's security, not the architect's

Developer security on this exam is practical: your code needs permissions, your secrets need storing, your APIs need auth.

• IAM. Policies (identity vs. resource-based), roles for Lambda/EC2/ECS, permission boundaries, cross-account access. Least privilege is the answer to a remarkable number of questions — when two options both work, the more restrictive one wins.
• Secrets. Secrets Manager vs. Systems Manager Parameter Store (SecureString): Secrets Manager wins when you need automatic rotation; Parameter Store is cheaper for simple cases. Hardcoding credentials is always wrong, and "store the API key in the Lambda environment variable" is the trap answer when rotation is required.
• KMS. Envelope encryption, CMKs, key policies. You don't need cryptographic depth — you need to know which service encrypts what and where the key lives.
• Cognito. User pools (authentication — sign-up/sign-in) vs. identity pools (authorization — temporary AWS credentials). The exam tests this distinction relentlessly. If the scenario says "mobile app users need temporary access to S3," that's an identity pool.
• API security. Lambda authorizers, Cognito authorizers, resource policies, WAF basics.

Domain 3: Deployment (24%) — pipelines and strategies

Know the Code* family cold: CodeCommit (source), CodeBuild (build), CodeDeploy (deploy), CodePipeline (orchestration). Then:

• Deployment strategies. All-at-once (fastest, riskiest), rolling, immutable, blue/green, canary, linear. The exam frames these as trade-off questions: "zero downtime required, instant rollback needed" → blue/green. "Shift 10% of traffic first" → canary.
• Elastic Beanstalk. Deployment policies mirror the strategies above; know the difference between rolling and rolling with additional batch, and when Beanstalk swaps CNAMEs.
• CloudFormation and SAM. Stacks, change sets, drift detection, intrinsic functions, SAM templates for serverless. Know that SAM is an extension of CloudFormation, not a replacement.
• Lambda versions and aliases. Weighted aliases for canary deployments — this bridges deployment and Lambda and the exam exploits the overlap.

Domain 4: Troubleshooting and Optimization (18%) — read the error, pick the fix

This domain is almost entirely "here's a symptom, what's the cause?" CloudWatch is your lens: Logs Insights queries, metric filters, alarms, composite alarms. X-Ray for distributed tracing — know the difference between a trace, a segment, and a subsegment, and when sampling matters.

The highest-yield skill here is error-message literacy: AccessDeniedException vs. throttling vs. timeout, and which service emitted the error. When you practice, don't just note whether you got the question right — write down why the wrong options were wrong. That habit is worth 50 points by itself.

The five traps that sink experienced developers

1. Timeout layering. Lambda behind API Gateway behind ALB — three timeouts, one symptom. Map every timeout in the chain before choosing.
2. Eventual consistency. "I wrote the item and immediately read it back, but it's missing" — that's not a bug, that's DynamoDB/S3 eventual consistency (and know which reads are strongly consistent).
3. The visibility timeout. SQS messages reappearing in the queue usually mean the consumer took longer than the visibility timeout — not a duplicate-publish bug.
4. Cold starts vs. provisioned concurrency. The exam distinguishes them precisely: provisioned concurrency keeps environments warm; reserved concurrency only limits/allocates. Don't conflate them.
5. Deployment required. API Gateway changes, Lambda alias shifts — several services need an explicit deploy/publish step. "Nothing changed" is the tell.

A study method that matches the exam

Books and videos teach; timed practice is what makes you pass. That's not a slogan — it's the mechanism. DVA-C02 tests recognition under time pressure: 130 minutes for 65 questions is exactly two minutes per question, and the long scenario stems eat into that fast. You need the pattern-matching to be automatic, and automation only comes from reps.

A plan that works: two weeks of hands-on (build a Lambda + API Gateway + DynamoDB app, wire Cognito auth, deploy it through CodePipeline, break it on purpose and fix it with CloudWatch and X-Ray), then two weeks of timed question blocks — 65 questions, 130 minutes, no pausing — reviewing every miss by writing the reason in your own words. When your timed scores hold above 80%, book the exam.

If you want exam-style reps on this exact blueprint, the DVA-C02 free practice questions at Study4Pass (https://study4pass.com/study-material/amazon-web-services/dva-c02) follow the same four domains with explanations for every answer — useful for the error-message literacy the exam demands.

Bottom line

DVA-C02 rewards builders. If you can write the Lambda function, secure it with IAM, deploy it through a pipeline, and debug it with CloudWatch and X-Ray, the exam is a formality. Study the services by using them, drill timed questions until the patterns are reflex, and book before the version clock runs out — or deliberately aim at DVA-C03 with the new AI and container topics in your plan. Either way, the developers who pass are the ones who practiced like developers.