DOP-C02 Incident and Event Response Practice Question
A company uses AWS Lambda functions to process messages from an Amazon SQS queue. The Lambda function is configured with a reserved concurrency of 5. The SQS queue has a large backlog of messages, and the Lambda function is processing them slowly. The DevOps team wants to increase throughput without making changes to the Lambda code. The team decides to increase the reserved concurrency to 10. However, after the change, the Lambda function starts to experience throttling errors (RateExceeded). The team also notices that other Lambda functions in the same account are also being throttled. What is the MOST likely cause?
⚠ Common exam trap
The trap is forgetting that reserved concurrency is deducted from the shared account-level concurrency pool — candidates assume raising reserved concurrency only affects the target function, when it actually reduces capacity available to every other function in the account.
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
✓
The account's Lambda concurrency limit has been reached due to the increased reserved concurrency.
Lambda concurrency is governed by an account-level limit (default 1,000) shared across all functions in a region. Reserved concurrency carves out a guaranteed slice for a function and subtracts from the unreserved pool available to other functions. Raising the reserved concurrency from 5 to 10 consumes more of the account pool, and if the account is already near its limit, other functions get throttled with RateExceeded errors.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
The SQS queue's polling interval is too high, causing Lambda to poll infrequently.
Why it's wrong here
Lambda's SQS event source mapping polls the queue for you at a rate that is managed internally and not configurable; setting a 'polling interval' is not an option. Even if polling were infrequent, throttling errors occur at invocation time due to concurrency limits, not because Lambda skips poll cycles. The symptom of infrequent polling would be delayed message processing, not a RateExceeded error.
- ✓
The account's Lambda concurrency limit has been reached due to the increased reserved concurrency.
Why this is correct
When you increase reserved concurrency for a function, you allocate a specific slice of the account's total concurrency limit (e.g., 1000). The remaining functions share the leftover pool, and if the total request rate exceeds that remaining capacity, new invocations for those functions are throttled with a 429 RateExceeded error. This is especially common when a burst of SQS messages triggers many concurrent invocations across multiple functions, saturating the account-wide limit and causing messages to remain in queue.
- ✗
The Lambda function's execution role does not have permission to invoke the function.
Why it's wrong here
An execution role lacking permissions to invoke the function is irrelevant because Lambda does not use the function's execution role to invoke itself; invocation is initiated by the event source mapping using the service principal. Missing permissions would cause failures like access denied when the function tries to call other AWS APIs, or a misconfigured trigger, but not a Lambda throttling error. A RateExceeded error means Lambda accepted the invocation request but could not run it due to concurrency.
- ✗
The SQS queue's visibility timeout is too short, causing messages to be processed multiple times.
Why it's wrong here
A short visibility timeout makes messages reappear in the queue before they are deleted, often leading to duplicate delivery and processing. If the function processes the message but the visibility timeout expires before the function completes or deletes the message, another worker can pick up the same message. This creates duplicates and possible out-of-order processing, but it does not generate throttling errors; throttling is purely a concurrency capacity issue at the Lambda service level.
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
One of 1,298 original DOP-C02 practice questions on Courseiva, each with a full explanation and wrong-answer analysis — not exam dumps or protected exam content. Learn why practice questions differ from exam dumps →
Same concept, more angles
1 more way this is tested on DOP-C02
These questions test the same concept from different angles. Work through them to make sure you can recognise it however the exam phrases it.
Variation 1. A company uses AWS Lambda functions to process events from Amazon SQS. Recently, the Lambda function has been throttled, causing messages to accumulate in the dead-letter queue (DLQ). The function’s reserved concurrency is set to 100, and the account’s regional concurrency limit is 1000. What is the MOST likely cause of the throttling?
hard- ✓ A.The function’s concurrency is fully utilized due to long-running invocations
- B.The Lambda function has a cold start issue
- C.The SQS queue is not configured as a FIFO queue
- D.The reserved concurrency is set too high, exceeding the account limit
Why A: The most likely cause of throttling is that the function's reserved concurrency of 100 is fully utilized due to long-running invocations. When invocations take longer to complete, they occupy concurrency for an extended period, preventing new invocations from starting. This leads to messages accumulating in the DLQ. Option D is incorrect because reserved concurrency of 100 is well below the account limit of 1000, so that is not the cause. Option B is incorrect because cold starts cause latency but not throttling; they do not consume concurrency. Option C is incorrect because the queue type (standard vs. FIFO) does not directly cause throttling; Lambda can process from both.
JA
Written and reviewed by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
Last reviewed September 2026 · checked against the official Amazon Web Services exam blueprint
This DOP-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 DOP-C02 exam.