AWS Developer Associate Exam Preparation Guide

You can write clean application code every working day and still walk out of the AWS Certified Developer – Associate (DVA-C02) exam feeling ambushed. That is the most common story among developers who under-prepare for it: the exam does not test whether you can program — it assumes you can — and instead probes how well you wire applications into Amazon Web Services (AWS) itself. Service configuration, SDK behaviour, deployment pipelines, permissions, debugging distributed systems: that is the terrain.

This guide is a preparation roadmap for that terrain. It covers what to study, in what order, what to build hands-on, and how to test your readiness before you spend the exam fee. If you want the exam's logistics in full — registration steps, languages, booking mechanics — those live in our companion AWS Developer Associate certification guide; this article stays focused on the preparation itself.

What you are actually preparing for

Before planning study time, anchor yourself to the exam's fixed parameters. As of 2026, DVA-C02 is the current version of the AWS Certified Developer – Associate exam. It presents 65 questions in 130 minutes, in multiple-choice and multiple-response format, and costs $150 USD (pricing varies by country and region, so confirm the local figure when you book). The passing score is 720 on AWS's scaled range of 100–1000 — a scaled score, not a percentage of questions answered correctly. There is no lab or coding component: every question is answered by selecting options, which shapes how you should study (more on that below).

There are no formal prerequisites. AWS recommends at least a year of hands-on experience developing on AWS, but nothing stops a motivated developer with less experience from booking the exam — you simply have more ground to cover in preparation. The certification is valid for three years, and passing the AWS Certified DevOps Engineer – Professional (DOP-C02) exam later will renew it automatically, which matters if you are treating this exam as the first step on a developer-to-DevOps track. If you are still weighing that progression, our comparison of the AWS Developer and DevOps Engineer certifications covers the decision in one place.

One deliberate omission here: this guide does not reproduce the exam's domain list and weightings. AWS publishes the authoritative domain breakdown in the official DVA-C02 exam guide on its Certified Developer – Associate page, and that document should be the first thing you download — treat it as your syllabus, and check it rather than any third-party summary, since AWS revises exam guides over time.

Start with a skills inventory, not a video course

Most candidates begin by buying a course and watching it front to back. For working developers this wastes the one advantage you have: you already know a large slice of this material from your day job. Spend your first study session doing an honest inventory instead.

Go through the objectives in the official exam guide and sort each line into three buckets:

1. I have built this in production. You have deployed it, broken it, and fixed it. These need review, not study.
2. I have used this but never configured it. Perhaps you call a queue or a database another team set up. These are your highest-value study targets — familiarity makes them quick wins.
3. I have never touched this. These get the most calendar time and must be learned hands-on, not from slides.

A typical back-end developer who works in a single language and deploys through a platform team usually finds their gaps cluster in three places: identity and permissions (how AWS Identity and Access Management policies actually evaluate), deployment tooling (the AWS-native CI/CD services rather than whatever their employer uses), and serverless event plumbing (what invokes what, and what happens when an invocation fails). Front-end and full-stack developers often add a fourth gap: server-side data modelling for DynamoDB, Amazon's managed NoSQL database, which rewards access-pattern thinking that relational habits work against.

The three pillars of DVA-C02 preparation

However the official guide slices its domains, developer-associate preparation in practice organises into three pillars. Build your study plan around them.

Pillar 1: The serverless application core

The exam's centre of gravity is application code running on AWS-managed compute — above all AWS Lambda — and the services an application touches around it. Studying this from documentation alone is a mistake, because the questions tend to describe behaviour you only internalise by causing it. Build a small but real serverless application: an API that accepts requests, writes to DynamoDB, publishes events, and processes them asynchronously.

While building, force yourself into the situations the exam cares about:

• Give a function too little memory or time and watch what a timeout looks like.
• Send it a malformed event and follow where the failure goes when there is no error handling, then add handling and a dead-letter destination and compare.
• Change the function's execution role so a permission is missing, and read the exact error the SDK surfaces.
• Deploy a change badly, then practise rolling back.

Each of these exercises converts an abstract objective into a memory. Multiple-choice questions about failure modes are dramatically easier when you have seen the failure with your own eyes.

Pillar 2: SDKs, credentials and how code talks to AWS

The developer exam differentiates itself from AWS's architect-track exams by caring about the developer's-eye view: the software development kit (SDK) calls, the credential chain, the retry behaviour, the way applications authenticate to services. Sibling questions about whether you should sit this exam or the architect exam are settled in our Solutions Architect vs Developer comparison — but assuming you are here, this pillar is where you should expect the sharpest difference from any architect-oriented study material you may have used before.

Practical drills that pay off:

• Write short scripts in your preferred language's AWS SDK that create, read and delete resources, paying attention to where credentials come from at each step — environment, profile, role.
• Deliberately run code with expired or missing credentials and learn the error signatures.
• Explore how the SDK handles throttling and retries, and where you would tune that behaviour rather than writing your own retry loop.
• Practise the difference between granting your code permissions (roles and policies) and encrypting what it stores and transmits (AWS Key Management Service and service-side encryption options).

If you cannot explain to a colleague how a Lambda function gets the permissions it runs with, you are not ready for this section of the exam — and no amount of question drilling substitutes for closing that gap.

Pillar 3: Deployment pipelines and observability

The third pillar is everything that happens after the code works on your machine: packaging it, shipping it through a continuous integration and continuous delivery (CI/CD) pipeline, releasing it safely, and understanding it in production. Developers whose employers use non-AWS pipeline tooling need to give this pillar real time, because the exam speaks the vocabulary of AWS's own developer tooling.

Set up one end-to-end pipeline for the serverless application you built in Pillar 1, from a source repository through build and automated deployment. Then experiment with release strategy: deploy a change gradually rather than all at once, watch a deployment fail health checks and roll back, and add alarms and structured logging so you can trace a single request through the system. Tracing and log-correlation questions reward candidates who have actually followed a request across service boundaries at least once.