Comparing Time Limits in ServerlessOps: Functions, Queues, Calls

Rajesh Kumar

Rajesh Kumar is a leading expert in DevOps, SRE, DevSecOps, and MLOps, providing comprehensive services through his platform, www.rajeshkumar.xyz. With a proven track record in consulting, training, freelancing, and enterprise support, he empowers organizations to adopt modern operational practices and achieve scalable, secure, and efficient IT infrastructures. Rajesh is renowned for his ability to deliver tailored solutions and hands-on expertise across these critical domains.

Timeouts look like the least interesting setting in a cloud console. They are one number in one field, usually left at whatever the default was on the day someone created the function. Yet a surprising share of ServerlessOps trouble, including duplicated work, stuck queues and surprise bills, begins with timeout values that do not agree with each other. This article compares the ceilings that different platforms offer, then compares the layers inside a single system, and ends with a method for choosing numbers that fit.

The figures here are taken from the Atlas entry covering ServerlessOps, which frames the subject as day-to-day operation of workloads built from functions and gives specific limits for several services. Those limits change, and the Atlas gives its own figures as of a particular date, so read the numbers below as a snapshot to verify, not as a permanent table.

Comparison one: how long may a single run last?

Different execution models set very different ceilings, and the ceiling tells you what the platform expects you to do with it.

  • Classic function service. The Atlas cites a maximum of 900 seconds, fifteen minutes, per run, with a higher figure of 5,400 seconds on the newer managed-instance variant. This is a service built around short event handlers.
  • Container-based request service. A maximum request timeout of 60 minutes. Here the unit of work is a web request that may stream or hold a connection, so the limit is far longer.
  • A third provider’s flexible plan. A default of 30 minutes. It sits between the other two, and again its default is a setting you can change.

What do these ranges mean in practice? A job that needs forty minutes does not fit a fifteen-minute function without being split up, and splitting it requires state, retries and idempotency. The same job might fit a container-based service with a one-hour ceiling, which moves the effort from design to platform choice. Neither answer is universally right. The question to ask is whether the job is naturally one long task or a sequence of short ones.

A caution about long ceilings

A generous maximum is a limit, not a target. A function allowed to run fifteen minutes but typically finishing in two seconds should not be configured for fifteen minutes, because a stuck call will then hold resources and bill you for the entire period. Set the timeout from observed behaviour, with headroom, instead of from the platform maximum.

Comparison two: how long do events wait?

Time limits also govern the waiting that happens before and after a run. Here the Atlas lists several figures worth setting side by side.

  • On the main function service, an asynchronous event can sit in line for six hours at most, and the platform will try it twice more after the first failure.
  • An event bus drops an undeliverable event after 24 hours or 185 attempts, whichever comes first.
  • A first-in-first-out queue deduplicates only for a five-minute window.
  • A dead-letter queue should keep messages longer than its source does. The example given is fourteen days against four.
  • Stream records on one database stream are retained for 24 hours.

Put those on one timeline and a pattern emerges. The platform’s own patience is measured in hours. Its duplicate protection is measured in minutes. Your failure storage must be measured in days. If an outage lasts longer than the retry window, events go to the failure destination, and if the destination’s retention is short, they vanish. The five-minute deduplication window is the mismatch that catches teams out most often: a replay after a half-hour pause is not recognised as a repeat.

Comparison three: the nesting rule

The layers inside one request path need ordering. The Atlas states the rule in two parts. Any call the function makes to a downstream service has to be abandoned sooner than the function itself would be. And when a queue feeds the function, the queue’s visibility timeout, the period during which a received message is hidden from other consumers, should be no less than six multiples of the function’s own limit.

The reason for the first part is information. If the function is cut off by the platform in the middle of a downstream call, it never learns whether the call succeeded. If instead the call times out first, the function can log the failure, record the state and raise a proper error. The reason for the second part is safety margin. The function may be retried within the same window, and the extra room means that the message does not reappear while an earlier attempt is still running.

A worked set of values

Suppose a function usually finishes in three seconds but occasionally needs ten. A reasonable arrangement, using the rule of thumb above, would be a downstream timeout of eight seconds, a function timeout of twelve and a queue visibility window of at least seventy-two. Those values are illustrative, not recommendations for your system; the point is the ordering, 8 below 12 below 72.

Now suppose someone raises the function timeout to fifteen minutes to fix a rare long run, and leaves the queue at its default of thirty seconds. The queue will hand the same message to another copy long before the first finishes. Two copies work on one message, and your side effects happen twice. This is the usual origin of “ghost duplicates” that engineers struggle to reproduce.

Comparison four: timeout versus retry budget

Timeouts interact with retries multiplicatively. A caller that waits ten seconds and retries three times can hold a resource for forty seconds. If every layer in a path does the same, the totals compound. The Atlas cites the arithmetic for five layers each making three attempts: 243 times the load on the deepest service. That figure is what happens when every layer assumes the others will not retry.

The healthy pattern is for exactly one layer to own retries, usually the one nearest the caller, while deeper layers fail quickly and report. Shorter timeouts at depth make this possible, since a fast failure gives the retrying layer something to act on.

Reading the options like an engineer

It helps to put the options into a small decision table, and ask the same four questions for each workload.

  1. What is the longest legitimate run, and how often does it occur?
  2. What happens to the event if the run fails: retry, park or drop?
  3. How long can a duplicate guard remember, compared with how long a replay can be delayed?
  4. Which single layer retries?

Readers steeped in wider DevOps practice will see this as a flow-control question. If you want to place it in the wider story of how delivery thinking developed, an essay on the future course of DevOps at home and abroad and a retrospective on DevOps over the years, from walled-off operations teams to cloud-native engineering are useful context. Timeouts are a small corner of that story, but they express its central idea: make dependencies explicit instead of hoping.

A note on testing the numbers

Do not trust a timeout table you have never exercised. In a staging copy, make the downstream service deliberately slow, then watch which layer gives up first and what each layer records when it does. Check that the failure lands in the right place and that the message does not reappear early. Ten minutes of this teaches more than an hour of reading, and it turns the ordering rule from a slogan into something the team has actually seen.

What the comparison does not settle

A few caveats. Platform limits move, and managed offerings change names and options faster than documentation spreads; the Atlas itself notes a renaming of function types in October 2026. The numbers above also describe maximums and defaults, not recommendations. And the comparison focuses on time, leaving out memory limits, payload sizes and regional quotas, each of which deserves its own table.

It also does not rank the platforms. Choosing between a function service and a container service involves cost, team skill and workload shape. A time limit is one input. Readers who want the organisational angle on such choices may find an introduction to the glossary of core DevOps terms handy for aligning vocabulary across a team before the debate starts.

A one-page template

Finally, a template small enough for a sticky note. Write the five values for each function that matters: downstream call timeout, function timeout, queue visibility window, source retention and failure-queue retention. Then check the ordering from smallest to largest. The first three should rise in that sequence, with the visibility window at least six times the function limit, and failure retention should exceed source retention. Add a sixth line for the duplicate-guard lifetime, which should outlast whichever retention you rely on for replay. If every function in your system has a sticky note, and every note passes the check, you have removed one of the quietest sources of incidents.

Leave a Reply