Past Lambda's 15-minute limit.

Lambda's timeout goes up to 15 minutes. If you are already there, that is the ceiling.

You need more than 15 minutes.

If the timeout is still at the 3-second default, raise it in Configuration > General > Timeout. If you are already at 900 seconds, the AWS path forward is Step Functions: chain Lambda invocations with a state machine. It works, but you are writing JSON state definitions and configuring IAM roles instead of writing Python. ECS removes the timeout but adds containerization. Both solve the problem by wrapping infrastructure around the code you already wrote. There is a simpler option if the work is a Python batch job that just needs to run longer.

handler.py

# Lambda handler
# Timeout: defaults to 3s, configurable up to 900s (15 min)

def handler(event, context):
    items = fetch_all_items()  # Could be thousands

    for item in items:
        result = call_openai(item["text"])
        write_to_dynamodb(item["id"], result)

    return {"statusCode": 200, "body": "Done"}

# If you are looking for the setting: Console > Configuration
# > General > Timeout. Max value: 15 minutes.

qbash Tasks.

A Task is an AI automation written in Python, hosted on a managed runtime. A developer writes the script; anyone runs it from a form. Integrations, model calls, version control, and logging are built in.

Get started Read the SDK docs →

Model and provider agnostic.

Anthropic
OpenAI
Gemini
xAI
OpenRouter
Amazon
Perplexity
MoonshotAI
Meta
Qwen

Same Python, up to 12 hours.

The bottleneck is usually data volume or network, not compute. A 10 GB CSV, a multi-million-row enrichment, an API chain with unpredictable latency. When Lambda times out, in-flight work is lost and a retry starts from scratch. A qbash task runs the same Python on a managed runtime. If it fails at item 4,000 of 10,000, the retry picks up at 4,001. Call it from your existing Lambda over HTTP to offload the long work, or put it on a cron and skip Lambda entirely.

process.py

items = qbash.integrations.postgres.execute_query(
    "SELECT * FROM items WHERE processed = false"
)

results = qbash.parallel(
    process_item, items,
    concurrency=10, max_per_minute=120,
    checkpoint="batch-process", retry=3,
)

qbash.integrations.slack.create_message(
    "#data", text=f"Processed {len(results)} items",
)

What matters once the job runs longer than 15 minutes.

Lambda handles short, event-driven functions well. When the work outgrows that ceiling, retries, checkpoints, and run history become the things you spend time building yourself or get from the runtime.

Checkpoints and retry

qbash.parallel records which items finished. If the run fails at item 4,000 of 10,000, a retry picks up at 4,001. In Lambda, a timeout or error restarts the function from scratch and re-processes every item.

backfill.py

result = qbash.parallel(
    enrich_record, records,
    concurrency=8, max_per_minute=100,
    checkpoint="enrich-backfill", retry=3,
)

failures = [r for r in result if r.get("error")]

Incremental processing

qbash.run.last_run_at returns the timestamp of the previous execution, so each run processes only the rows created since the last one. No state table to maintain and no DynamoDB stream to configure.

sync.py

since = qbash.run.last_run_at

new_records = qbash.integrations.postgres.execute_query(
    "SELECT * FROM events WHERE created_at > %(since)s",
    params={"since": since},
)

for record in new_records:
    qbash.integrations.pipedrive.create_deal(
        title=record["name"], value=record["amount"],
    )

Version history and rollback

Every save creates a version with a line-level diff. Any previous version restores in one click. No CI pipeline, no SAM template, and no CloudFormation stack to manage.

Questions

Can AWS Lambda run longer than 15 minutes?

No. 900 seconds is the hard ceiling. AWS Lambda Durable Functions (late 2025) extend the model for stateful services, but the standard Lambda timeout cannot be raised past 15 minutes.

Why not use Step Functions?

Step Functions works. It adds state machine definitions, IAM policies, execution roles, and a separate deployment pipeline. If you are already in the AWS ecosystem and need complex branching logic, Step Functions fits. If you need to run a Python script longer than 15 minutes, a Task does that with one file and no additional infrastructure.

Can I trigger a Task from my Lambda function?

Yes. Each task has an API endpoint. Call it over HTTP from your Lambda to offload the long-running work to a durable runtime. The Lambda returns immediately and the Task runs in the background.

How long can a Task run?

Up to 12 hours. The default timeout is about 15 minutes per invocation. For longer work, the runtime uses retries and checkpoints to span across invocations, so the task resumes rather than running for hours in one shot.

Does qbash replace Lambda for everything?

No. Lambda is the right tool for short, event-driven functions: API handlers, webhook processors, lightweight transformations. A Task is for the work that outgrows a 15-minute timeout, needs checkpointed retries, or chains integrations and model calls.

Competitor details reviewed 13 August 2026. Vendors change plans and features without notice, so check theirs before deciding.

Ship your first task.

Write the Python, set a trigger, and the platform handles the runtime. Up to 12 hours, with checkpoints that resume on failure.