AWS Lambda Timeout Errors: Fix "Task timed out after X seconds"

AWS CLI

# Increase timeout to 30 seconds
aws lambda update-function-configuration \
  --function-name my-function \
  --timeout 30

# Verify the change
aws lambda get-function-configuration \
  --function-name my-function \
  --query 'Timeout'

AWS SAM (template.yaml)

MyFunction:
  Type: AWS::Serverless::Function
  Properties:
    Handler: index.handler
    Runtime: nodejs20.x
    Timeout: 30        # seconds, max 900
    MemorySize: 512    # more memory = faster CPU

Always set timeouts inside your function code too

Lambda's timeout kills the whole invocation but gives no useful error. Set per-call timeouts on every outbound request so you get actionable errors:

import urllib.request
import urllib.error

def handler(event, context):
    # Check remaining time before expensive operations
    remaining_ms = context.get_remaining_time_in_millis()
    if remaining_ms < 2000:
        raise RuntimeError("Not enough time remaining")

    # Set explicit socket timeout on outbound HTTP calls
    req = urllib.request.urlopen(
        "https://api.example.com/data",
        timeout=10   # seconds — never leave this None
    )
    return {"statusCode": 200, "body": req.read().decode()}

// Node.js: use AbortSignal for fetch timeouts
export const handler = async (event: unknown, context: AWSLambda.Context) => {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), 8_000); // 8 s

  try {
    const res = await fetch('https://api.example.com/data', {
      signal: controller.signal,
    });
    return { statusCode: 200, body: await res.text() };
  } finally {
    clearTimeout(timer);
  }
};

Provisioned Concurrency (all runtimes)

Keeps N execution environments initialized and ready. Eliminates cold starts for that concurrency level but incurs an hourly cost even when idle.

# Publish a version, then enable Provisioned Concurrency
aws lambda publish-version --function-name my-function

aws lambda put-provisioned-concurrency-config \
  --function-name my-function \
  --qualifier 1 \
  --provisioned-concurrent-executions 5

SnapStart (Java 21, Python 3.12+)

Lambda takes a snapshot of the initialized execution environment after your INIT phase. Subsequent cold starts restore from the snapshot instead of re-initializing — typically 10× faster. No extra cost beyond execution time.

# Enable SnapStart on a Java 21 or Python 3.12+ function
aws lambda update-function-configuration \
  --function-name my-java-function \
  --snap-start ApplyOn=PublishedVersions

Keep-alive ping via EventBridge Scheduler

A free option: trigger your function on a schedule every 5 minutes to prevent the runtime from being reclaimed. Not guaranteed — AWS may still replace execution environments — but reduces cold start frequency significantly for low-traffic functions.

# EventBridge rule: ping every 5 minutes
aws events put-rule \
  --name keep-warm-my-function \
  --schedule-expression "rate(5 minutes)"

# In your handler, skip real work on warm-up pings:
# if event.get('source') == 'aws.events': return {'statusCode': 200}

Step Functions — orchestrate multiple Lambda steps

Each Lambda step can run up to 15 minutes. Step Functions chains them with built-in retry, error handling, and state. Total workflow duration can be up to one year.

// Pseudocode: each state calls a Lambda that finishes in <15 min
{
  "Comment": "Long-running data pipeline",
  "StartAt": "Extract",
  "States": {
    "Extract": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123:function:extract",
      "Next": "Transform"
    },
    "Transform": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123:function:transform",
      "Next": "Load"
    },
    "Load": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123:function:load",
      "End": true
    }
  }
}

SQS + Lambda fan-out — parallel chunk processing

Split large work into small items, push them to SQS, and let Lambda process each item independently in parallel. 1000 items that each take 10 seconds finish in 10 seconds total, not 10,000 seconds.

import boto3, json

sqs = boto3.client('sqs')
QUEUE_URL = 'https://sqs.us-east-1.amazonaws.com/123/my-queue'

def dispatcher_handler(event, context):
    # Split work into chunks, enqueue each
    items = get_all_items()          # e.g. 50,000 rows
    for chunk in chunks(items, 100): # 500 messages
        sqs.send_message(
            QueueUrl=QUEUE_URL,
            MessageBody=json.dumps(chunk)
        )

def worker_handler(event, context):
    for record in event['Records']:
        chunk = json.loads(record['body'])
        process(chunk)               # each invocation < 15 min