CloudPath Academy

Your guide to AWS certification success

AWS Certified Developer Associate (DVA-C02) Domain 1

Development with AWS Services

Official Exam Guide: Domain 1: Development with AWS Services
Skill Builder: AWS Developer Associate (DVA-C02) Exam Prep

Note: Some Skill Builder labs require a subscription.

How to Study This Domain Effectively

Study Tips

Build working code examples for each pattern - Don’t just read about event-driven architectures, microservices, or Lambda functions—actually implement them. Create small projects that demonstrate synchronous vs asynchronous patterns, tightly vs loosely coupled components, and stateful vs stateless designs. Hands-on coding solidifies these concepts far better than passive reading, and the exam frequently tests your ability to identify the right pattern for specific scenarios.
Practice with AWS SDKs in your preferred language - The exam expects you to understand how to interact with AWS services programmatically. Install the AWS SDK for your language of choice (Python, JavaScript, Java, etc.) and write code that calls various AWS services. Focus on error handling, retry logic, pagination, and authentication patterns that appear consistently across different SDKs.
Master DynamoDB through practical exercises - DynamoDB is heavily featured in this domain. Create tables with different partition key and sort key combinations, practice query vs scan operations, experiment with Global Secondary Indexes and Local Secondary Indexes, and implement pagination. Understanding DynamoDB’s performance characteristics and access patterns is crucial for multiple exam questions.
Set up a local Lambda development environment - Use AWS SAM CLI or the Serverless Framework to develop and test Lambda functions locally. Practice configuring environment variables, adjusting memory and timeout settings, implementing error handling with destinations and dead-letter queues, and testing event-driven invocations. Local development helps you understand Lambda’s execution model without constant deployment delays.
Create an architecture pattern cheat sheet - Build a visual reference that maps common application patterns (event-driven, microservices, fanout, choreography, orchestration) to their AWS service implementations. Include when to use SQS vs SNS vs EventBridge, how Step Functions orchestrates workflows, and how to implement circuit breakers and retry logic. This reference helps you quickly identify the right architectural approach during exam questions.

Recommended Approach

Start with foundational architectural concepts - Begin by understanding the core architectural patterns (monolithic vs microservices, stateful vs stateless, synchronous vs asynchronous, tightly vs loosely coupled). Read the AWS Well-Architected Framework and serverless application lens to understand how these patterns apply to AWS. This foundation is essential for making architectural decisions throughout the exam.
Deep dive into AWS SDK programming - Study how to use AWS SDKs to interact with services programmatically. Focus on the SDK documentation for your preferred language, learn about credential management, understand pagination for large result sets, and master error handling and retry strategies. Practice writing code that calls EC2, S3, DynamoDB, SQS, and Lambda programmatically.
Master Lambda development and optimization - Study Lambda configuration options (memory, timeout, concurrency, environment variables, layers, extensions), understand the execution lifecycle, practice implementing error handling with destinations and DLQs, and learn performance optimization techniques. Work through AWS SAM documentation to understand local testing and deployment patterns.
Become proficient with messaging and event services - Study SQS, SNS, EventBridge, and Kinesis in detail. Understand their use cases, message delivery patterns, error handling mechanisms, and how to implement fanout and event-driven architectures. Practice writing code that sends, receives, and processes messages from these services.
Study data stores and caching strategies - Focus heavily on DynamoDB (partition keys, sort keys, GSIs, LSIs, query vs scan, consistency models), then expand to ElastiCache, RDS, and specialized stores like OpenSearch. Understand data serialization, caching patterns, and how to choose the right data store based on access patterns. Complete with practice exams focused on Domain 1 to identify knowledge gaps.

Task 1: Develop code for applications hosted on AWS

Skills & Corresponding Documentation

Skill 1.1.1: Describe architectural patterns (for example, event-driven, microservices, monolithic, choreography, orchestration, fanout)

Why: The exam tests your ability to identify and implement appropriate architectural patterns for different scenarios. Questions present requirements like scalability needs, component independence, or event processing workflows and expect you to recommend the right pattern. Understanding when to use event-driven architecture vs request-response patterns, microservices vs monolithic designs, and choreography vs orchestration is fundamental for designing AWS applications and appears across multiple exam questions.

AWS Documentation:

Skill 1.1.2: Describe differences between stateful and stateless concepts

Why: Stateful vs stateless application design is tested through scenarios about scalability, session management, and fault tolerance. You must understand that stateless applications can scale horizontally more easily, how to externalize state to services like DynamoDB or ElastiCache, and when stateful designs are appropriate. Exam questions often describe scaling requirements or ask how to maintain user sessions across multiple instances, requiring knowledge of state management strategies.

