Standalone Activities: Durable job processing, now in Public Preview#

If you’ve ever maintained a background job system in production, you already know where this is going. You start with a simple queue for sending emails delivery or processing webhooks. Then you bolt on retries. Then a result store. Then a custom scheduler. Then observability, cobbled together from three different data sources. Before long you’re the owner of a Tier-0 service that nobody signed up to maintain.

One platform team described their homegrown system as “the source of most of our problems.” An engineering manager at another company told us plainly: “I need to get this off my team’s plate.”

Today, we’re announcing the Public Preview of Standalone Activities, Temporal’s answer to durable job processing. Standalone Activities are now production-ready, available across most Temporal SDKs (Go, Python, Java, TypeScript, .NET), and supported in Temporal Cloud.

What are Standalone Activities?#

Temporal Activities can now run on their own, not just as steps inside a Workflow. You write an Activity once and use it anywhere: as a standalone background job or as a step in a multi-step Workflow. If you’ve written a Temporal Activity before, you already know the programming model. Same Activity function, same Activity Worker, same deployment. The only difference is how you invoke it.

from temporalio import activity
from dataclasses import dataclass

@dataclass
class SendEmailInput:
    to: str
    subject: str
    body: str

@activity.defn
async def send_email(input: SendEmailInput) -> str:
    # Your existing email logic - works standalone or in a Workflow
    result = await email_service.send(input.to, input.subject, input.body)
    return result.message_id

To run this as a standalone job, call it directly from a client:

result = await client.execute_activity(
    send_email,
    args=[SendEmailInput("user@example.com", "Welcome", "Hello!")],
    id="welcome-email-user-12345",
    task_queue="email-jobs",
    start_to_close_timeout=timedelta(seconds=30),
)

That’s it. The job is durably persisted, retried on failure, and visible in the Temporal Web UI. There’s no broker to configure, no result backend to wire up, and no scheduler to operate.

Why this matters#

Standalone Activities solve three problems that traditional job queue systems leave on your plate.

1. Durable by default#

When you submit a Standalone Activity, Temporal persists the job to durable storage before acknowledging the request. The job survives Worker crashes, deploys, and restarts. Retries, timeouts, and exponential backoff are configured declaratively rather than reimplemented in application code across every service.

Compare this to systems that rely on in-memory brokers or message queues with visibility timeouts. Jobs can be lost during broker failures, and retry state is scattered across Workers rather than managed centrally.

2. Full visibility and lifecycle control#

Every Standalone Activity is an addressable entity with a stable ID. You can query its status, inspect its last error and retry count, cancel it, terminate it, or delete it from the UI, CLI, SDK, or API. You can list and filter Activities across Task Queues and count them by status.

Screenshot 2026-05-13 at 3.21.25 PM

# List all running email jobs
activities = client.list_activities(
    query="TaskQueue = 'email-jobs' AND Status = 'Running'",
)
async for info in activities:
    print(f"{info.activity_id}: {info.status}, attempt {info.attempt}")

Execution state is first-class in the platform, not a best-effort projection assembled from Worker event streams.

3. Jobs and orchestration in one place#

The same Activity code that runs as a standalone job today can become a step in a multi-step Workflow tomorrow without any changes to the Activity itself.

This matters because most job systems are dead ends. When your business logic outgrows simple fire-and-forget (when you need sequencing, branching, compensation, or human-in-the-loop steps), you typically adopt a separate orchestration system and rewrite everything. With Standalone Activities, that on-ramp to Workflow orchestration is already built in.

Customer quote

“We run hundreds of millions of background jobs a day at Coinbase: fund flows, compliance, customer onboarding. These jobs have to be finished. We built and ran our own system to do that, and it served us well for years. But reliability, isolation, and observability are hard to bolt on top of a job queue, especially at our scale. They belong in the platform. We’ve trusted Temporal Activities inside our workflows for years; Standalone Activities lets us run that same Activity on its own for durable job processing. One tool for jobs and workflows. That’s a simpler stack.” — Edward Zhu, Software Engineer at Coinbase

What's included in Public Preview#

SDKs supported: Go, Python, .NET, Java (pre-release), TypeScript (pre-release), Ruby (coming soon)

Core capabilities:

Durable Execution with configurable retry policies, timeouts, and exponential backoff
Heartbeating for long-running jobs with checkpoint data that survives Worker failures
Conflict and reuse policies for built-in deduplication
Priority and fairness scheduling with no head-of-line blocking and no starvation under load
Manual (async) completion for jobs that depend on external systems
Dedicated Activities view in the Temporal UI alongside Workflows
OpenMetrics support for Activity-level observability

Coming in GA:

Pause, unpause, and reset operations
Update options

Production-ready: Public Preview is suitable for production workloads. Full retention is supported, and Temporal Cloud provides production-level support.

Getting started#

Temporal Cloud users: Standalone Activities are available now. No special enablement required.

Self-hosted users: Available in the latest Temporal Server release.

Pick your SDK and start building:

Read the Standalone Activities concept docs for the full technical overview, or explore Temporal as a job queue to understand how Standalone Activities compare to traditional approaches.

New to Temporal Cloud? Sign up and get $1,000 in free credits to try it out.

What’s next#

Standalone Activities are the simplest entry point to Temporal. Start with a single durable job. Add heartbeating when your jobs run longer. And when your use case outgrows executing a single function reliably, use that same Activity as a step in a Workflow, no rewrite required.

Try it out and tell us what you think on #standalone-activities in Temporal Community Slack!

Standalone Activities: Durable job processing, now in Public Preview