DVA-C02 study plan: from writing code to exam-ready
Updated
A dependable DVA-C02 study plan has four phases: build and deploy a small serverless application so the core services are concrete, study the four domains in weight order with daily scenario practice, consolidate the implementation trade-offs you keep getting wrong, then rehearse with full-length timed mocks until you clear the pass mark consistently. Because DVA-C02 tests developer judgment rather than recall, the plan front-loads shipping code over reading about it — and the timeline stretches or compresses depending on how much you already build on AWS.
Before you start: set the finish line and gauge your gap
Pick an exam window now, even loosely — a date turns study into a project. Then answer a short practice session cold, before studying anything. On a developer exam the baseline is diagnostic in a useful way: it tells you whether your gap is coverage (services you have never touched, often the CI/CD suite or Cognito) or judgment (you know the services but pick the wrong implementation under a constraint), and those need different remedies.
Be honest about which parts of the syllabus your job actually exercises. Most working developers are strong wherever their codebase lives — perhaps Lambda and DynamoDB — and weak in the domains their pipeline or platform team owns, usually deployment strategies and IAM. The plan's length is set by the weak half, not the strong one.
Phase 1 — Ship a small application to AWS (do not skip)
Before deep study, build the exam's world in miniature on the AWS Free Tier: a Lambda function behind API Gateway reading and writing a DynamoDB table; an SQS queue decoupling a slow step, with a dead-letter queue for failures; secrets in Secrets Manager or Parameter Store instead of environment variables; the stack defined as a SAM template; and a pipeline that builds and deploys it, shifting traffic to a new Lambda version through an alias.
You are not building production software — you are earning the intuition the scenarios assume. Break things on purpose: give the function too little memory, remove a permission from its role, push a bad version and roll back. The exam's troubleshooting questions are re-runs of exactly these moments, and X-Ray traces and CloudWatch logs of your own failures teach faster than any lesson.
Phase 2 — Study the four domains in weight order (the bulk)
Work through the domains heaviest-weighting first — Development with AWS Services, then Security, then Deployment, then Troubleshooting and Optimization. For each domain: read its lessons end to end, then drill scenario sessions scoped to that domain until your accuracy stabilises before moving on. Finishing a domain completely beats sampling everything shallowly, because half-known implementation details are exactly what the distractor options are built from.
Keep a daily practice habit running across everything you have covered, mixing earlier domains back in so they stay warm. Read the explanation on every option, right or wrong — on a judgment exam the reasoning behind the second-best answer is the actual syllabus, and it is where the difference between SQS and EventBridge, or a user pool and an identity pool, finally sticks.
Phase 3 — Consolidate the trade-offs you miss
When all four domains are covered, switch from learning to repair. Rebuild practice sessions from your incorrect and flagged questions — the review pool is your personal weak-spot list — and look for patterns: if you keep confusing Secrets Manager with Parameter Store, or canary with linear traffic shifting, that is a specific gap to close, not a vague weakness.
This is also cheat-sheet time: skim every key takeaway domain by domain, and treat anything unfamiliar as a signal to revisit that lesson. By the end of this phase the recurring decision sets — messaging, Lambda configuration, DynamoDB key and index design, secrets and identity, deployment strategies, retries and caching — should feel automatic.
Phase 4 — Mock week: rehearse, then book
Sit a full-length timed mock under real conditions: one sitting, no notes, no pausing. Developer-exam stems are dense with configuration detail — policy fragments, error messages, capacity settings — so this phase is as much about reading discipline and pacing as knowledge; practise flag-and-return so one intricate question never costs you three straightforward ones. The mocks use the exam's scaled scoring, so the pass line means what it will on the day.
After each mock, spend a session on its incorrect answers before sitting the next. Book the real exam once you clear the pass mark comfortably on consecutive mocks, and keep the daily practice habit until exam day.
Signals you are ready
Book the exam when all of these are true:
- Consecutive full-length mocks above the pass mark — a trend, not one lucky sitting.
- No domain clearly trailing the others in your per-domain accuracy, especially not Security or Deployment.
- The recurring implementation decisions — messaging service, DynamoDB index, secret store, deployment strategy — feel automatic, not effortful.
- You can read an IAM policy or a Lambda error scenario and predict the behaviour before looking at the options.
- Your review pool of incorrect questions is shrinking week over week, not growing.