AWS Builder Center
I Fired 100 Requests at One Lambda Function. Only 10 Ran.

I Fired 100 Requests at One Lambda Function. Only 10 Ran.

I fired up to 100 concurrent requests at one Lambda function to find its real concurrency ceiling. The account limit was hiding in plain sight the whole time.

Cloud Engineer

Why I did this

Every AWS Lambda function runs inside a Firecracker microVM — a lightweight VM that boots in milliseconds and gets thrown away when it's no longer needed. I've read that fact dozens of times, but I'd never actually watched it happen. So I built a small test rig, pointed it at my own account, and started firing concurrent requests to see what the burst really looks like from the inside.
I was not trying to test the new "AWS Lambda MicroVMs" product that AWS announced this June. This is about the ordinary Lambda function type everyone already uses, and the microVMs that have always powered it under the hood.

The setup

Nothing fancy. A Python Lambda function that returns a random UUID it generates once at cold start, plus a flag for how many times that same environment has been reused. If two invocations come back with the same UUID, they landed on the same microVM. A local script fires N concurrent  Invoke  calls with  boto3  and records who succeeded, who got throttled, and which UUIDs came back.


First surprise: the account limit is 10, not 1000

Before writing any load, I checked  aws lambda get-account-settings . I expected the commonly quoted number — an initial burst of 500 to 3000 per minute, then +500/minute after that. Instead I got this:
"ConcurrentExecutions": 10,
"UnreservedConcurrentExecutions": 10
Ten. Not a thousand, not five hundred. This looks like a default for a low-usage personal account rather than the numbers you see in the docs, which seem to assume an account with some history behind it. That alone reframed the whole experiment — there was no "initial burst quota" to chase. The interesting question became something smaller and more concrete: what actually happens when you cross a limit of 10?

The confusing first attempt

I fired 50 concurrent requests expecting a clean split around 10 successes and 40 throttles. What I got instead was 25 throttled — reasonable enough. But running the same 50-request burst again a bit later gave me 7 throttled, and later still, 2. Same code, same function, wildly different outcomes. My first thought was that something in my script was broken.
Sweeping across a range of concurrency levels made the picture even stranger:
At 30 concurrent requests, all 30 succeeded — no throttling at all, despite an account limit of 10. At 100 requests, 85 succeeded. And yet the number of distinct microVM UUIDs I saw never went much above 10. So more than 10 environments were never created, but far more than 10 requests were getting served.

What was actually happening

My handler was fast — a few milliseconds of work, then it returns. That's the problem. If an environment finishes an invocation and becomes free again before the next queued request even arrives, Lambda can hand that same warm environment the next request instead of spinning up a new one. With ~10 environments serving requests that each take a few milliseconds, you can push a lot more than 10 requests through the pipe before anything gets throttled. My successful-request count was measuring throughput, not concurrency.
To actually observe the concurrency ceiling, I needed every invocation to hold onto its environment for a while, so environments couldn't be recycled mid-burst. I added an optional  sleep_ms  parameter to the handler and reran the sweep with a 1-second delay on every call.
That's a clean cliff. Up to 10 concurrent requests, everything succeeds. At 12, exactly 2 get throttled. At 50, exactly 40 get throttled. Every single data point lines up with  requested − 10 . The account setting wasn't lying — it was just invisible under fast, reusable invocations.

Cross-checking with CloudWatch (and a false alarm)

I wanted a second source of truth, so I queried the  AWS/Lambda   Throttles  metric for the same time window right after the delayed sweep finished. My own client had recorded 77 throttled calls. CloudWatch showed 46. For a moment I assumed the metric and my instrumentation disagreed on something fundamental about what counts as a throttle.
It turned out to be simpler than that — metric ingestion lag. I waited about 90 seconds and queried again. This time CloudWatch reported 77, matching my client-side count exactly. Good reminder that CloudWatch numbers taken seconds after an event aren't final yet.



Why the very first test was so unstable

That still left the original mystery: why did the same 50-request burst throttle 25 times, then 7, then 2? I reran the same test five times in a row with no delay and watched both numbers:
trial
throttled
environments used
0
11
10
1
9
10
2
5
9
3
4
9
4
2
9
The environment count barely moved, but the throttle count dropped steadily. The best explanation I have is that each trial left a handful of environments warm for the next one, and warm environments skip the cold-start delay entirely. As more of the pool stayed warm across trials, requests got served faster, which meant more of them slipped through the queue before the next one arrived. Fewer cold starts, less serialization, fewer throttles — even though the hard ceiling of 10 never changed.

What I took away from this

The number in  get-account-settings  was accurate the entire time. What changed was how visible it was. A slow, non-reusable workload shows you the limit immediately, as a clean wall. A fast, cheap workload can hide that same wall behind queueing and warm-environment reuse, to the point where a single test run tells you almost nothing you can trust. If you want to measure a concurrency ceiling instead of throughput, the invocation needs to be slow enough, or held open long enough, that environments can't be recycled mid-test.
None of this needed thousands of requests or an expensive experiment — the whole thing ran inside a personal account's default limit of 10, for a few cents of Lambda compute.
Thanks for reading.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article