DVA-C02 Development with AWS Services Practice Question
A company has a production application running on AWS Lambda that processes real-time streaming data from Amazon Kinesis Data Streams. The Lambda function is configured with a batch size of 100 and a maximum concurrency of 5. Recently, the application has been experiencing failures with a high number of invocation errors. The errors indicate that the function is timing out. The developer checks the CloudWatch metrics and notices that the IteratorAge metric for the Kinesis stream is increasing rapidly, and there are many Throttles events for the Lambda function. The average execution duration of the function is 30 seconds, and the function timeout is set to 1 minute. The Kinesis stream has 10 shards. The company expects the data volume to double in the next month. Which combination of actions should the developer take to resolve the issue and prepare for future growth?
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Increase Lambda concurrency to at least 20 and reduce the batch size to 10.
The Lambda function is throttled because the maximum concurrency of 5 is too low for 10 shards. With a batch size of 100 and average duration of 30 seconds, each batch takes too long, leading to timeouts and increasing IteratorAge. Increasing concurrency to at least 20 (2 per shard) allows processing of all shards in parallel. Reducing batch size to 10 reduces the processing time per batch, helping avoid timeouts. Option A is wrong because increasing shards without increasing concurrency would worsen throttling. Option C is wrong because disabling reserved concurrency could lead to uncontrolled scaling, but the main issue is concurrency and batch size; also decreasing batch size to 5 may be too small and inefficient. Option D is wrong because increasing timeout and batch size would not resolve throttling and would increase latency.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
Increase the number of shards in the Kinesis stream to 20 and increase Lambda concurrency to 10.
Why it's wrong here
Increasing Kinesis shards to 20 without adequately increasing Lambda concurrency is counterproductive. By default, Lambda processes one batch per shard concurrently, but can scale up to 10 concurrent invocations per shard. With only 10 total concurrency for 20 shards, many shards will remain unprocessed, leading to a significant backlog and increased event lag, ultimately failing to address the underlying performance issues or throttling.
- ✓
Increase Lambda concurrency to at least 20 and reduce the batch size to 10.
Why this is correct
Increasing Lambda concurrency to at least 20 allows the function to process more batches in parallel, effectively utilizing the Kinesis stream's capacity and reducing event backlog. Simultaneously, reducing the batch size to 10 records per invocation decreases the processing time for each individual invocation, making the function more efficient and less prone to timeouts, thereby improving overall throughput and mitigating throttling.
- ✗
Disable the reserved concurrency limit on the Lambda function and decrease the batch size to 5.
Why it's wrong here
Disabling reserved concurrency is risky as it removes dedicated capacity, forcing the function to compete for the account's general unreserved concurrency pool. This can lead to unpredictable throttling if other functions consume available capacity or if the account's overall concurrency limit is reached. While a smaller batch size can reduce individual invocation duration, the lack of guaranteed concurrency introduces instability and potential performance degradation in a production environment.
- ✗
Increase the Lambda function timeout to 5 minutes and increase the batch size to 500.
Why it's wrong here
Increasing the batch size to 500 records per invocation will significantly increase the processing time required for each Lambda invocation, exacerbating existing performance bottlenecks and making the function more likely to hit timeouts, even with an extended timeout. While a longer timeout might prevent immediate failures, it does not address the root cause of slow processing or throttling, potentially leading to increased event lag and Kinesis record expiration.
Visual reference
Quick reference
Cloud Service Model Comparison
| Model | You Manage | Provider Manages | Examples |
|---|---|---|---|
| IaaS | OS, runtime, apps, data | Hardware, hypervisor, networking | EC2, Azure VMs, GCP Compute Engine |
| PaaS | Apps and data | OS, runtime, middleware, hardware | Elastic Beanstalk, Azure App Service |
| SaaS | Data and settings only | Everything else | Microsoft 365, Salesforce, Workday |
| FaaS / Serverless | Function code only | Infra, scaling, runtime | Lambda, Azure Functions, Cloud Run |
| CaaS | Containers and apps | Kubernetes, OS, hardware | EKS, AKS, GKE |
Go deeper
Related to this question
About these practice questions
This DVA-C02 question is part of Courseiva's 1,135-question bank — original exam-style content with full explanations and wrong-answer analysis, never real exam questions or exam dumps. Learn why practice questions differ from exam dumps →
JA
Written by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This DVA-C02 practice question is part of Courseiva's free Amazon Web Services certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the DVA-C02 exam.