AWS Lambda 30-minute timeout, 19 Nov 2026: which jobs can drop Step Functions

Lambda's on-demand timeout doubled to 30 minutes on 19 Nov 2026. Jobs of 15 to 30 minutes can drop chunking, but callers and queues still cap them.

Read time
15 min
Word count
2.4K
Sections
8
FAQs
8
Share
Two engineers sort planning cards beside a laptop and server chassis, with AWS, Lambda and Step Functions marks
On this page · 8 sections
  1. What changed on 19 November 2026
  2. Which workloads can drop their workarounds
  3. What still caps you: callers, queues and retries
  4. Cost: when Lambda beats Fargate, and when it does not
  5. A migration checklist for the 30-minute limit
  6. India-specific considerations
  7. How eCorpIT can help
  8. References

Summary. On 19 November 2026 AWS raised the maximum timeout for Lambda Event Functions running on demand from 15 to 30 minutes (1,800 seconds), for synchronous, asynchronous and event source mapping invocations, in all commercial AWS Regions. AWS names AI inference, media transcoding and financial calculations as the target workloads, and the limit also applies inside Lambda durable functions and when Step Functions Standard workflows call a function. Pricing is unchanged: $0.0000166667 per GB-second on x86 and $0.20 per million requests, the same in US East (N. Virginia) and Mumbai. A 25-minute job at 10,240 MB therefore costs about $0.25 per run, or $250.00 (about ₹23,170) for 1,000 runs a month. Lambda Managed Instances keep the 90-minute ceiling for asynchronous and event source mapping calls that arrived on 9 September 2026, and now allow 30 minutes for synchronous calls. Our verdict: event-started, bursty jobs that run 15 to 30 minutes can drop chunking logic and Fargate side-paths. But API Gateway still stops waiting after 29 to 30 seconds by default, SQS queues need a visibility timeout of at least 3 hours, and steady heavy compute is still cheaper on Fargate.

About this article. This is for cloud architects, platform engineers and engineering leads who run AI inference, media or batch work on AWS, including Indian teams building for US and UK clients. On 21 November 2026 we checked the launch, the new limits, caller timeouts, queue rules and prices against the AWS What's New posts, the Lambda, SQS, API Gateway, Step Functions and ECS developer guides, the AWS Compute Blog and AWS's published price data. Prices are list prices for US East (N. Virginia) unless stated, and AWS can change them. This is general information, not procurement advice, and no vendor paid for inclusion. Researched with AI assistance and checked against the primary sources listed in the references.

What changed on 19 November 2026

The launch uses AWS's newer name, Event Functions, for the original Lambda function type. The name is cosmetic: the API operations, SDKs, CLI and the AWS::Lambda::Function resource type still say function, so no code changes are needed. What did change is the ceiling. The timeout setting still defaults to 3 seconds and moves in 1-second steps, but its maximum is now 1,800 seconds.

Compute mode and invocation Maximum before Maximum from 19 Nov 2026
On demand, synchronous 15 minutes 30 minutes
On demand, asynchronous 15 minutes 30 minutes
On demand, event source mapping 15 minutes 30 minutes
Managed Instances, synchronous 15 minutes 30 minutes
Managed Instances, asynchronous 90 minutes since 9 Sep 2026 90 minutes
Managed Instances, event source mapping (not MQ or DocumentDB) 90 minutes since 9 Sep 2026 90 minutes
Durable function, whole execution (asynchronous) Up to 1 year Up to 1 year

The table combines the launch post, the timeout page, the Managed Instances blog and the Event Functions guide. On Managed Instances, the 30-minute synchronous limit applies wherever Managed Instances are offered, and there is no extra charge for the longer limit on either compute type.

Other per-function limits did not move. Memory still runs from 128 MB to 10,240 MB, /tmp storage tops out at 10,240 MB, synchronous request and response payloads are capped at 6 MB each (200 MB for a streamed response), and asynchronous payloads at 1 MB. The default regional concurrency quota is still 1,000, and new accounts start lower; that matters more now that each long call holds a slot for twice as long.

