Start with reliable background jobs, grow to multi-step applications with dynamically scaling compute.#
Today, writing an application or a small job for sending a webhook, generating a PDF, or analyzing an uploaded document is a mostly-solved problem. Running that code reliably, though, means handling failures, tracking progress, and knowing what happens when something goes wrong.
Temporal gives you Durable Execution: it automatically persists the state of your jobs and workflows, coordinates their steps, and retries failed work according to the policies you configure. You can build everything from a single background job to an AI application that runs for days without building your own system to track execution and recover from failures.
However, your code still needs compute to run. In Temporal, that code runs as a Worker: a process that picks up work and executes it in your infrastructure. Serverless compute lets that capacity grow as work arrives and return to zero between bursts, so for intermittent workloads you avoid an always-on Worker fleet and paying for compute that sits idle.
Temporal Serverless Workers combine Durable Execution with on-demand, serverless compute in your own cloud account. Temporal Cloud provides the managed, highly reliable backend that tracks the work and starts Workers as capacity is needed; AWS Lambda or Google Cloud Run Worker Pools run your code and manages the underlying infrastructure.
How do you run reliable background jobs with Temporal?#
Imagine your application delivers webhooks when a customer’s order ships. Your customer’s endpoint might be temporarily unavailable, or your worker might crash after sending the request. You need to track the delivery, retry when appropriate, and find out whether it eventually succeeded.
In Temporal, you write the delivery function as an Activity. An Activity performs work such as calling an API, writing to a database, or processing a file. You can submit it directly to Temporal as a Standalone Activity, which makes it a durable background job without also requiring you to define a larger Workflow around it.
Temporal persists the job before dispatching it, applies the retry policy and timeouts you configure, and lets you inspect its status and retrieve its result. Each job has an identifier you can use to find or cancel it.
Add Serverless Workers on AWS Lambda, and the job queue also gets compute on demand:
- Your application submits a webhook delivery job to Temporal.
- Temporal queues the work and invokes your Lambda worker when capacity is needed.
- The worker picks up jobs, runs your delivery function, and reports the results.
- When available work is finished, the worker exits.
A single Lambda invocation can process multiple jobs. The same pattern works for transactional emails, PDF generation, image processing, and data synchronization. Each starts with a function you want to run reliably in the background; check out the webhook delivery tutorial for an example.
Turn document uploads into a dynamically scaling processing application#
Now consider an application that analyzes customer documents: a user uploads a file, and your application extracts its text, sends sections to a model, validates the response, and produces a report.
Those steps depend on one another, so something has to remember which ones finished and decide what happens next. A Temporal Workflow is that something: the thing that coordinates and preserves the application’s progress.
Your Workflow consists of separate steps, each defined as individual Activities, that interact with the outside world. If your model API is temporarily unavailable, Temporal can retry that Activity according to its policy while retaining the results of completed steps.
Document uploads might arrive sporadically during the day or in a burst when a customer imports a collection of documents. Serverless Workers follow that demand without a custom autoscaler or metrics pipeline: you tell Temporal where your Worker lives and it handles the rest.
Build applications that can run indefinitely, efficiently#
Some applications spend more time waiting than computing.
An AI assistant might gather information, propose an action, and wait for a person to approve it. An onboarding process might create an account, request verification, and wait for another system to respond.
A Workflow can preserve that state while it waits for a message or timer, so an application that lasts days doesn’t need one Lambda invocation to stay alive for days. Each Worker lifetime only needs to run the code needed to make progress. Temporal retains the state needed to continue, across as many sessions as the application takes. That extends what serverless compute can do, because a long-running application no longer needs compute running continuously.
You can also reuse the Activity you already wrote for a standalone job and your webhook delivery function can become the final step of an order-processing Workflow without rewriting the function.
Which compute options do Serverless Workers support?#
Temporal Serverless Workers meet you where you are, with compute options for AWS and Google Cloud and runtimes suited to different workloads. You can bring Durable Execution to the cloud services your team already uses, whether you’re building a background job queue, a document-processing pipeline, or an AI agent.
- AWS Lambda for event-driven or highly scalable jobs and applications. Run webhook deliveries, notifications, and document processing work on demand in your AWS account. Temporal invokes workers as capacity is needed, so you can handle bursts without keeping a worker fleet running between them. Lambda documentation.
- Google Cloud Run Worker Pools for containerized workloads with no infrastructure to manage. Run your workers as containers in your Google Cloud project, including workloads that need longer execution times. Cloud Run hosts the containers, while Temporal adjusts the pool’s capacity as demand changes and can scale it to zero when there is no work. Cloud Run documentation.
- Amazon Bedrock AgentCore Runtime for agentic applications on AWS. Run Temporal workers in a runtime built for agents, alongside AgentCore services for identity, tool access, memory, and observability. Temporal preserves the agent’s execution progress and coordinates model calls, tool calls, and approvals; AgentCore supplies the compute and agent services you choose to use. AgentCore documentation.
Across all three, you use Temporal’s programming model for Durable Execution while your workers run in your own cloud account. As of October 2026, Lambda and Cloud Run support are in Public Preview; AgentCore Runtime support is in Pre-release.
Start with a durable batch job, evolve into a Workflow, and never worry about compute#
Start your Temporal journey with a background job your application already needs. Our Standalone Activities tutorial builds a webhook delivery service and demonstrates retries, duplicate handling, and job visibility.
Then follow the Lambda deployment guide to package your worker, grant invocation permissions, and connect its deployment to Temporal.
You can begin with a single function and on-demand compute via Serverless Workers. When the application needs several coordinated steps, the Activity you wrote can come with you and become part of a Workflow. Your Serverless Workers will be there, waiting to scale to exactly what your ever-evolving workload requires.