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.
charge_confirm = charge(order.order_id, order.payment_info)
shipment_confirmation = ship(order)
# Represented above is a simple order processing program
# With DURABLE EXECUTION, you code for the single positive result you want to execute
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.
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.
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 and queue-driven design promise ease of deployment and scale, but are a development nightmare.
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.
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.
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 ›
Saga typically requires significant forethought as there is no central system to manage coordination and visibility. Debugging unexpected failure modes can be treacherous.
Workflow definitions allow you to more easily understand, debug, and modify sagas. Tighter coupling for compensations increases and your application code remains clean.
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.
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.
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.
Batch Processes are created to execute a well-defined function across large or even small sets of data.
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.
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.
For years, we have relied on Cron to schedule jobs to be executed at a certain time or regular interval.
Cron is a largely manual process that can be unreliable and provides limited to no controls over execution.
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.
Temporal works with your preexisting choices for runtime, test framework, deployment, continuous integration, web frameworks, and more.
Temporal allows you to develop with durable execution in different languages and multiple languages can be used to build single services, enabling polyglot development.
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.
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.
Founder & CEO, 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.