Which workloads can drop their workarounds

Before this launch, a job that needed 16 to 30 minutes of continuous compute had three usual escapes: split it into chunks under 15 minutes and stitch them with Step Functions, move it to an ECS task on Fargate, or move it to Managed Instances and accept their EC2-based model. AWS says the 15-minute cap forced exactly these workarounds on data-heavy inference and media work.

Workload pattern Good fit for 30-minute Lambda now? Why
Batch AI inference on a file or document set, 15 to 30 minutes Yes Event-started, bursty, fits in 10 GB memory
Media transcode of one asset, 15 to 30 minutes, CPU only Yes, if inputs fit in 10 GB of temp storage No chunk stitching needed
Nightly risk or pricing calculation per portfolio Yes Fan-out by event, each item under 30 minutes
Job that needs a GPU No On-demand Lambda and Fargate have no GPU; use Managed Instances on GPU instances or ECS on EC2
Job over 30 minutes that cannot checkpoint No Use Managed Instances (async, 90 minutes) or Fargate
Job over 30 minutes that can checkpoint Maybe Durable functions run up to a year across many invocations
Synchronous API call that takes minutes No API Gateway stops waiting after 29 to 30 seconds by default
Steady, high-volume compute all day Usually no Fargate or Managed Instances cost less per run

The GPU row follows from the Managed Instances guide, which offers GPU-accelerated EC2 instances for Event Functions, and from the ECS guide, which lists the GPU parameter as not valid for Fargate tasks. The durable row follows from the durable functions guide: executions checkpoint and replay, and waits incur no compute charge. If you are choosing between durable functions and Step Functions for multi-step flows, our explainer on Lambda durable execution versus Step Functions covers the trade-offs.

AI inference

The clearest win is batch inference on CPU: embedding a document set, running a small open model over a queue of files, or scoring a model against a batch of records. Lambda allocates CPU in proportion to memory, with 1,769 MB equal to one vCPU, so a 10,240 MB function gets about 5.8 vCPU-equivalents (10,240 divided by 1,769). Jobs split into two 12-minute chunks only because of the cap can now run in one invocation, which removes the state hand-off between chunks. For GPU-bound or always-on serving, the calculation is different; our comparison of production AI inference platforms covers that side.

Media processing

A single-asset transcode that took 20 minutes used to need segmenting, parallel encodes and a final concatenation step, usually orchestrated by Step Functions. With 30 minutes, the one-function version works if the source and output fit inside the 10,240 MB /tmp limit and the encoder fits in a container image (up to 10 GB uncompressed) or a .zip package (250 MB unzipped). Two details affect the bill. Network bandwidth is 625 Mbps per execution environment by default, so pulling a 10 GB source takes about 131 seconds of billed time (81,920 megabits divided by 625). Storage above the free 512 MB is charged at $0.0000000309 per GB-second, so 9.5 GB extra for 25 minutes adds about $0.0004 a run. Segmenting is still worth keeping where it shortens wall-clock time for users, because parallel chunks finish sooner than one long encode.

Batch and financial calculations

Event-driven batch work, such as a per-portfolio valuation started by a file landing in S3 or a message on a queue, fits well when each unit finishes in under 30 minutes. If a unit can exceed 30 minutes on a bad day, keep a fallback. A timeout is an error, and for asynchronous calls Lambda retries a failed event twice by default, waiting one minute and then two minutes. Three 30-minute attempts that all time out cost three times as much and still fail.

What still caps you: callers, queues and retries

The function can now run for 30 minutes. Whatever invokes it may not wait that long, and you pay for the full run either way. The caller limits below come from the Lambda guide, with the REST and HTTP API details from the API Gateway quota pages.

