AWS DVA-C02 Study Plan: Lambda, Eventing, and Troubleshooting in 30, 60, and 90 Days

AWS DVA-C02 30-, 60-, and 90-day study plan for Lambda, eventing, troubleshooting, review loops, and final-week priorities.

Use this study plan when you want a structured route through AWS Certified Developer - Associate (DVA-C02) instead of jumping between Lambda facts, IAM snippets, and deployment tools. DVA-C02 is a developer implementation exam. It tests whether you can develop, secure, deploy, debug, and optimize AWS cloud-based applications.

AWS’s current exam guide keeps DVA-C02 in the developer lane. You need application lifecycle judgment, at least one high-level programming language, AWS CLI/SDK familiarity, CI/CD workflow awareness, and the ability to resolve application issues. You do not need to design enterprise architectures, administer IAM users and groups, administer servers, or design VPC infrastructure.

Current exam facts

I verified these current AWS exam facts on May 16, 2026.

Item Value
Exam AWS Certified Developer - Associate
Exam code DVA-C02
Category Associate
Questions 65 total
Scoring 50 scored + 15 unscored (unscored items are not identified)
Question types Multiple choice and multiple response
Time 130 minutes
Passing score 720, scaled 100-1000
Cost 150 USD
Target candidate 1 or more years developing and maintaining applications with AWS services

AWS also notes that exam guides are periodically revised. Recheck the official guide before scheduling, especially for service-scope and short-name changes.

Weight-driven study allocation

Domain Weight How to allocate study time
Development with AWS Services 32% Spend the most time on application patterns, APIs, messaging, Lambda behavior, event sources, SDK usage, DynamoDB, caching, and data-store fit.
Security 26% Drill IAM roles, authentication, authorization, KMS, TLS, secrets, masking, sensitive data, and tenant-safe access.
Deployment 24% Study packaging, dependencies, repositories, environment config, test environments, IaC, approved versions, CI/CD, canary, and rollback.
Troubleshooting and Optimization 18% Practice evidence-first debugging, logs, metrics, traces, custom metrics, health checks, concurrency, caching, filtering, and tuning.

The weights are close enough that every domain matters. Most difficult DVA-C02 questions combine two lanes: Lambda plus IAM, DynamoDB plus caching, deployment plus rollback evidence, or observability plus performance tuning.

Pick the right timeline

Starting point Typical study time Best-fit timeline
You build AWS serverless or backend apps today 45-70 hours 30-60 days
You are a developer with AWS exposure but limited production depth 70-100 hours 60 days
You know AWS basics but not application deployment/debugging 90-120 hours 60-90 days
You are new to both AWS and cloud application development 120+ hours 90 days before scheduling

Choose the longer route if you still guess at Lambda retry behavior, IAM role boundaries, KMS access failures, DynamoDB key design, deployment rollback strategy, or which observability signal proves the cause.

The DVA-C02 study loop

Use one loop every week. DVA-C02 rewards narrow, evidence-based application decisions.

    flowchart LR
	  S["Scenario"] --> P["Pattern"]
	  P --> C["Code or config"]
	  C --> A["Access and secrets"]
	  A --> D["Deploy safely"]
	  D --> O["Observe and debug"]
	  O --> M["Miss rule"]
Step What to ask
Scenario Is the problem development, security, deployment, troubleshooting, or optimization?
Pattern Is the application synchronous, asynchronous, event-driven, streaming, cached, or stateful?
Code or config Is the fix in handler logic, timeout, memory, environment config, data access, or SDK behavior?
Access and secrets Which identity, permission, KMS key, secret, token, or tenant boundary controls the request?
Deploy safely What package, version, stage, alias, canary, rollback, or test environment reduces blast radius?
Observe and debug Which metric, log, trace, custom metric, alert, or health check proves the cause?

Minimum implementation baseline

You do not need a large lab, but you should be able to explain these paths without guessing:

