AWS DVA · Domain 1 of 4

AWS DVA Domain 1: Development with AWS Services

This is the largest DVA domain. It covers writing application code that uses AWS, from SDKs and APIs to Lambda functions, DynamoDB and other data stores, messaging, caching and event-driven patterns.

Exam format
32%
Official tasks
3
Assessment estimate
~16
Suggested study time estimate
25–35 hrs

About 11 min read Reviewed October 2026

Overview

Development with AWS Services is the core of the developer certification. It has three tasks. Developing code for applications covers writing resilient, idempotent, stateless code that uses the AWS SDKs and service APIs, messaging with SQS and SNS, and streaming with Kinesis. Developing code for Lambda covers configuring functions (memory, timeout, concurrency, layers, environment variables), accessing VPC resources, handling events and errors with destinations and dead-letter queues, and integrating Lambda with other services. Using data stores covers DynamoDB and its access patterns, caching, data lifecycles, and serialization.

At 32%, this is the heaviest domain and the most hands-on. The exam rewards knowing how to write code that calls AWS correctly: making operations idempotent, choosing DynamoDB keys and indexes, handling Lambda concurrency, and picking the right messaging or caching service. These patterns recur throughout the security, deployment and troubleshooting domains.

How it's tested

DVA-C02 questions are scenario-based and often show a code or integration situation, asking which service, configuration or pattern a developer should use. In this domain they describe an application behavior need and reward the correct SDK usage, Lambda setting, DynamoDB design or messaging choice. Read the behavior required before choosing.

  • Right service for the pattern

    An application behavior is described, and you choose SQS, SNS, Kinesis, DynamoDB or caching to implement it.

  • Lambda configuration

    A function behavior or limit is described, and you choose the memory, timeout, concurrency or error-handling setting.

  • DynamoDB design

    A data access pattern is described, and you choose the partition key, sort key or index.

Reasoning it through

A payment API may receive the same request twice due to client retries, and must not charge twice. Simply processing each request risks double charges. Making the operation idempotent, for example with a unique request token stored in DynamoDB using a conditional write, ensures a repeated request is recognized and not processed again, which is the pattern the exam expects for safe retries.

Tasks 3

Official tasks from the Amazon Web Services outline, in outline order.

1.1 Develop code for applications hosted on AWSSDKs and APIs, idempotency, statelessness, messaging and streaming.
What it means
This covers writing fault-tolerant, resilient application code in a supported language, using idempotency and stateless design, calling AWS services through the SDKs and APIs, using messaging services such as SQS and SNS, and handling streaming data with Kinesis.
What to understand
Idempotency means a repeated operation has the same effect as doing it once, which is essential for safe retries. Stateless design lets requests be handled by any instance and scale horizontally. SQS decouples with a queue, SNS fans out notifications, and Kinesis handles ordered streaming. The SDK handles retries, pagination and credentials.
How it shows up
An application behavior need is described, and you must choose the messaging or streaming service and apply idempotency and statelessness.
Common confusion
Confusing SQS, SNS and Kinesis; SQS is a queue, SNS is pub/sub, and Kinesis is ordered real-time streaming.
1.2 Develop code for AWS LambdaFunction configuration, VPC access, concurrency, events and error handling.
What it means
This covers configuring Lambda functions (memory, timeout, concurrency, runtime, handler, layers, extensions, triggers, destinations), accessing private VPC resources from Lambda, handling the event lifecycle and errors with Lambda Destinations and dead-letter queues, integrating Lambda with other services, and tuning performance.
What to understand
Lambda memory also scales CPU, so raising memory can speed execution. Timeout limits run time. Reserved and provisioned concurrency control scaling and cold starts. Dead-letter queues and destinations capture failed asynchronous events. Accessing VPC resources requires the function to be configured in the VPC with the right networking.
How it shows up
A function behavior or limit is described, and you must choose the memory, timeout, concurrency or error-handling configuration.
Common confusion
Confusing reserved concurrency with provisioned concurrency; reserved caps and guarantees concurrency, while provisioned pre-warms instances to avoid cold starts.
1.3 Use data stores in application developmentDynamoDB access patterns, caching, data lifecycle and serialization.
What it means
This covers using data stores in application code, especially DynamoDB partition and sort keys, secondary indexes, read and write capacity, caching with DAX or ElastiCache, data lifecycle management, serialization and deserialization, and choosing specialized stores by access pattern.
What to understand
DynamoDB performance depends on good key design: the partition key should spread load evenly, and indexes support additional query patterns. DAX caches DynamoDB reads, and ElastiCache caches general data. Choosing the right store and key design for the access pattern is the central skill, since relational and key-value stores suit different needs.
How it shows up
A data access pattern is described, and you must choose the DynamoDB key or index, a caching service, or the right store.
Common confusion
Confusing a global secondary index with a local secondary index; a global secondary index can use a different partition key, while a local secondary index shares the table's partition key.