Caller How long the caller waits
API Gateway REST API 29 seconds by default, can be raised for Regional and private APIs
API Gateway HTTP API 30 seconds maximum
Amazon Cognito user pool trigger 5 seconds
AWS Step Functions Until the function returns
Lambda function URL Until the function returns

Raising a REST API integration timeout above 29 seconds may require AWS to cut your Region-level throttle quota, and edge-optimised APIs cannot be raised at all. For a long job behind an API, the pattern is unchanged: accept the request, invoke the function asynchronously or drop a message on a queue, and return a job ID the client can poll.

SQS queues need a longer visibility timeout first

For an SQS event source mapping, AWS recommends a queue visibility timeout of at least six times the function timeout, plus any batching window you set. A 30-minute function therefore needs a visibility timeout of at least 3 hours (30 times 6 is 180 minutes). Lambda checks that the function timeout does not exceed the visibility timeout when you create or update the mapping, but not when you later change the function timeout. If you raise the function timeout first, messages can reappear while still being processed and be handled twice, so raise the queue setting before the function setting. SQS allows up to 12 hours of visibility, so the 3-hour target fits.

Asynchronous retries and event age

For asynchronous calls, function errors including timeouts trigger two retries by default. Throttles and system errors are retried for up to 6 hours by default, with back-off growing to a maximum of 5 minutes between attempts. With longer functions holding concurrency for longer, throttling becomes more likely at the 1,000 default quota, so check reserved concurrency and the maximum event age before you raise timeouts across an estate.

Cost: when Lambda beats Fargate, and when it does not

The price list did not change on 19 November. We costed one job: 25 minutes of compute per run, 1,000 runs a month, in US East (N. Virginia), before free tier. Rupee values use the ECB reference rates of 20 November 2026, crossed to ₹92.68 per US dollar and rounded to two decimals.

Option Configuration Cost per run Cost per 1,000 runs
Lambda x86 10,240 MB, about 5.8 vCPU-equivalent $0.25 $250.00 (about ₹23,170)
Lambda Arm 10,240 MB $0.20 $200.00 (about ₹18,536)
Fargate Linux x86 4 vCPU, 10 GB $0.086 $85.99 (about ₹7,969)
Fargate Linux Arm 4 vCPU, 10 GB $0.069 $68.80 (about ₹6,376)

The arithmetic: 1,500 seconds times 10 GB is 15,000 GB-seconds, and 15,000 times $0.0000166667 is $0.25 on x86, or times $0.0000133334 is $0.20 on Arm. Fargate x86 bills $0.04048 per vCPU-hour and $0.004445 per GB-hour, so 4 vCPU and 10 GB cost $0.20637 an hour, and 25 minutes cost about $0.086. Fargate Arm at $0.03238 and $0.00356 gives $0.16512 an hour and about $0.069 per run. A 4 vCPU Fargate task can take between 8 GB and 30 GB of memory. Request charges add $0.0002 per 1,000 Lambda runs, and the Lambda free tier of 400,000 GB-seconds a month would cut about $6.67 off the x86 total.

Two caveats keep this honest. First, the two are not the same machine: Lambda at 10,240 MB has more CPU than a 4 vCPU task, so a CPU-bound job may finish sooner on Lambda, and you should benchmark both. Second, Fargate's per-run figure assumes the task runs only while working. Lambda still wins on spiky traffic, on zero idle cost and on the absence of cluster, image-pull and task-scheduling plumbing. For a steady stream of heavy jobs, Fargate or Managed Instances stay cheaper. Managed Instances bill the EC2 instance price plus a 15% management fee, and EC2 Savings Plans or Reserved Instances discount only the EC2 part. Since 20 November 2026, AWS Trusted Advisor flags on-demand functions that would cost less on Managed Instances, for customers on eligible Support plans, in four Regions: N. Virginia, Oregon, Ireland and Milan. Our guide to sizing AWS Savings Plans coverage helps with the commitment side.

What removing Step Functions saves

