What is Durable Execution?

Durable Execution: a new abstraction for developers

Durable Execution is a development abstraction that preserves complete application state so that upon host or software failure it can seamlessly migrate execution to another machine.

Temporal is an open source implementation of Durable Execution created by the originators of the abstraction.

WORKFLOW.PSEUDO

def process_order(order):

check_fraud(order.order_id, order.payment_info)

prepare_shipment(order)

charge_confirm = charge(order.order_id, order.payment_info)

shipment_confirmation = ship(order)

CONSOLE

# Represented above is a simple order processing program

# With DURABLE EXECUTION, you code for the single positive result you want to execute

Code business logic, not plumbing

Temporal delivers durable execution. It abstracts away the complexity of building scalable distributed systems and lets you keep focus on what matters – delivering reliable systems, faster.

It allows you to avoid coding for infrastructure nuances and their inevitable failures.

Home Page Protection Graphic

What if you could avoid the complexity of failure and focus on only what matters?

Ship more features, faster

Temporal eliminates recovery logic, callbacks, and timers from your code so you can spend more time building features.

Code more reliable systems

Temporal makes your software durable and fault tolerant by default, reducing failures by 10-100X.

Gain visibility into execution

Temporal records every execution, its progress and state, providing new insights into errors and app performance.

100% open, 100% open source

Temporal is built in the open and released under the MIT license.
It has been endorsed by some of the world's best companies
and is loved by a growing, vibrant community.

Don't fight development patterns, ship code

Service development patterns try to hide complexity with pictures and concepts, but leave developers to do the dirty work. Temporal abstracts away the complexity of infrastructure and delivers the value you want from these development patterns, without the heavy implementation burden.

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.

EDA Diagram

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.

Read now: Automating the Saga Pattern with Temporal ›

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.

Saga Diagram

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.

State Machine Diagram

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.

Batch Processing Diagram

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.

Schedules Diagram

Temporal works the way you work

Temporal works with your preexisting choices for runtime, test framework, deployment, continuous integration, web frameworks, and more.

Temporal works the way you work

...in your language.

Temporal allows you to develop with durable execution in different languages and multiple languages can be used to build single services, enabling polyglot development.

Code languages

...and in your applications

Temporal is used for a wide variety of applications from transaction processing to control planes to applied AI to content pipelines and more. It's useful anywhere you want to guarantee reliability and correctness.

Order Management

Payment processing

Infrastructure pipelines

Customer on/offboarding

Logistics Management

Applied AI

One of the most interesting pieces of tech I've seen in years… Temporal does to backend and infra, what React did to frontend… the surface exposed to the developer is a beautiful "render()" function to organize your backend workflows.

Guillermo Rauch, Founder & CEO at Vercel

Guillermo Rauch

Founder & CEO, Vercel

Vercel

Temporal's technology satisfied all of these requirements out of the box and allowed our developers to focus on business logic.

Without Temporal's technology, we would've spent a significant amount of time rebuilding Temporal and would've very likely done a worse job.

Mitchell Hashimoto, Co-founder at Hashicorp

Mitchell Hashimoto

Co-founder, Hashicorp

Hashicorp
Globe with pixelated continents and orbitting dashed lines

Temporal Cloud

Reliable, scalable, serverless Temporal in 11+ regions

Run the Temporal Service today, without hassle, and with peace of mind. Pay for only what you use with our managed service, built, managed, and supported by the creators of the Temporal project.

Temporal Cloud

Reliable, scalable, serverless Temporal in 11+ regions

Run the Temporal Service today, without hassle, and with peace of mind. Pay for only what you use with our managed service, built, managed, and supported by the creators of the Temporal project.

Globe with pixelated continents and orbitting dashed lines

Temporal Cloud

Reliable, scalable, serverless Temporal in 11+ regions

Run the Temporal Service today, without hassle, and with peace of mind. Pay for only what you use with our managed service, built, managed, and supported by the creators of the Temporal project.

Globe with pixelated continents and orbitting dashed lines

Build invincible apps

Give your apps and services durable execution.