AWS Developer Associate Guide: DVA-C02 Exam Breakdown and Preparation

The AWS Certified Developer – Associate (DVA-C02) is designed for engineers who build and deploy applications on AWS. Where the Solutions Architect Associate focuses on designing complete infrastructure architectures, the Developer Associate goes deeper into the services, APIs, and patterns that application developers use day to day.

If your work involves writing code that runs on AWS — Lambda functions, containerised applications, serverless APIs, message-driven systems — this certification is more directly relevant to what you do than the Solutions Architect.

How it differs from the Solutions Architect Associate#

The two certifications share a significant amount of content — both cover core AWS services, security, IAM, and deployment concepts. But they have different angles:

The Developer Associate rewards engineers who actually write and ship code to AWS. The scenario questions assume you are implementing a feature, not designing a multi-region architecture.

Exam details#

Format: 65 questions (multiple choice and multiple response), 130 minutes, passing score approximately 720/1000, approximately $150, valid 3 years.

Domains and weightings:

Key topics to know well#

Lambda — in real depth#

Lambda is the heaviest topic in this exam and where engineers who have not worked with serverless get caught out.

Know specifically:

• Deployment packages and layers: when to use layers, how to manage dependencies
• Versions and aliases: how to use them for deployment rollouts and blue/green
• Concurrency: reserved vs provisioned concurrency, how throttling works
• Execution environment: memory, timeout (max 15 minutes), tmp storage (512MB default, up to 10GB)
• Event source mappings: how SQS, Kinesis, and DynamoDB Streams trigger Lambda
• Environment variables and parameter passing
• Cold starts: what causes them, how to mitigate them with provisioned concurrency

DynamoDB — beyond the basics#

The Developer Associate tests DynamoDB at a practical development level:

• Partition keys and sort keys: how to design for your access patterns
• Global secondary indexes (GSIs) and local secondary indexes (LSIs): when to use each
• Query vs Scan: why Scan is expensive and when you have no choice
• Conditional writes: using ConditionExpression to prevent overwrites
• DynamoDB Streams: use cases, event format, integration with Lambda
• TTL: how to expire items automatically
• Transactions: TransactWriteItems for atomic multi-table operations
• DAX (DynamoDB Accelerator): caching layer, when to use it

API Gateway#

• REST APIs vs HTTP APIs vs WebSocket APIs: the trade-offs
• Lambda proxy integration vs non-proxy integration
• Usage plans and API keys
• Caching at the API Gateway level
• Throttling settings and quotas
• Stages and deployment

CI/CD: CodePipeline, CodeBuild, CodeDeploy#

This is where the Developer Associate diverges most from the Solutions Architect:

CodeBuild: What buildspec.yml contains, build phases (install, pre-build, build, post-build), how to store artifacts in S3, environment variables.

CodeDeploy: Deployment types (in-place vs blue/green), AppSpec files, lifecycle event hooks, how to deploy to EC2 vs Lambda vs ECS.

CodePipeline: Stage and action types, source providers (CodeCommit, GitHub, S3), how to connect to CodeBuild and CodeDeploy.

Know the lifecycle hook order for CodeDeploy on EC2: BeforeInstall → AfterInstall → ApplicationStart → ValidateService.

X-Ray for distributed tracing#

X-Ray is frequently tested in the troubleshooting domain:

• How X-Ray tracing works: segments, subsegments, traces
• How to instrument Lambda, EC2, and containers with the X-Ray SDK
• X-Ray groups and sampling rules
• Reading X-Ray service maps to identify latency issues

Elastic Beanstalk#

• Platform as a service: what it manages vs what you control
• Deployment policies: all-at-once, rolling, rolling with additional batch, immutable, traffic splitting
• .ebextensions configuration files
• Environment tiers: web server vs worker

SQS, SNS, and Kinesis — applied patterns#

• SQS visibility timeout: why it matters, what happens if it expires
• Dead-letter queues: configuration and use
• FIFO queues: deduplication IDs, message group IDs, throughput limits
• SNS fan-out pattern with SQS subscriptions
• Kinesis Data Streams: shards, partition keys, GetRecords, Enhanced Fan-Out, iterator types

Security for developers#

• Cognito: user pools vs identity pools, use cases for each
• STS and AssumeRole: how applications get temporary credentials
• AWS Secrets Manager vs Parameter Store: when to use each for application config
• Encryption: encrypting data with KMS in application code, using GenerateDataKey

Who should take this certification#

Take it if:

• Your primary work involves building serverless or containerised applications on AWS
• You work closely with Lambda, API Gateway, DynamoDB, or SQS in your day job
• You have the Solutions Architect Associate and want to deepen your application-layer knowledge
• You are a backend developer transitioning to cloud-native development

Consider the Solutions Architect Associate instead if:

• You are focused on infrastructure design rather than application code
• You are early in your cloud learning and want the most broadly recognised credential

Take both if:

• You want comprehensive AWS coverage and are targeting senior AWS roles
• You are studying systematically and have time for both

Study approach#

The Developer Associate rewards depth over breadth. Rather than trying to memorise every service at surface level, focus on the services that appear most heavily — Lambda, DynamoDB, API Gateway, CI/CD tooling — and understand them thoroughly.

Build the key services: Deploy a Lambda function, connect it to API Gateway, write to DynamoDB, trigger it from SQS, trace it with X-Ray. This practical circuit covers a large proportion of the exam content in a way that makes the questions feel familiar rather than abstract.

Use CodePipeline: Build a working pipeline that deploys a Lambda function through CodeBuild and CodeDeploy. Seeing how the pieces connect is significantly more valuable than reading about them.

Practice exam questions: The DVA-C02 questions have a different feel from Solutions Architect questions — more specific, more code and configuration focused. Use Developer-specific practice exams rather than general AWS practice banks.

Preparation time: 6–10 weeks for most engineers with AWS experience. 8–12 weeks if your background is primarily infrastructure rather than application development.

After the Developer Associate#

The DVA-C02 pairs well with:

• AWS Solutions Architect – Associate for broad platform coverage
• AWS DevOps Engineer – Professional for CI/CD and delivery pipeline depth
• Building serverless applications on GitHub to demonstrate your capability

See the full AWS certifications guide for where this cert fits in the broader AWS path.

Summary#

• The DVA-C02 is the AWS certification for application developers and serverless engineers
• It goes deeper on Lambda, DynamoDB, API Gateway, CodePipeline, CodeDeploy, and X-Ray than the Solutions Architect
• It is more directly relevant to engineers who write code than to those who design infrastructure
• Build the key services hands-on — the exam rewards practical understanding more than memorisation
• 6–10 weeks of focused study is realistic for candidates with AWS development experience