Keep your API fast—even at peak

Maya asks for a report. The application is the program; compute supplies the resources that execute its instructions. Receiving a message is not the same as doing that work.

The two panels are alternative placements, not a chain of calls. A server pool has separate machines running application copies. Containers provide separate places for programs on a host; they do not remove the host’s resource limits.

Requests reach A and B. C has been requested, but it contributes no ready capacity yet. Count the copies that can serve now—not the number you asked the platform to create.

C is initializing. A and B still handle the incoming work; C has no incoming request path yet. Adding a desired copy does not instantly relieve the existing servers.

Now suppose C is ready too. All three application copies call the same database. The database is a separate resource: adding an application copy does not automatically add capacity there.

Your code still runs on machines, inside the provider-managed boundary. The provider starts that code when needed. The word serverless does not mean machines or finite resources have disappeared.

A and B are separate execution environments inside the managed infrastructure. Each box is a place for a copy of your application code, not an unlimited shared machine.

Provider-managed execution still has a resource budget. Each environment can run out of its available memory. The strips illustrate finite budgets, not byte measurements or platform defaults.

The next invocation may reuse environment A, where code has run before, or start in a new environment B. These are alternatives—not two calls made by the application. Never rely on getting A again.

Follow the vertical Now line. A, B and C have all started and none has finished: concurrency is three. The earlier completed operation no longer counts. Concurrency measures overlapping work, not requests per second.

Choose an illustrative limit of three in this scope. A, B and C are still active, so D cannot start yet. Decide what to do with excess work; moving it to an unbounded waiting area would not solve the resource problem.

An application-scoped limit covers work in one environment. Protecting a shared dependency also requires reasoning about all its callers. Platforms expose different memory signals and controls; one server middleware recipe is not automatically portable to every serverless runtime.

A and B were already present; C and D are added. All four paths converge on the same database. We doubled the equal-sized application fleet, not the capacity of every component it depends on.

If the database already limits completions, more callers do not necessarily produce more reports. They can simply send more work to the same bottleneck. Check the entire request path before treating added compute as added useful capacity.