Amazon DVA-C02 AWS Certified Developer – Associate (DVA-C02) Free Practice Test — 30 Questions
This practice set focuses on key AWS services and architectural patterns for the AWS Certified Developer – Associate (DVA-C02) exam. It exercises knowledge of EC2 Auto Scaling, Elastic Load Balancing, RDS Multi-AZ, Lambda, API Gateway, Elastic Beanstalk, CI/CD with CodeCommit/CodeBuild/CodePipeline, CloudFormation, DynamoDB, KMS, CloudWatch, IoT Core, and design patterns like API Gateway and Saga. The questions emphasize high availability, scalability, security, and cost optimization. Use this set to reinforce decision-making in multi-tier architectures, serverless applications, and infrastructure as code. Practice interpreting performance metrics and conditional resource creation in CloudFormation.
What this DVA-C02 practice set measures
This is an analysis of the practice bank, not a claim about the vendor's live exam blueprint. Use it to identify the knowledge, judgment, and recall patterns exercised here, then verify your coverage against the current official exam guide.
Scalability and High Availability
Multiple questions assess strategies for handling variable traffic and ensuring fault tolerance. Topics include Auto Scaling groups across Availability Zones, Elastic Load Balancing, RDS Multi-AZ deployments, and ECS Service Auto Scaling. The correct answers emphasize decoupling compute and database layers to avoid single points of failure, and using horizontal scaling for cost efficiency. A common theme is that provisioning fixed resources (e.g., a single large instance) leads to waste or risk, while dynamic adjustments (e.g., Auto Scaling based on CloudWatch metrics) optimize both cost and performance.
- Use Auto Scaling groups across multiple Availability Zones for compute layer resilience.
- RDS Multi-AZ provides automatic failover for database high availability.
- ECS Service Auto Scaling adjusts task count based on CPU utilization or request count.
- Elastic Load Balancing (ELB) distributes traffic and performs health checks.
- Avoid single-instance architectures; they create single points of failure.
CI/CD and Automation
The practice bank covers CI/CD pipelines using CodeCommit, CodeBuild, CodePipeline, and CodeDeploy. Key decisions include using webhooks to trigger pipelines (instead of polling), implementing test impact analysis to reduce build times, and configuring CloudWatch Events to trigger Lambda on build failure. For CodeBuild, storing artifacts in S3 and using a buildspec file are recommended. For Elastic Beanstalk, rolling updates minimize downtime by updating instances in batches. The set also stresses that manual processes (e.g., emailing teams) are inefficient and error-prone.
- Webhooks from GitHub (or CodeCommit) trigger CodePipeline automatically; polling is inefficient.
- Test impact analysis runs only tests affected by recent code changes to optimize pipeline speed.
- CloudWatch Events rules can invoke Lambda on build failure for notification automation.
- Elastic Beanstalk rolling updates update a batch of instances at a time to maintain availability.
- Build artifacts should be stored in S3 for reliable access during deployment.
Security and Compliance
Security is addressed through IAM roles and policies, KMS key rotation, and least privilege. Questions require choosing IAM roles for Lambda (not a dedicated user) and restricting KMS key access to specific IAM roles. CloudTrail logging is essential for auditing key usage. For Cognito/Amplify, user identity-based S3 policies and DynamoDB access controls ensure that users access only their own data. The set also highlights that managed policies can grant excessive permissions and should be avoided when least privilege is required.
- Attach an IAM role to Lambda with a policy allowing only necessary DynamoDB actions; avoid managed policies.
- Enable automatic key rotation in KMS and use CloudTrail for key usage tracking.
- IAM policies should restrict KMS key access to specific roles, not all users.
- Use AWS Amplify's built-in authentication to enforce identity-based access to S3 and DynamoDB.
- Separate IAM users for Lambda functions are not recommended; use roles with temporary credentials.
Serverless and Microservices
Serverless patterns are a major focus. Lambda and API Gateway are used for variable workloads; provisioned concurrency pre-warms instances to reduce latency but may increase cost. API Gateway rate limiting (e.g., 2,000 req/sec) can become a bottleneck if set lower than Lambda's concurrency. For microservices, the API Gateway pattern centralizes cross-cutting concerns, while the Saga pattern uses local transactions and compensating actions for distributed data consistency without locking. IoT Core integrates directly with Lambda for real-time processing. The correct answers favor event-driven architectures over monolithic deployments.
- Lambda provisioned concurrency reduces cold starts for predictable traffic patterns.
- API Gateway rate limiting should be balanced with Lambda concurrency to avoid throttling.
- The API Gateway pattern simplifies authentication, logging, and routing in microservices.
- The Saga pattern ensures eventual consistency via local transactions and compensation; no distributed locks.
- AWS IoT Core can directly trigger Lambda functions from sensor messages for real-time alerting.
Practice Amazon DVA-C02 AWS Certified Developer – Associate (DVA-C02) with real flashcards
Read the prompt, commit to an answer, then flip the card. Move through the deck at your own pace and repeat any topic that does not come back quickly.
Card 1 of 20
1 reviewed this session
Static practice bank
Start the 30-question diagnostic
The complete question bank is embedded in this pre-rendered page. There is no database request or second content download when you begin.
A company is planning to migrate its on-premises application to AWS. The application consists of a web server, an application server, and a database server. The company expects a steady increase in traffic over the next year and wants to ensure that the architecture can scale efficiently. Which AWS services and architectural principles should the company consider to achieve a highly available and scalable solution while minimizing costs?
Study workflow
Turn one DVA-C02 attempt into a study plan
- 1
Plan Auto Scaling for Compute and Database Layers
Define Auto Scaling groups for EC2 instances across multiple Availability Zones. Attach an Application Load Balancer. For RDS, enable Multi-AZ for automatic failover. Use CloudWatch alarms to scale based on CPU or request count. Test the scaling policies under load.
- 2
Set Up a CI/CD Pipeline with CodePipeline
Connect your source repository (e.g., CodeCommit) using a webhook. Configure CodeBuild to run your build and tests, storing artifacts in S3. Add a deploy stage with CodeDeploy. Set up CloudWatch Events to trigger a Lambda function on build failure for notifications.
- 3
Implement Conditional Resource Creation in CloudFormation
Define a parameter (e.g., CreateInstances) and a condition in the Conditions section. In the Resources section, add a Condition key to the EC2 instance resource. Use the DependsOn attribute to enforce creation order, such as ensuring the database is created before the instance.
- 4
Configure Secure Access for Serverless Applications
Create an IAM role for Lambda with a policy that allows only necessary actions on DynamoDB (e.g., GetItem, PutItem) and S3 (e.g., GetObject, PutObject). Use AWS Cognito for user authentication in mobile apps and restrict S3 bucket policies to the authenticated user's prefix. Enable CloudTrail to log API calls.
- 5
Optimize Lambda Performance with Provisioned Concurrency
Analyze traffic patterns and set provisioned concurrency to a level that matches expected peak demand. This pre-warms environments to reduce cold starts. Monitor with CloudWatch and adjust the concurrency level as traffic changes. Combine with API Gateway throttling to control overall throughput.
FAQ
Questions about this DVA-C02 practice page
Clear boundaries on what the bank covers, how to use it, and where official vendor information still matters.
What is the difference between a rolling update and a blue/green deployment in Elastic Beanstalk?+
Rolling update gradually replaces instances in batches, keeping some capacity running. Blue/green deployment creates a new environment (green) and switches traffic after testing. Rolling is simpler but can cause mixed versions; blue/green offers zero downtime but requires more resources.
How does AWS Lambda provisioned concurrency improve latency?+
Provisioned concurrency initializes a specified number of execution environments in advance, eliminating cold starts for those instances. This reduces latency for requests, especially for applications with predictable traffic spikes, but incurs cost even when not in use.
When should you use the Saga pattern over a traditional distributed transaction?+
Use Saga when you need eventual consistency across microservices without distributed locks. Each service performs a local transaction and publishes events; if a step fails, compensating transactions roll back previous steps. This avoids the complexity and performance hit of two-phase commit.
What is the purpose of the DependsOn attribute in CloudFormation?+
DependsOn explicitly specifies that a resource must be created before another resource. For example, an EC2 instance can depend on an RDS database to ensure the database is available before the instance starts. This prevents creation order errors.
How can you enforce that EC2 instances are launched in specific subnets based on instance type using CloudFormation?+
Define conditions in the Conditions section that evaluate instance type (e.g., IsT2Micro and IsT2Large). In the EC2 resource, use the Condition attribute to choose the appropriate condition, and set the SubnetId property to the correct subnet for each condition.
Build the next review session
Browse another free bank or use the study strategy guide to turn your misses into spaced review.