High-yield concepts

The terms, rules and formulas this domain turns into questions most often.

  • Idempotency

    A repeated operation has the same effect as a single one.

    Remember
    Essential for safe retries, often via a unique token and conditional write.
    Tested as
    Resilience questions.
    Trap
    Processing duplicate requests twice.

  • Stateless design

    Requests carry no server-side session state.

    Remember
    It enables horizontal scaling and resilience.
    Tested as
    Architecture-in-code questions.
    Trap
    Storing session state on the instance.

  • SQS vs. SNS vs. Kinesis

    Queue, pub/sub, and ordered real-time streaming.

    Remember
    Kinesis preserves order and supports replay.
    Tested as
    Messaging questions.
    Trap
    Using SQS where ordered streaming is needed.

  • Lambda memory and CPU

    Memory setting also scales CPU.

    Remember
    More memory can reduce execution time.
    Tested as
    Performance questions.
    Trap
    Tuning CPU separately from memory.

  • Reserved vs. provisioned concurrency

    Reserved caps and guarantees concurrency; provisioned pre-warms instances.

    Remember
    Provisioned concurrency reduces cold starts.
    Tested as
    Lambda scaling questions.
    Trap
    Confusing the two settings.

  • Dead-letter queues and destinations

    Capture failed asynchronous Lambda events for later handling.

    Remember
    They prevent silent loss of failed events.
    Tested as
    Error-handling questions.
    Trap
    Ignoring failed async invocations.

  • Lambda in a VPC

    Configuring a function to access private VPC resources.

    Remember
    It needs subnets and security groups, and for internet access a NAT path.
    Tested as
    Integration questions.
    Trap
    Expecting VPC Lambda to reach the internet without NAT.

  • DynamoDB key design

    Partition key spreads load; sort key orders items within a partition.

    Remember
    A poor partition key causes hot partitions.
    Tested as
    Data store questions.
    Trap
    Choosing a low-cardinality partition key.

  • Global vs. local secondary index

    A global secondary index uses a different partition key; a local secondary index shares the table's partition key.

    Remember
    Choose by the query pattern needed.
    Tested as
    Data store questions.
    Trap
    Confusing the two index types.

  • DynamoDB capacity modes

    Provisioned versus on-demand capacity.

    Remember
    On-demand suits unpredictable traffic.
    Tested as
    Data store questions.
    Trap
    Using provisioned for spiky, unpredictable load.

  • DAX vs. ElastiCache

    DAX caches DynamoDB reads specifically; ElastiCache caches general data.

    Remember
    DAX is purpose-built for DynamoDB.
    Tested as
    Caching questions.
    Trap
    Using ElastiCache where DAX fits DynamoDB.

Side by side

Concepts candidates mix up, compared on the point that decides the answer.

SQS vs. SNS vs. Kinesis

ConceptMeaningKey differenceCommon trap
SQS A queue consumers pull from Decouples work, no ordering guarantee by default Expecting ordered replay
SNS Pub/sub fan-out to many subscribers Pushes one message to many Using it to buffer work
Kinesis Ordered real-time streaming Ordering and replay within a shard Using SQS for ordered streams

Reserved vs. provisioned concurrency

ConceptMeaningKey differenceCommon trap
Reserved concurrency Caps and guarantees a function's concurrency Limits and reserves capacity Expecting it to remove cold starts
Provisioned concurrency Pre-warms a set number of instances Removes cold-start latency Confusing it with reserved

Global vs. local secondary index

ConceptMeaningKey differenceCommon trap
Global secondary index Different partition and sort key New query patterns, own capacity Confusing it with a local index
Local secondary index Same partition key, different sort key Alternate sort within a partition Expecting a different partition key

Exam traps