Path What you should know
API to Lambda API Gateway or another event source, handler behavior, timeout, memory, errors, logs, and response shape
Async Lambda Retry behavior, DLQ or destination, idempotency, duplicate handling, and failure visibility
Lambda to DynamoDB Partition key, query vs scan, consistency, throttling, IAM role, and data serialization
App security Authentication, authorization, runtime role, signed AWS requests, KMS, TLS, secrets, and log masking
Deployment Artifact packaging, environment config, test events, IaC, approved versions, canary, alias, and rollback
Troubleshooting CloudWatch Logs, metrics, X-Ray traces, custom metrics, alarms, release context, and bottleneck isolation

30-day intensive plan

Use this route only if you already have development experience and can study most days.

Week Focus What to produce
1 Development with AWS services A service-pattern chooser for API Gateway, Lambda, SQS, SNS, EventBridge, Step Functions, DynamoDB, SDK calls, and resilient integrations.
2 Security An access checklist covering IAM roles, Cognito or federation, signed requests, KMS, TLS, Secrets Manager, Parameter Store, masking, and tenant boundaries.
3 Deployment A release-safety map covering artifacts, dependencies, config, test stages, IaC, approved versions, CI/CD, aliases, canaries, and rollback triggers.
4 Troubleshooting and mixed review A debugging runbook covering symptom, signal, cause, narrow fix, validation, and follow-up optimization.

30-day rule

Every day should create one reusable artifact.

Artifact Why it matters
Event-flow sketch Forces you to separate synchronous calls, async queues, fanout, orchestration, retries, and idempotency.
Permission path Keeps caller identity, execution role, resource policy, KMS key access, and secret access separate.
Deployment checklist Prevents treating CI/CD as just “push code” instead of package, test, promote, observe, and roll back.
Evidence map Converts troubleshooting guesses into metric, log, trace, deployment event, or health-check evidence.
Miss log Turns repeated mistakes into one-line developer rules.

60-day balanced plan

This is the best default route for most candidates.

Weeks Focus What to do
1-2 Development with AWS Services Drill application patterns, APIs, SDK use, messaging, Lambda configuration, event behavior, VPC access, errors, DynamoDB, consistency, caching, and data-store decisions.
3-4 Security Practice authentication, authorization, IAM roles, federated access, KMS, TLS, secrets, sensitive data, masking, and multi-tenant access.
5-6 Deployment Study packaging, repositories, dependencies, environment config, testing, IaC, approved versions, CI/CD, staged deployments, runtime config, and rollback.
7 Troubleshooting and Optimization Drill metrics, logs, traces, structured logging, custom metrics, health checks, concurrency, caching, messaging filters, and bottlenecks.
8 Mixed practice and final repair Run timed sets, group misses by lane, review the cheat sheet, answer sample questions, and schedule only if misses are narrow.

90-day part-time plan

Use this route if you are building AWS developer depth while studying.

Phase Weeks Outcome
Application patterns 1-3 You can choose APIs, queues, topics, event buses, workflows, Lambda behavior, and data access patterns by requirement.
Security implementation 4-5 You can secure application calls with roles, tokens, KMS, TLS, secrets, masking, and tenant-aware authorization.
Deployment discipline 6-8 You can package, configure, test, promote, and roll back application releases with low blast radius.
Troubleshooting and optimization 9-10 You can isolate failures with logs, metrics, traces, health checks, release context, concurrency, cache, and filter evidence.
Mixed exam execution 11-12 You can answer mixed questions under time pressure and explain repeated misses as developer decision rules.

What to drill by domain

Domain Drill questions until you can answer…
Development with AWS Services What application pattern, Lambda behavior, data access shape, or managed integration fits the requirement?
Security Which identity, authorization layer, encryption control, secret mechanism, or sensitive-data boundary controls the risk?
Deployment What artifact, environment, test, IaC, pipeline, stage, alias, canary, or rollback choice reduces release risk?
Troubleshooting and Optimization Which evidence source proves the cause, and what is the narrowest useful performance or reliability fix?

