A durable execution platform that lets you write the code you want

Temporal capabilities

Temporal delivers new development primitives that help simplify your code and allow you to build more features, faster. And at runtime, it's fault-tolerant and easily scalable so your apps can grow bigger, more reliably.

Stop building state machines

Temporal captures the complete state of your functions (variables, threads, blocking calls) so you get the benefits of a state machine, without maintaining complex state machine code.

Set retry policies, don't code them

Temporal allows you to define exponential retry policies for Activities, so you don’t have to write retry logic into your application code. And your retry duration can be as long as needed, even months.

Wait for 3 seconds or 3 months

Set timers to wait for days, weeks, or months, knowing that an outage or server restart during the wait period won’t prevent your workflow from executing.

Schedule, don't Cron

Temporal delivers an ability to schedule a workflow (much like a cron job) and then pause, re-start, and stop them as needed.

Code like a champion, in your language

Temporal allows you to simply code for durable execution, using one or more of our SDKs in Go, Java, Typescript, Python and .NET (and even deploy polyglot workflows).

Incorporate human interactions

Use external sources – including human actions – that interact seamlessly with Workflows.

Never guess what's going on

Temporal allows you to inspect, replay, and rewind every Workflow execution, step by step.

Develop locally, deploy globally

Write code in your preferred language locally, then deploy your workflows and activities using the same software delivery mechanisms you have today.

Don't fight dev patterns, ship code.

Event-Driven Architectures

Event-driven architectures and queue-driven design promise ease of deployment and scale, but are a development nightmare. Without Temporal Event-driven applications are loosely coupled at runtime, but highly coupled at build time. This creates great complexity for error handling and propagation of state across disparate services. With Temporal Application state, retries, and error handling are abstracted away so that you no longer have to code for them. System testing is a breeze because Temporal eliminates common failure scenarios.

SAGA & Distributed Transactions

The saga pattern ensures safe and consistent state across distributed services so that the failure of one operation within a sequence results in prior operations being reversed using compensating transactions. Without Temporal Saga typically requires significant forethought as there is no central system to manage coordination and visibility. Debugging unexpected failure modes can be treacherous. With Temporal Workflow definitions allow you to more easily understand, debug, and modify sagas. Tighter coupling for  compensations increases and your application code remains clean.

Batch Processing

Batch Processes are created to execute a well-defined function across large or even small sets of data. Without Temporal Often, batch processes can be quite large and when they fail, you have limited or no insight into where they failed, what completed and what hasn't. With Temporal Each execution within the batch process becomes a Workflow Execution with state captured, so that upon failure, you have insight into what completed and where to restart the process.

Scheduled Jobs & Cron

For years, we have relied on Cron to schedule jobs to be executed at a certain time or regular interval. Without Temporal Cron is a largely manual process that can be unreliable and provides limited to no controls over execution. With Temporal You can replace Cron with Scheduled Workflows to be reliably executed. You can start and pause them and even set up signals to start them on command for a Workflow.

State Machines

State machines are often used to define and manage valid state and transitions for entities within your application and depending on your application, they can be quite complex. Without Temporal State machine code grows in complexity and length with the addition of each new state and maintenance and testing of them can be a challenge. With Temporal Complete state of your function and workflow is captured, so you no longer need to automate, track and validate state so you can eliminate or avoid state machines.