Each trap is an answer that looks right. Learn the clue that should change your mind.

  1. No idempotency

    What candidates pick
    Process every incoming request without a deduplication mechanism.
    Why it looks right
    It is the straightforward path.
    Why it's wrong
    Client retries can send duplicates; idempotency with a unique token and conditional write prevents double processing.

    Clue to watch for Requests may be retried and must not be applied twice.

  2. SQS for ordered streams

    What candidates pick
    Use a standard SQS queue for ordered, replayable event streaming.
    Why it looks right
    SQS is a familiar messaging service.
    Why it's wrong
    Kinesis preserves order within a shard and supports replay, which standard SQS does not.

    Clue to watch for The data must be ordered or replayable.

  3. Provisioned to cap concurrency

    What candidates pick
    Use provisioned concurrency to limit how many instances a function can use.
    Why it looks right
    Both relate to concurrency.
    Why it's wrong
    Reserved concurrency caps and guarantees concurrency; provisioned concurrency pre-warms instances to cut cold starts.

    Clue to watch for The need is to limit concurrency versus reduce cold starts.

  4. Hot partition key

    What candidates pick
    Use a low-cardinality attribute such as status as the DynamoDB partition key.
    Why it looks right
    It is a convenient attribute.
    Why it's wrong
    A low-cardinality partition key concentrates traffic on few partitions, causing throttling. The key should spread load.

    Clue to watch for The table experiences throttling on certain keys.

  5. VPC Lambda reaches internet freely

    What candidates pick
    Assume a Lambda in a VPC can reach the internet by default.
    Why it looks right
    Non-VPC Lambda can.
    Why it's wrong
    A function in a VPC needs a NAT path for internet access, like any private subnet resource.

    Clue to watch for A VPC-configured function must call an external endpoint.

  6. ElastiCache for DynamoDB

    What candidates pick
    Use ElastiCache to cache DynamoDB reads.
    Why it looks right
    ElastiCache is a cache.
    Why it's wrong
    DAX is purpose-built to cache DynamoDB reads with minimal code change; ElastiCache is for general caching.

    Clue to watch for The cache is specifically for DynamoDB reads.

Answer framework

For any Domain 1 development scenario, use these steps to find the answer DVA-C02 expects.

  1. Identify the application behavior required and whether it needs messaging, streaming, a data store or compute logic.
  2. Make operations idempotent and stateless so retries are safe and the application scales horizontally.
  3. Choose the right integration service: SQS to decouple, SNS to fan out, Kinesis for ordered streaming, and the correct caching service.
  4. For Lambda, set memory (which scales CPU), timeout and concurrency correctly, and handle failed async events with destinations or dead-letter queues.
  5. For DynamoDB, design a high-cardinality partition key, add the right secondary index for the query pattern, and choose the capacity mode that fits the traffic. Where two options seem to fit, pick the one that most precisely matches the behavior the scenario requires.

Practice question

A developer is building an order API that clients may call more than once for the same order because of network retries. The application must ensure an order is processed only once. Which approach BEST achieves this?

Want more like this? The AWS DVA practice test has questions for every domain.

Checklist

0 of 10

Tick each one you can do without notes. Your ticks stay in this browser.

Study strategy

This domain is the most hands-on, so study by writing code against the AWS SDK rather than only reading. Build small applications that call AWS services, handle retries idempotently and run statelessly, so these patterns become instinctive.

Give Lambda deep attention, since it is central: learn how memory scales CPU, how timeout and concurrency behave, the difference between reserved and provisioned concurrency, and how to capture failed async events. Then master DynamoDB, the most tested data store: partition and sort key design, avoiding hot partitions, global versus local secondary indexes, and capacity modes.

Learn the messaging and streaming trio precisely, SQS, SNS and Kinesis, and the caching options DAX and ElastiCache. Because this domain underpins the others, strong fundamentals here pay off across the exam. Afterwards, move to Domain 2, security, the second-largest domain. Hands-on coding against the AWS SDK in a free-tier account cements these developer patterns far faster than reading, and reviewing missed practice questions by domain shows where to focus next.

FAQ

How much of DVA-C02 is Domain 1?

Development with AWS Services is 32% of the scored content, the largest domain, and the most implementation-focused.

What is idempotency and why does it matter?

An idempotent operation has the same effect whether applied once or many times, which makes retries safe. It is often implemented with a unique token and a conditional write so duplicates are ignored.

What is the difference between reserved and provisioned concurrency?

Reserved concurrency caps and guarantees how much concurrency a function can use. Provisioned concurrency pre-warms a set number of instances to eliminate cold-start latency.

When should I use Kinesis instead of SQS?

When the data must be ordered and replayable. Kinesis preserves order within a shard and allows replay, while a standard SQS queue does not.

How do I avoid DynamoDB hot partitions?

Choose a high-cardinality partition key that spreads traffic evenly across partitions, rather than a low-cardinality attribute that concentrates load.

Can a Lambda function in a VPC reach the internet?

Only through a NAT path, like any private subnet resource. A VPC-configured function does not get internet access automatically.

How does Domain 1 connect to the rest of the exam?

Its implementation patterns, idempotency, Lambda, DynamoDB and messaging, recur in the security, deployment and troubleshooting domains.

Other Cloud Computing certifications

Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.

Test your Domain 1 knowledge

You have covered SDK usage, Lambda, DynamoDB, messaging and caching. Test whether you can choose the right service and configuration for an application behavior under exam conditions.

Take the AWS DVA practice test Check your AWS DVA readiness

Keep going