High-yield developer comparisons

Decision Choose by asking…
SQS vs SNS vs EventBridge Is the requirement buffering, fanout notification, or event routing/filtering between producers and consumers?
Step Functions vs EventBridge Is the need explicit workflow state and retries, or loosely coupled event routing?
Sync Lambda vs async Lambda Does the caller need an immediate response, or can work be retried and completed later?
DLQ vs destination Do you need failed-event capture, or success/failure routing with execution result context?
DynamoDB query vs scan Do you know the key access pattern, or are you reading broadly and expensively?
Strong vs eventual consistency Does the application need the latest committed value, or is lower-latency/lower-cost eventual read acceptable?
Secrets Manager vs Parameter Store Is the value a secret with rotation and secret-management needs, or configuration/parameter data?
Alias/canary vs all-at-once release Do you need traffic shifting and rollback safety, or is one-shot replacement acceptable?
Logs vs metrics vs traces Do you need event detail, numeric signal/alarm, or request-path timing and dependency visibility?

Out-of-scope guardrails

Do not turn DVA-C02 into the wrong exam.

Do not over-study… Learn this instead
Full architecture design Application behavior, managed integrations, and developer-visible trade-offs
CI/CD platform design from scratch How developer releases use pipelines, artifacts, tests, stages, versions, and rollback
IAM user/group administration Runtime roles, temporary credentials, app authorization, and least-privilege access
Server and OS administration Serverless/application runtime behavior, logs, metrics, config, and deployment output
Deep VPC architecture What a developer needs for private access, VPC-connected Lambda, endpoints, and connectivity symptoms

Final-week checklist

Use the final week for cross-domain implementation speed.

Day Work
7 days out Reread the cheat sheet and summarize each domain as one developer decision problem.
6 days out Drill development: Lambda, APIs, SQS, SNS, EventBridge, Step Functions, SDKs, DynamoDB, consistency, and caching.
5 days out Drill security: IAM roles, federation, tokens, KMS, TLS, secrets, masking, tenant boundaries, and AccessDenied reasoning.
4 days out Drill deployment: packaging, config, testing, IaC, approved versions, CI/CD, aliases, canaries, and rollback.
3 days out Drill troubleshooting: logs, metrics, traces, custom metrics, health checks, concurrency, caching, and bottleneck isolation.
2 days out Run one mixed timed block and convert repeated misses into one-line developer rules.
1 day out Review only weak rules, domain weights, current facts, high-yield comparisons, and exam logistics.

Readiness signals

You are close to ready when:

  • You can classify a scenario into development, security, deployment, or troubleshooting before reading every answer.
  • You can explain Lambda retry, timeout, concurrency, event-source, and failure-routing behavior without guessing.
  • You can separate application authentication, authorization, execution role, resource policy, KMS, and secrets access.
  • You can choose a rollout or rollback strategy by blast radius and evidence, not by tool familiarity.
  • You can start debugging from logs, metrics, traces, deployment output, or health checks before changing capacity.
  • You can keep a steady pace across 65 questions in 130 minutes.

If you only have 48 hours

This is only reasonable if you are already near-ready.

  1. Read the cheat sheet twice: once before practice and once after reviewing misses.
  2. Drill one mixed timed block and classify every miss by domain.
  3. Spend one focused block on Lambda/eventing/DynamoDB and one on IAM/KMS/secrets.
  4. Review deployment rollback, aliases, canaries, stages, environment config, logs, metrics, traces, concurrency, caching, and high-yield comparisons.
  5. Recheck the current official AWS page before scheduling or buying an exam attempt.

Booking signal

Schedule only when your misses are narrow and explainable. If you still pick answers by familiar service name instead of application pattern, permission boundary, release safety, or evidence source, keep studying. DVA-C02 rewards developer implementation judgment under time pressure.

Revised on Monday, June 15, 2026