AWS Certified Developer - Associate Exam Guide: What to Study and How to Prepare
AWS Certified Developer - Associate validates practical ability to develop, test, deploy, secure, and debug cloud applications on AWS. It is aimed at people performing a developer role, with AWS recommending at least one year of hands-on application development and maintenance experience. This guide helps you decide whether your current experience matches the target profile, which skills deserve study time, how to use the blueprint, and when you are ready to schedule the exam.
What the certification validates
The certification tests application-focused AWS skills rather than broad architecture ownership. The official DVA-C02 guide centers on developing and optimizing applications, packaging and deploying them through CI/CD workflows, securing code and data, and identifying and resolving application issues.
That scope makes the exam relevant to developers who work with AWS APIs, SDKs, the AWS Command Line Interface, managed services, deployment tools, and application monitoring. It is an Associate-level certification for a specific technical role, not a general introduction to AWS Cloud.
A useful way to interpret the credential is as evidence that you can make informed implementation choices inside an existing cloud application. You should be able to select an appropriate service integration, apply permissions, move code through a delivery process, and investigate a malfunction using the evidence available from logs, metrics, traces, and service behavior.
Who should use this guide
Use this guide if you write or maintain application code on AWS, support deployments, or troubleshoot integrations between application components and AWS services. It also suits developers moving from another cloud or from on-premises development who need to map familiar programming and delivery practices to AWS services.
The exam guide describes a target candidate with 1 or more years of hands-on experience developing and maintaining applications using AWS services. That is a recommendation about the intended profile, not a substitute for checking the current registration rules in your AWS Certification Account.
If you have programming experience but little AWS practice, treat the exam as a practical cloud-development project rather than a terminology quiz. If you already use Lambda, DynamoDB, S3, IAM, API Gateway, or AWS developer tools, use the domain tasks to find gaps instead of studying every AWS service equally.
What is outside the target role
The official guide distinguishes developer work from several neighboring responsibilities. It does not expect the target candidate to design distributed architectures, design and create CI/CD pipelines, administer IAM users and groups, administer servers and operating systems, or design AWS networking infrastructure.
This boundary should change your preparation. Learn how to use a pipeline and understand deployment behavior, but do not make pipeline architecture the center of your plan. Learn how application permissions work, but do not turn the exam into an IAM administration course.
Architecture can still appear as application context. For example, a question may require you to choose how code accesses a database or how a deployment behaves behind an API. The relevant decision is usually the developer’s implementation, security, or troubleshooting choice rather than an invitation to design an entire enterprise platform.
Exam format and scheduling facts
The supplied AWS exam guide describes 65 multiple-choice or multiple-response questions, including 50 questions that affect your score and 15 unscored questions. The unscored questions are not identified, so treat every item as consequential while you work through the exam.
AWS reports results as a scaled score of 100–1,000, and the minimum passing score is 720. AWS also states that unanswered questions are scored as incorrect and that there is no penalty for guessing. These facts support a simple exam tactic: select the best available answer for every item before time expires.
AWS lists 130 minutes for the exam. That is enough to require pacing, especially when a scenario contains several plausible service choices. Do not build a plan around identifying which questions are unscored; you cannot reliably do that during the test.
Question types require different reading habits
A multiple-choice question has one correct response and three incorrect responses. A multiple-response question has two or more correct responses out of five or more options. Read the instruction before evaluating the options, because selecting only one valid action is incomplete when the question asks for multiple responses.
For every scenario, identify the requested outcome first: lowest operational effort, strongest security, a particular deployment behavior, a specific failure diagnosis, or another stated constraint. Then eliminate options that solve a different problem, require out-of-scope administration, or introduce a permission, latency, or reliability issue that the scenario does not allow.
Do not choose an answer merely because the named service is familiar. Compare the service’s behavior with the application requirement. A correct option normally explains both what the developer must configure and why that configuration satisfies the stated constraint.
Delivery options and language availability
AWS lists Pearson VUE testing centers and online-proctored testing as available options for this exam. AWS says appointments can be scheduled through an AWS Certification Account with Pearson VUE, and most online-proctored appointments are available 24 hours a day, seven days a week.
AWS lists English, Japanese, Korean, Brazilian Portuguese, Simplified Chinese, and Latin American Spanish as exam languages. Availability and appointment details can change, so confirm the current choices, policies, identification requirements, and testing conditions in the official scheduling flow before paying or selecting a date.
Choose a test-center appointment if your home environment may create technical or privacy problems. Choose online proctoring only after checking the current system requirements and room rules. The practical decision is not which method sounds easier; it is which method lets you concentrate without avoidable setup risk.
Check the current official guide before booking
AWS states that exam guides are periodically reviewed and revised and that revisions are published at least one month before changes are reflected on an exam. The supplied documentation is for DVA-C02, while the AWS exam-guide index also references a DVA-C03 guide, so verify the active exam version in the official AWS Certification pages before scheduling.
Use the current guide as the authority for the blueprint, services, delivery information, and any revision notice. Do not assume that an older practice question set, course, or service list represents the version attached to your appointment.
A sensible final check is to open the exam guide, the in-scope service page, and the scheduling page in the same study session. Confirm the exam code, current content outline, language, appointment option, and policies. This prevents a preparation plan built around a superseded version.
How the blueprint should control study time
The DVA-C02 exam guide identifies four content domains. Content Domain 1: Development with AWS Services accounts for 32% of scored content; Content Domain 2: Security accounts for 26% of scored content; Content Domain 3: Deployment accounts for 24% of scored content; and Content Domain 4: Troubleshooting and Optimization accounts for 18% of scored content.
Treat the percentages as allocation signals, not as a promise about the exact number of questions you will see. Study all four domains, but give the largest deliberate practice block to Development with AWS Services, followed by Security and Deployment. Keep Troubleshooting and Optimization active throughout the plan rather than leaving it as a final chapter.
Section-level feedback should be interpreted cautiously. A domain percentage does not tell you whether a particular service will appear, and a practice score is not the AWS scaled score. Use the blueprint to organize learning and use targeted review to correct weak capabilities.
Content Domain 1: Development with AWS Services
Content Domain 1: Development with AWS Services accounts for 32% of scored content, making it the largest domain. Prepare to reason about application interactions with AWS services, including data access, event-driven behavior, API integration, caching, and application configuration.
Build service comparisons around developer decisions. For a data requirement, distinguish the access pattern and operational behavior of DynamoDB, RDS or Aurora, ElastiCache, and S3 rather than memorizing isolated definitions. For an asynchronous workflow, compare SQS, SNS, EventBridge, and Step Functions by message or event behavior and workflow needs.
Practice writing small integrations with an SDK or the AWS CLI. Your goal is not to memorize every parameter. It is to understand how an application authenticates, calls a service, handles responses and errors, and uses configuration without embedding sensitive values in source code.
The in-scope service list includes Lambda, API Gateway, DynamoDB, S3, ECS, EKS, ECR, CloudFront, CloudWatch, X-Ray, AppConfig, CDK, CloudFormation, and other services. Use the official list as a map, then follow the domain tasks and service references to decide which behaviors deserve deeper work.
Content Domain 2: Security
Content Domain 2: Security accounts for 26% of scored content. Study security as an application implementation responsibility: permissions, temporary access, encryption, secrets, identity propagation, protected endpoints, and safe handling of data in code and configuration.
Know the difference between an identity-based permission and a resource-based permission, and be able to reason about which principal is making a request. Review IAM roles and policies, AWS STS, KMS, Secrets Manager, Cognito, API Gateway authorization, and WAF in the context of an application rather than as separate product chapters.
A strong study exercise is to trace one request from a client to an API, compute component, and data store. At each hop, write down the identity, permission policy, encrypted material or secret involved, and the likely failure evidence. This turns security into a repeatable diagnostic process.
Avoid the common mistake of granting broad permissions to make a sample application work. During practice, use the narrowest permission that meets the stated action and resource requirement. Also distinguish storing a secret from encrypting ordinary application data; the correct AWS service depends on the problem described.
Content Domain 3: Deployment
Content Domain 3: Deployment accounts for 24% of scored content. Focus on packaging application artifacts, configuring build and release stages, deploying to AWS compute services, managing versions, and recognizing how a change moves from source to a running application.
Review the roles of CodeCommit where relevant to the current guide, CodeArtifact, CodeBuild, CodeDeploy, CodePipeline, CloudFormation, CDK, Elastic Beanstalk, Lambda, ECS, and ECR according to the official scope and domain material. The key is to connect each tool to a lifecycle step rather than memorizing a list of product names.
Create a simple delivery flow on paper or in a sandbox: source or artifact, build, test, package, deploy, configuration, and rollback or version selection. Mark where permissions are evaluated and where logs are produced. Then change one assumption, such as the deployment target or artifact type, and explain what else must change.
The guide’s out-of-scope note matters here. You should understand how to use and troubleshoot a CI/CD pipeline, but preparation should not drift into designing a full pipeline platform. Concentrate on application packaging, deployment configuration, release behavior, and the evidence needed when a stage fails.
Content Domain 4: Troubleshooting and Optimization
Content Domain 4: Troubleshooting and Optimization accounts for 18% of scored content. It is smaller by weighting, but it tests whether you can connect symptoms to application configuration, permissions, service limits, logs, metrics, traces, and inefficient implementation choices.
Use CloudWatch, CloudTrail, and X-Ray as evidence sources with different purposes. Ask what each record can actually prove, which component generated it, and whether the timeline matches the reported failure. Include application logs and service response codes in the same investigation instead of treating monitoring tools as interchangeable.
Practice a structured diagnosis: reproduce or characterize the symptom, identify the failing boundary, inspect the most relevant evidence, form one likely cause, test the least disruptive correction, and verify the result. This method is more useful than memorizing a collection of isolated error messages.
Optimization questions may involve performance, reliability, or cost-sensitive implementation choices. Read the constraint carefully. A solution that is faster may not be the least expensive; a solution that removes manual work may alter delivery safety. Choose only what the question asks you to optimize.
Which AWS services deserve hands-on priority
Prioritize services that appear repeatedly in developer workflows and connect several domains. Lambda, API Gateway, DynamoDB, S3, IAM, CloudWatch, CodeBuild, CodeDeploy, CodePipeline, and common messaging services provide useful practice surfaces for development, security, deployment, and troubleshooting.
The official in-scope page organizes services into Analytics, Application Integration, Compute, Containers, Database, Developer Tools, Management and Governance, Networking and Content Delivery, Security, Identity, and Compliance, and Storage. It explicitly says the list is non-exhaustive and subject to change, so use it as a current boundary rather than a permanent catalog.
A practical lab need not be large. Build a small API that invokes a function, reads or writes data, stores an object, emits a message, and records logs. Add a deployment step, restrict the execution role, move a configuration value out of the code, and deliberately introduce a permission or environment-variable error. Each change creates a concrete troubleshooting question.
Study services by decision pairs
Pair services by the decision a question asks you to make. Compare SQS with SNS and EventBridge for asynchronous integration; DynamoDB with relational services for data access patterns; Lambda with containers for execution and packaging; Secrets Manager with configuration services for sensitive versus non-sensitive values; and CloudWatch with X-Ray for operational evidence.
For each pair, write four notes: the problem each service solves, the application interface, the operational responsibility left to the developer, and one reason an option would be unsuitable. This format exposes confusion more effectively than a glossary because it forces you to identify boundaries.
Keep a service matrix, but do not turn it into a list of unsupported promises. Record only behavior you have verified in the current AWS documentation or observed in a controlled lab. When a feature or limit is time-sensitive, return to the official source rather than relying on an old note.
Use the official service list correctly
The in-scope page is valuable for preventing accidental omission, but it is not a demand to master every service equally. Start with the services attached to your weakest domain tasks, then scan the remaining categories for unfamiliar names and learn their primary developer-facing purpose.
A service appearing in scope does not mean every feature is equally likely or that a question will test detailed administration. Read the exam guide’s task statements and service references alongside the list. Your notes should answer what a developer needs to choose, configure, call, secure, deploy, or troubleshoot.
Recheck the list near the end of preparation because AWS states that it is subject to change. This is especially important if your study materials were created substantially earlier than your appointment.
A preparation method that produces usable evidence
Start with a diagnostic, not a full course replay. Read the domain tasks, mark each capability as confident, familiar, or unknown, and complete a small set of scenario questions without looking up answers. For every miss, record the misunderstood requirement and the AWS behavior that resolves it.
Use a three-part study loop: learn the behavior, implement or inspect it, and explain the decision in writing. A service definition may tell you what a product does, but a short lab reveals permissions, configuration, response handling, packaging, and logs—the details that make scenario answers distinguishable.
Separate knowledge gaps from reading errors. If you knew the service but missed the requirement, practice extracting constraints. If you chose an unsuitable service, study a comparison. If you understood the solution but forgot a configuration detail, perform the task again and keep a concise reference note.
Build a decision log after every practice item
A decision log should capture the scenario’s required outcome, the decisive constraint, the selected service or configuration, why the strongest distractor fails, and the source used to verify the reasoning. This converts practice questions into reusable judgment instead of a collection of remembered answer patterns.
Do not copy question wording or attempt to memorize answer positions. Practice material is useful when it teaches a transferable behavior: how a role is assumed, how a deployment artifact is formed, how an event is delivered, or how a failed request is traced.
Review the log by error category. Useful categories include identity and permissions, event semantics, data access, deployment packaging, configuration, observability, and requirement extraction. A repeated category should change the next lab or reading assignment.
Use labs with a deliberately narrow objective
A lab should answer one question. Examples include whether a function can access a particular resource under its execution role, how an API passes input to a function, how a deployment selects a version, or which log and trace records appear when a request fails.
Keep the implementation small enough that you can explain every resource and permission. Delete or secure temporary resources after practice and avoid copying credentials into source files. The purpose is exam readiness and sound development habits, not a production claim about the design.
After the successful path works, test one failure path. Remove a required permission, change a configuration value, send an invalid request, or deploy an incompatible artifact. Observe the resulting evidence and write the shortest reliable diagnosis.
Read scenarios for constraints before services
The most attractive distractor often names a real AWS service but violates a stated condition. Underline constraints such as minimal code changes, asynchronous processing, least privilege, encryption, automatic rollback, low operational effort, a particular runtime, or a required deployment target.
Then identify the action the developer must take. Is the question asking for a policy, a code change, an SDK call, a build setting, a deployment configuration, a monitoring query, or a service selection? This prevents answering a nearby architecture question instead of the one presented.
For multiple-response items, test each option independently against every requirement. Do not select an option because it is generally good practice if it does not solve the stated problem.
A practical study roadmap
A flexible roadmap is more useful than an arbitrary calendar. Move through orientation, core development, security, deployment, troubleshooting, and final validation in that order, while revisiting earlier topics through mixed scenarios. Increase hands-on work when you lack AWS experience and increase timed reasoning when your implementation knowledge is already strong.
Keep the official blueprint beside your plan. At the end of each phase, produce evidence: a working integration, a service comparison, a secured configuration, a deployment trace, or a written diagnosis. If you cannot produce that evidence without copying a recipe, the topic needs another pass.
Phase 1: Establish the baseline
Begin by confirming that you are studying the active exam guide and identifying the four domains and their task statements. Inventory your experience with a high-level programming language, application lifecycle management, AWS APIs, SDKs, the AWS CLI, and CI/CD deployment.
Next, create a gap table with one row per task or capability. Mark whether your evidence comes from work, a lab, or only reading. Give priority to items supported by no practical evidence, especially where your experience is limited to one AWS service or one deployment style.
Finish this phase with a small diagnostic set. Review every answer, including correct guesses. Your result is not a readiness score; it is a map of what to study and which assumptions need verification.
Phase 2: Build the application path
Study development services through one application path: request entry, compute, data, object storage, asynchronous integration, configuration, and observability. Implement the path with an SDK or CLI, then explain the purpose and trade-off of each component.
For each service, connect the code to the required permission and the expected operational evidence. Test valid and invalid input, a missing resource, and a service response that the application must handle. Keep notes on behavior, not just commands.
At the end of this phase, you should be able to select a service from a requirement and describe how the application calls it, how access is granted, and how you would detect a failure.
Phase 3: Add security deliberately
Review IAM roles and policies, temporary credentials, KMS, Secrets Manager, Cognito, API authorization, and protection at the application boundary. Apply least privilege to the project from Phase 2 rather than studying security as an unrelated vocabulary list.
Trace identities through each request. Ask whether the caller is a user, workload, or AWS service; where credentials come from; what policy permits the action; and where sensitive values are stored. Verify encryption and secret retrieval using the current service documentation.
Create several short security diagnoses: an absent action, an incorrect resource, an untrusted principal, an expired or unavailable secret, and an authorization failure at an API boundary. Write the evidence that would distinguish each cause.
Phase 4: Package and deploy
Take the same application through a build and deployment workflow. Identify the source or artifact, build commands, test output, packaged files, deployment target, runtime configuration, execution role, and release or version behavior.
Study deployment tools by function. CodeBuild handles build activity, CodeDeploy handles supported deployment behavior, CodePipeline coordinates stages, CloudFormation and CDK represent infrastructure, and ECR supports container images. Confirm the details for the current exam version and avoid assuming that similarly named tools perform the same step.
Break the workflow intentionally. Use a missing dependency, an incorrect artifact path, a denied deployment action, or a mismatched runtime. Follow the failure from the pipeline stage to its logs and state the smallest correction that addresses the cause.
Phase 5: Troubleshoot and optimize
Use mixed failures rather than isolated flashcards. Combine an application error with a permission issue, a deployment failure with a packaging issue, or a slow request with an inefficient data access pattern. Your task is to locate the failing boundary before choosing a remedy.
Review the evidence chain across application logs, CloudWatch metrics and logs, CloudTrail records, X-Ray traces, and service-specific responses. For every tool, note the question it can answer and the question it cannot. This guards against choosing an observability product simply because it appears in an option.
Finish with a written optimization review. For each proposed change, state what improves, what new responsibility or risk appears, and whether the scenario actually requires that trade-off.
Phase 6: Validate readiness and schedule
Before scheduling, complete a final review against the current official domain tasks and service list. Use mixed practice under the official time allowance, but interpret results diagnostically rather than treating an unofficial percentage as a guarantee.
You are closer to ready when you can explain why each answer is correct, reject plausible distractors using the scenario’s constraints, and troubleshoot a small AWS application without following a step-by-step script. Revisit any domain in which your reasoning depends on memorized wording.
When the scope is stable and your scheduling conditions are suitable, use the AWS Certification Account and Pearson VUE process to choose a testing center or online-proctored appointment. Recheck language, appointment rules, identity requirements, and the current exam code immediately before booking.
Common preparation mistakes to avoid
The most damaging mistakes are not usually a lack of service names. They are studying the wrong exam version, confusing developer tasks with architecture or administration, memorizing answer patterns, ignoring security until the end, and practicing successful deployments without learning how failures appear.
Correct these mistakes by tying every study activity to an official domain task and a concrete implementation decision. If a topic cannot be connected to code, configuration, deployment, permissions, or diagnostic evidence, confirm that it belongs in the current guide before spending more time on it.
Mistake: treating the service list as a syllabus
The in-scope list is non-exhaustive and subject to change, and it does not assign equal depth to every service. Reading product summaries from top to bottom can create wide recognition without the ability to choose or troubleshoot an implementation.
Use the list to find omissions, then prioritize according to domain tasks, your experience, and recurring application patterns. Learn a service deeply enough to explain its developer interface and boundaries before adding another unfamiliar name.
Mistake: confusing use with design
The target role is expected to use APIs, SDKs, the AWS CLI, and CI/CD pipelines, while several architecture and administration activities are explicitly out of scope. Spending most of your time designing VPCs or administering operating systems can leave the tested developer skills underprepared.
When a scenario includes infrastructure context, ask what action the developer must take. Focus on application code, permissions, packaging, configuration, deployment behavior, and evidence rather than designing an entire platform.
Mistake: relying on recalled questions
Memorized or unauthorized question material cannot teach you how to handle changed wording, a different service combination, or an unfamiliar constraint. It also encourages answer-pattern recognition instead of technical judgment.
Use legitimate study material and original practice scenarios to explain behavior. Never assume that dumps, leaked questions, or memorization guarantee a passing result. A reliable preparation plan makes you capable of solving a new scenario without access to live exam content.
Mistake: leaving troubleshooting until the final session
Troubleshooting depends on knowledge built in every other domain. You cannot diagnose a deployment issue if you do not understand packaging, or a permission failure if you have not traced application identities and resource access.
Add one failure exercise to each lab. This creates a steady habit of reading evidence, locating the failing boundary, and choosing a correction based on the stated objective.
Mistake: reading the score report too literally
AWS advises caution when interpreting section-level feedback. Domain feedback can indicate where review is useful, but it should not be treated as a direct percentage of questions answered or as a precise diagnosis of every knowledge gap.
If you need another attempt, return to the task statements and rebuild evidence in the weak areas. Review the active guide first, then use your previous experience to choose targeted labs rather than repeating the same broad course unchanged.
What to do in the final week
Use the final week for consolidation, not uncontrolled expansion. Recheck the current guide, repair the two or three most consequential gaps, run a small number of mixed scenarios, and rehearse your pacing and review method. Avoid replacing hands-on reasoning with last-minute memorization.
Prepare a one-page personal reference organized by decisions: identity and secret handling, event and data choices, packaging and deployment, and diagnostic evidence. Keep it for study only and verify each entry against current official documentation when the detail may have changed.
Confirm the appointment details through the official scheduling process. For online proctoring, check the current technical and room requirements early enough to resolve problems. For a test center, verify location and arrival instructions. These are scheduling safeguards, not substitutes for technical preparation.
A simple question workflow
Read the final sentence first to identify the requested outcome, then extract the application context and constraints. Classify the item as development, security, deployment, or troubleshooting, while remembering that a scenario may combine domains.
Eliminate answers that solve a different requirement or require capabilities outside the target role. Compare the remaining options by service behavior, permissions, operational effort, and evidence. For multiple response, validate every selected option independently.
Mark a difficult item and continue if it is consuming disproportionate time. Return later with the remaining context fresh, but do not leave an item unanswered because AWS states that unanswered questions are scored as incorrect and there is no penalty for guessing.
A readiness check based on capability
You are ready to schedule when you can demonstrate, without copying a recipe, that you can build a small AWS integration, secure its access and sensitive configuration, package and deploy it through a delivery workflow, and diagnose an intentional failure.
You should also be able to explain the reason behind a choice in plain language. If your explanation is only “that is the service used for this question,” replace the memorized association with a comparison based on the requirement and service behavior.
Finally, verify administrative details separately from readiness. Confirm the active exam version, current languages and delivery options, appointment conditions, and official policies in AWS sources because these details can change independently of your technical study progress.
Recommended next actions
Open the current AWS exam guide and highlight every task you cannot support with an implementation or troubleshooting example. Then compare that list with the official in-scope service page and select a small project that crosses development, security, deployment, and troubleshooting.
Build the project in stages, record each decision, and introduce one controlled failure after each successful stage. Use the official documentation to verify behavior, not recollection or unauthorized exam material. At the end of each study session, update your gap table and choose the next task based on evidence rather than anxiety.
When your gaps are narrow and your mixed practice shows consistent reasoning, review the official scheduling page and book the delivery option that matches your environment. Keep checking the current AWS guide for revisions until the appointment, especially if your preparation spans a long period.
Conclusion
AWS Certified Developer - Associate preparation is strongest when it mirrors the work the exam describes: develop an integration, secure it, move it through delivery, and investigate what happens when it fails. Use the DVA-C02 domain outline and official service list to set boundaries, but let hands-on evidence and scenario reasoning determine readiness. Confirm the active exam version and scheduling details with AWS before booking, then spend the final review period correcting specific gaps rather than collecting more disconnected service facts.