Less than you might think in direct fees. Standard workflows cost $0.025 per 1,000 state transitions in US East (N. Virginia) after 4,000 free transitions a month. A chunked job using 6 transitions per run, 1,000 runs a month, uses 6,000 transitions, and the 2,000 billable ones cost $0.05. The real saving is engineering: no chunk-state hand-off, no stitching step, fewer failure paths and one log stream instead of several. Keep Step Functions where it does more than work around a timer, such as human approval, cross-service orchestration, or audit history, which Standard workflows retain for 90 days after an execution ends. Express workflows remain capped at five minutes, so they were never a fix for long jobs.

A migration checklist for the 30-minute limit

  1. Find the candidates. List functions that are chunked only because of the old 15-minute cap, and ECS tasks moved to Fargate for the same reason. Check their p99 duration, not the average, against 30 minutes.
  1. Check the caller. If an API Gateway route waits on the result, switch to an asynchronous pattern before raising the timeout.
  1. Raise queue visibility first. Set SQS visibility to at least six times the new function timeout plus any batching window, then change the function.
  1. Review retries and concurrency. Set maximum retry attempts and event age for asynchronous calls, add a dead-letter queue or on-failure destination, and recheck reserved concurrency against the 1,000 default.
  1. Set the timeout. Use the console, the CLI (aws lambda update-function-configuration --function-name my-function --timeout 1800), SDKs, CloudFormation, CDK or SAM.
  1. Re-cost it. Price the single function against the old chunked flow and against Fargate at your real duration and memory.
  1. Test at real size. AWS warns that test data is often smaller than production and hides timeouts, so test with inputs at the upper bound you expect. Our guide to serverless integration testing shows local and cloud setups.

India-specific considerations

The 30-minute limit is live in all commercial Regions, which includes Mumbai and Hyderabad. Lambda's on-demand duration and request prices in Mumbai match US East (N. Virginia), but Fargate is slightly dearer there on x86 at $0.04256 per vCPU-hour and $0.004655 per GB-hour, and cheaper on Arm at $0.02383 per vCPU-hour and $0.00261 per GB-hour. The new Trusted Advisor recommendations are not offered in any Indian Region yet, so Mumbai teams need to run the Managed Instances comparison themselves. Teams processing personal data under the DPDP Act should note that moving a job from chunks to one function changes nothing about where data is processed, but it does reduce the number of intermediate copies written to S3 between chunks, which simplifies retention and deletion.

How eCorpIT can help

eCorpIT is a Gurugram-based technology organisation, founded in 2021, assessed at CMMI Level 5 and MSME certified, with senior-led engineering teams working across AWS, Microsoft and Google platforms. Our cloud computing services team can audit your Lambda, Step Functions and Fargate estate, cost the 30-minute option against your real job durations, and retire workarounds that no longer earn their keep. Talk to us at /contact-us/.

Last updated: 21 November 2026.

References

  1. AWS Lambda now supports a 30-minute timeout for on-demand Event Functions, 19 November 2026 — Amazon Web Services
  1. Configure Lambda Event Function timeout — AWS Lambda Developer Guide
  1. AWS Lambda pricing (read 21 November 2026) — Amazon Web Services
  1. Euro foreign exchange reference rates, 20 November 2026 — European Central Bank
  1. Announcing 90-minute function timeout on AWS Lambda Managed Instances, 9 September 2026 — AWS Compute Blog
  1. Invoking Lambda with events from other AWS services, response timeouts for synchronous callers — AWS Lambda Developer Guide
  1. Creating and configuring an Amazon SQS event source mapping — AWS Lambda Developer Guide
  1. AWS Fargate pricing (read 21 November 2026) — Amazon Web Services
  1. AWS Lambda Event Functions (formerly Lambda functions) — AWS Lambda Developer Guide
  1. Lambda quotas — AWS Lambda Developer Guide
  1. Lambda Managed Instances — AWS Lambda Developer Guide
  1. Amazon ECS task definition differences for Fargate — Amazon ECS Developer Guide
  1. Lambda durable functions — AWS Lambda Developer Guide
  1. Configure Lambda function memory — AWS Lambda Developer Guide
  1. How Lambda handles errors and retries with asynchronous invocation — AWS Lambda Developer Guide
  1. Amazon API Gateway quotas for configuring and running a REST API — Amazon API Gateway Developer Guide
  1. Quotas for configuring and running HTTP APIs — Amazon API Gateway Developer Guide
  1. Amazon SQS visibility timeout — Amazon SQS Developer Guide
  1. AWS Lambda now provides cost optimization recommendations for Event Functions, 20 November 2026 — Amazon Web Services
  1. AWS Step Functions pricing (read 21 November 2026) — Amazon Web Services
  1. Choosing workflow type in Step Functions — AWS Step Functions Developer Guide