AWS Documentation:

Skill 1.1.3: Describe differences between tightly coupled and loosely coupled components

Why: Exam questions frequently test your understanding of coupling in distributed systems. You need to know that tightly coupled components have direct dependencies and synchronous communication, while loosely coupled components communicate asynchronously through intermediaries like queues or event buses. Questions present architectural scenarios and ask you to identify coupling levels or recommend services (SQS, SNS, EventBridge) to reduce coupling and improve system resilience.

AWS Documentation:

Skill 1.1.4: Describe differences between synchronous and asynchronous patterns

Why: Understanding synchronous vs asynchronous communication patterns is essential for designing responsive, scalable applications. The exam tests scenarios where you must choose between blocking requests (synchronous) and fire-and-forget patterns (asynchronous), understand the implications for user experience and system scalability, and select appropriate AWS services (API Gateway with Lambda vs SQS with Lambda). This knowledge helps answer questions about system responsiveness and handling variable workload patterns.

AWS Documentation:

Skill 1.1.5: Create fault-tolerant and resilient applications in a programming language (for example, Java, C#, Python, JavaScript, TypeScript, Go)

Why: Exam questions test your ability to implement resilience patterns in code. You must understand how to implement retry logic with exponential backoff, circuit breakers to prevent cascading failures, graceful degradation when dependencies fail, and timeout handling. Questions present failure scenarios and expect you to identify the correct resilience pattern or recognize code that implements fault tolerance correctly.

AWS Documentation:

Skill 1.1.6: Create, extend, and maintain APIs (for example, response/request transformations, enforcing validation rules, overriding status codes)

Why: API development is heavily tested because API Gateway is a core service for serverless and microservices architectures. You need to understand request/response transformations using mapping templates, input validation with request validators and models, custom authorization, CORS configuration, and how to override status codes. Exam questions present API requirements and expect you to configure API Gateway features or write transformation code correctly.

AWS Documentation:

Skill 1.1.7: Write and run unit tests in development environments (for example, using AWS SAM)

Why: Testing is a fundamental development practice that appears throughout the exam. You must understand how to use AWS SAM CLI for local Lambda testing, write unit tests that mock AWS service calls, use frameworks like pytest or Jest for testing, and validate code before deployment. Exam questions test your knowledge of testing strategies, local development tools, and how to validate serverless applications in development environments.

AWS Documentation:

Skill 1.1.8: Write code to use messaging services

Why: Messaging services are core to decoupled architectures, and the exam extensively tests your ability to write code for SQS, SNS, and EventBridge. You need to understand how to send messages to queues, publish to topics, receive and delete messages, handle message attributes, implement long polling, and process batches. Questions present messaging scenarios and expect you to write or identify correct SDK code for message handling.

AWS Documentation:

Skill 1.1.9: Write code that interacts with AWS services by using APIs and AWS SDKs

Why: This is one of the most fundamental skills tested throughout the exam. You must know how to use AWS SDKs in your programming language to call AWS services, handle authentication with IAM roles and credentials, implement pagination for large result sets, handle API throttling and rate limits, and properly process SDK responses and errors. Nearly every exam question involving code implementation requires understanding of SDK usage patterns.

AWS Documentation:

Skill 1.1.10: Handle streaming data using AWS services

Why: Streaming data processing is tested through scenarios involving real-time analytics, log processing, and event streams. You need to understand Kinesis Data Streams for ingesting and processing streaming data, Kinesis Data Firehose for delivery to data stores, and how to write code that produces and consumes streaming data. Exam questions present real-time processing requirements and expect you to select appropriate streaming services and implement correct processing patterns.

AWS Documentation:

Skill 1.1.11: Use Amazon Q Developer to assist with development

Why: Amazon Q Developer is a newer service that represents AWS’s AI-powered development assistance. Exam questions test your understanding of how Q Developer can help with code generation, debugging, security scanning, and AWS best practices recommendations. You should know when to leverage Q Developer for development tasks, what capabilities it provides, and how it integrates into development workflows.

AWS Documentation:

Skill 1.1.12: Use Amazon EventBridge to implement event-driven patterns

Why: EventBridge is heavily tested as the central service for event-driven architectures. You must understand how to create event buses, define event rules and patterns, route events to targets, use event schemas for validation, and implement cross-account event routing. Exam questions present event-driven scenarios and expect you to configure EventBridge rules, write event patterns that match specific events, and select appropriate targets for event processing.

AWS Documentation:

Skill 1.1.13: Implement resilient application code for third-party service integrations (for example, retry logic, circuit breakers, error handling patterns)

Why: Integration with third-party services requires robust error handling because external dependencies can fail unpredictably. Exam questions test your ability to implement retry logic with exponential backoff and jitter, circuit breaker patterns to prevent cascading failures, timeout handling, and graceful degradation. You must understand when each pattern is appropriate and how to code them correctly to ensure application resilience.

AWS Documentation:

AWS Service FAQs:

AWS Whitepapers:

Task 2: Develop code for AWS Lambda

Skills & Corresponding Documentation

Skill 1.2.1: Describe the access of private resources in VPCs from Lambda code

Why: VPC integration for Lambda functions is frequently tested because many applications need to access private resources like RDS databases or ElastiCache clusters. You must understand how Lambda functions connect to VPCs, the impact on cold start times, how to configure security groups and subnets for Lambda, and that VPC-connected Lambda functions need NAT gateways to access the internet. Exam questions present scenarios involving private resource access and expect you to configure VPC settings correctly.

AWS Documentation:

Skill 1.2.2: Configure Lambda functions by defining environment variables and parameters (for example, memory, concurrency, timeout, runtime, handler, layers, extensions, triggers, destinations)

Why: Lambda configuration is one of the most heavily tested topics because it directly impacts function behavior, performance, and cost. You must understand how to set memory (which also affects CPU), configure timeout values, use environment variables for configuration, set concurrency limits, choose the appropriate runtime, specify the handler correctly, use layers for shared code, configure extensions for monitoring, define triggers for invocation, and set up destinations for async success/failure routing. Exam questions frequently present scenarios requiring specific configuration changes.

AWS Documentation:

Skill 1.2.3: Handle the event lifecycle and errors by using code (for example, Lambda Destinations, dead-letter queues)

Why: Error handling in Lambda is critical for building reliable serverless applications. Exam questions test your understanding of how to configure Lambda Destinations for routing successful and failed async invocations, use dead-letter queues for failed synchronous invocations, implement retry behavior, and handle partial batch failures with SQS and Kinesis. You must know the difference between destinations and DLQs, when each is appropriate, and how to configure them correctly.

AWS Documentation:

Skill 1.2.4: Write and run test code by using AWS services and tools

Why: Testing Lambda functions is essential for ensuring code quality before deployment. You must understand how to use AWS SAM CLI for local testing, create test events in the Lambda console, use CloudWatch Logs to debug, and write unit tests that mock AWS service calls. Exam questions test your knowledge of testing strategies, local development workflows, and how to validate Lambda functions in development environments before production deployment.

AWS Documentation:

Skill 1.2.5: Integrate Lambda functions with AWS services

Why: Lambda integration with other AWS services is extensively tested because serverless architectures depend on service orchestration. You need to know how to configure Lambda triggers from various sources (API Gateway, S3, DynamoDB Streams, EventBridge, SQS, SNS, Kinesis), understand how event source mappings work, configure IAM permissions for cross-service access, and handle service-specific event formats. Exam questions present integration scenarios and expect you to configure triggers and permissions correctly.

AWS Documentation:

Skill 1.2.6: Tune Lambda functions for optimal performance

Why: Performance optimization is tested through scenarios requiring you to minimize cold starts, optimize memory allocation for cost and speed, use provisioned concurrency for consistent performance, implement caching strategies, minimize deployment package size, and reduce execution time. You must understand the relationship between memory and CPU allocation, connection reuse best practices, and how to profile Lambda functions. Exam questions present performance requirements and expect you to identify appropriate optimization techniques.

AWS Documentation:

Skill 1.2.7: Use Lambda functions to process and transform data in near real time

Why: Real-time data processing with Lambda is tested through scenarios involving streaming data from Kinesis, processing S3 events as files are uploaded, transforming DynamoDB Streams records, and implementing ETL pipelines. You must understand batch processing for streams, checkpointing mechanisms, how to handle processing failures, and patterns for data transformation. Exam questions present real-time processing requirements and expect you to configure Lambda for stream processing correctly.

AWS Documentation:

AWS Service FAQs:

AWS Whitepapers:

Task 3: Use data stores in application development

Skills & Corresponding Documentation

Skill 1.3.1: Describe high-cardinality partition keys for balanced partition access

Why: Partition key design is critical for DynamoDB performance and is heavily tested. You must understand that high-cardinality partition keys distribute data evenly across partitions, prevent hot partitions, and enable horizontal scaling. Low-cardinality keys (like status or region) create uneven distribution and performance bottlenecks. Exam questions present table design scenarios and expect you to identify appropriate partition keys that ensure balanced data distribution and optimal throughput.

AWS Documentation:

Skill 1.3.2: Describe database consistency models (for example, strongly consistent, eventually consistent)

Why: Consistency models affect data accuracy and read performance, and exam questions test your understanding of when to use each model. You must know that DynamoDB offers eventually consistent reads (default, faster, cheaper) and strongly consistent reads (guaranteed latest data, higher latency, more expensive). You should understand read-after-write consistency, how replication affects consistency, and trade-offs between consistency and performance. Questions present data accuracy requirements and expect you to choose the appropriate consistency level.

AWS Documentation:

Skill 1.3.3: Describe differences between query and scan operations

Why: Understanding query vs scan is fundamental for DynamoDB performance and cost optimization. You must know that queries retrieve items using partition key and optional sort key (efficient, fast, predictable cost), while scans examine every item in the table (expensive, slow, unpredictable). Exam questions present data retrieval scenarios and expect you to identify when queries are possible versus when scans are necessary, understand filter expressions, and recognize performance implications of each operation.

AWS Documentation:

Skill 1.3.4: Define Amazon DynamoDB keys and indexing

Why: DynamoDB key structures and indexes are extensively tested because they determine data access patterns and query capabilities. You must understand partition keys and sort keys (composite primary keys), Global Secondary Indexes for alternative access patterns, Local Secondary Indexes for additional sort keys, projection types (ALL, KEYS_ONLY, INCLUDE), and index throughput considerations. Exam questions present access pattern requirements and expect you to design appropriate key structures and indexes.

AWS Documentation:

Skill 1.3.5: Serialize and deserialize data to provide persistence to a data store

Why: Serialization is tested because applications must convert between programming language objects and storage formats. You need to understand JSON serialization for API communication, how DynamoDB stores different data types, converting objects to/from database records, handling complex data structures, and using SDK type converters. Exam questions may present code that serializes/deserializes data and expect you to identify correct implementations or troubleshoot serialization errors.

AWS Documentation:

Skill 1.3.6: Use, manage, and maintain data stores

Why: Data store management is tested through operational scenarios involving backup, restore, monitoring, capacity planning, and maintenance tasks. You must understand DynamoDB on-demand vs provisioned capacity, auto-scaling, point-in-time recovery, global tables for multi-region replication, RDS maintenance windows, automated backups, and read replicas. Exam questions present operational requirements and expect you to configure appropriate management settings.

AWS Documentation:

Skill 1.3.7: Manage data lifecycles

Why: Data lifecycle management is tested through scenarios involving data retention, archival, and deletion policies. You must understand S3 lifecycle policies to transition objects between storage classes, DynamoDB TTL for automatic item expiration, RDS snapshot retention, and automated cleanup strategies. Exam questions present data retention requirements and expect you to configure lifecycle policies that balance cost and compliance needs.

AWS Documentation:

Skill 1.3.8: Use data caching services

Why: Caching is extensively tested because it’s a fundamental performance optimization technique. You must understand ElastiCache for Redis and Memcached, DynamoDB Accelerator (DAX) for single-digit millisecond DynamoDB reads, cache invalidation strategies, cache-aside vs write-through patterns, and when caching provides the most benefit. Exam questions present performance requirements and expect you to select appropriate caching solutions and implement caching patterns correctly.

AWS Documentation:

Skill 1.3.9: Use specialized data stores based on access patterns (for example, Amazon OpenSearch Service)

Why: Choosing the right database for specific access patterns is tested through scenarios that require specialized query capabilities. You must understand when to use OpenSearch for full-text search and analytics, DocumentDB for MongoDB-compatible document storage, Neptune for graph databases, Timestream for time-series data, and QLDB for immutable ledger requirements. Exam questions describe access patterns and data characteristics, expecting you to identify the most appropriate specialized data store.

AWS Documentation:

AWS Service FAQs:

AWS Whitepapers:

Final Thoughts

Domain 1: Development with AWS Services is the foundation of the AWS Developer Associate certification and represents the largest portion of the exam. Success requires hands-on coding experience with AWS services—reading documentation alone is insufficient. Set up a development environment with AWS SAM CLI, practice writing Lambda functions in your preferred language, experiment with DynamoDB table designs, and build event-driven applications using SQS, SNS, and EventBridge. Focus heavily on understanding architectural patterns, Lambda configuration and optimization, DynamoDB access patterns and indexing, and SDK usage for programmatic AWS interaction. The skills you build here are directly applicable to real-world serverless development and will serve as the technical foundation for the remaining exam domains.