20+ practice questions focused on Troubleshooting and Optimization — one of the most tested topics on the AWS Certified Developer Associate DVA-C02 exam. Each question includes a detailed explanation so you learn why the right answer is correct.
Start Troubleshooting and Optimization PracticeA developer is troubleshooting an AWS Lambda function that processes records from an Amazon Kinesis Data Stream. The function is configured with a batch size of 100 and a parallelization factor of 1. The developer notices that the iterator age is increasing, indicating that the function is not keeping up with the stream. CloudWatch Logs show that the function is not experiencing errors or throttling, but the execution time per invocation is close to the 5-minute timeout. The stream has 10 shards. Which action will most likely increase processing throughput?
Explanation: The function's execution time is already near the 5-minute timeout, indicating a CPU-bound or memory-bound operation. Increasing memory proportionally increases CPU allocation in Lambda, which directly reduces execution time per invocation, allowing each batch to be processed faster and thus increasing overall throughput without changing the batch size or shard count.
A developer is using AWS Lambda with a function that processes messages from an SQS queue. The function is configured with a batch size of 10 and reserved concurrency of 5. The queue has a large backlog, and messages are being throttled, leading to retries and eventual DLQ. The function is idempotent and can handle up to 100 messages per invocation. What is the most effective way to increase throughput without increasing throttling?
Explanation: For SQS FIFO queues, the maximum batch size allowed for a Lambda event source mapping is 10. Therefore, options B and C are incorrect because they attempt to increase the batch size to 100, which is unsupported for FIFO queues. To resolve the throttling and increase throughput, the reserved concurrency of the Lambda function must be increased (Option A), allowing more concurrent executions to process the backlog.
An AWS Lambda function that processes messages from an SQS queue is experiencing throttling (TooManyRequestsException). The function has reserved concurrency set to 100. The SQS queue has a redrive policy configured with maxReceiveCount of 5. CloudWatch metrics show that the function's concurrent executions occasionally spike to 100, and throttling occurs. The function execution time averages 2 seconds. What is the most effective way to reduce throttling?
Explanation: When an AWS Lambda function processing SQS messages experiences throttling because it reaches its reserved concurrency limit (100), the most direct and effective solution is to increase the reserved concurrency limit. Increasing the batch size (Option A) does not reduce the concurrency requirement because processing more messages per batch increases the execution time of each invocation proportionally, keeping the overall concurrency (Invocations per second * Execution duration) the same. Therefore, increasing the reserved concurrency is the correct solution.
A developer deployed an AWS Lambda function that is invoked by an Amazon SQS queue. The function is configured with a batch size of 10 and a timeout of 30 seconds. CloudWatch metrics show that the function's Duration is consistently around 28 seconds, but occasionally spikes to 35 seconds causing timeouts. The function makes a synchronous HTTP call to an external API. Which approach will MOST effectively prevent timeouts while maximizing throughput?
Explanation: Reducing the batch size to 5 is the most effective and simplest solution. Since the function currently takes ~28 seconds to process 10 messages (about 2.8 seconds per message), reducing the batch size to 5 will lower the average execution time to approximately 14 seconds. This is well below the 30-second Lambda timeout, preventing timeouts without requiring any code changes. Increasing the Lambda timeout to 60 seconds (Option B) or SQS visibility timeout to 60 seconds (Option D) in isolation is incorrect because AWS recommends setting the SQS visibility timeout to at least 6 times the Lambda function timeout to prevent duplicate processing. Option A is incorrect because making asynchronous calls with callbacks in Lambda can lead to the function exiting before the callbacks complete, or requires complex concurrency management and code refactoring.
A developer is troubleshooting slow response times in a serverless application. The application consists of an Amazon API Gateway REST API that invokes an AWS Lambda function, which then writes data to an Amazon DynamoDB table with on-demand capacity. The function also calls an external API for enrichment. The developer observes that the API Gateway integration latency is high, but the Lambda function duration is low. What is the most likely cause?
Explanation: API Gateway integration latency measures the total time from when API Gateway sends the request to the backend (Lambda) until it receives the response. This includes the Lambda service's container initialization time (cold start). However, the Lambda 'Duration' metric only measures the execution time of the handler code itself, excluding the initialization phase. Therefore, when a function experiences cold starts, the integration latency is high while the Lambda duration remains low.
+15 more Troubleshooting and Optimization questions available
Practice all Troubleshooting and Optimization questions1. Baseline your knowledge
Start with 10 questions to gauge your current understanding of Troubleshooting and Optimization. This tells you whether you need a concept refresher or just practice.
2. Review every explanation
For each question — right or wrong — read the full explanation. Understanding why an answer is correct is more valuable than knowing the answer itself.
3. Focus on exam traps
Troubleshooting and Optimization questions on the DVA-C02 frequently use trap wording. Look for subtle differences in answers that test your precision, not just general knowledge.
4. Reach 80% consistently
Do repeated sessions until you score 80%+ three times in a row. Then move to mixed-mode practice to test cross-topic recall under realistic conditions.
The exact number varies per candidate. Troubleshooting and Optimization is tested as part of the AWS Certified Developer Associate DVA-C02 blueprint. Practicing with targeted Troubleshooting and Optimization questions ensures you can handle any format or difficulty that appears.
Yes. Courseiva provides free DVA-C02 practice questions across all exam topics and domains. The platform includes topic-based practice, mock exams, missed-question review, bookmarked questions, and readiness tracking — no account required.
Difficulty is subjective, but Troubleshooting and Optimization is a high-priority exam concept tested in multiple ways — direct recall, scenario analysis, and command-output interpretation. Consistent practice is the best way to build confidence.
Launch a full Troubleshooting and Optimization practice session with instant scoring and detailed explanations.
Start Troubleshooting and Optimization Practice →