Frequently asked

Quick answers.

01 What is the new AWS Lambda maximum timeout?
Since 19 November 2026, Lambda Event Functions running on demand can be set to time out after up to 1,800 seconds, which is 30 minutes. That applies to synchronous, asynchronous and event source mapping invocations in all commercial AWS Regions. The default timeout is still 3 seconds, so you must raise it yourself.
02 Does the 30-minute timeout cost extra?
No. AWS says standard Lambda pricing applies, so you pay the same per GB-second and per request as before. A longer timeout only costs more if your function actually runs longer. Remember that a function keeps running and billing until it returns or times out, even if its caller has stopped waiting.
03 Can API Gateway now wait 30 minutes for a Lambda response?
No. REST APIs wait 29 seconds by default and HTTP APIs at most 30 seconds. REST API Regional and private endpoints can be raised above 29 seconds, but AWS may reduce your throttle quota. For long jobs, accept the request, run the function asynchronously and let the client poll for the result.
04 What do I change for an SQS-triggered function?
Raise the queue's visibility timeout first, to at least six times the function timeout plus any batching window, so at least 3 hours for a 30-minute function. Then raise the function timeout. Lambda does not check this when you change only the function timeout, and messages could be processed twice if the order is reversed.
05 How does this compare with Lambda Managed Instances?
Managed Instances run Event Functions on EC2 instances that Lambda manages, priced at the EC2 rate plus a 15% management fee. Since 9 September 2026 they allow 90 minutes for asynchronous and most event source mapping calls, and from 19 November 2026 synchronous calls get 30 minutes. They suit steady traffic and GPU work.
06 Should I stop using Step Functions?
Only where it exists solely to split work around the old 15-minute limit. The direct fee saving is small, often a few cents a month, but you lose chunk hand-offs and failure paths. Keep Step Functions for approvals, multi-service orchestration, long waits and audit history, which Standard workflows keep for 90 days.
07 Is Lambda now cheaper than Fargate for long jobs?
Not for steady heavy compute. In our 25-minute example, Lambda at 10 GB cost about 0.25 dollars per run against about 0.09 dollars for a 4 vCPU Fargate task. Lambda wins on bursty traffic, zero idle cost and less infrastructure to run, so benchmark your own job before moving it.
08 Does the change apply in the Mumbai Region?
Yes. AWS says the 30-minute timeout for on-demand Event Functions is available in all commercial AWS Regions, which includes Mumbai and Hyderabad. Lambda duration and request prices in Mumbai match US East (N. Virginia), while Fargate x86 is slightly more expensive there and Fargate Arm slightly cheaper.

About the author

Manu Shukla

Founder & Director

Founder of eCorpIT. Hands-on engineer leading senior-only delivery for AI apps, custom software, and cloud systems for global clients.

Subscribe

One engineering note a week. No fluff, no spam.

Senior-architect playbooks on AI agents, mobile apps, cloud, security, data, and marketing — delivered every Wednesday.

Past the reading

Read enough. Let's build something.

A senior architect responds in 24 working hours with scope, indicative cost, and a timeline. NDA before any technical conversation.

Loading search…

Browse all guides