Temporal functions are a modern approach for writing code that runs reliably over extended periods, from seconds to years. Their state and progress are managed by an external system, the Temporal platform, allowing developers to create complex applications without building intricate systems to handle interruptions. The platform acts as an intelligent bookmark, remembering the exact point of execution so a process can resume seamlessly after any pause or failure.
The Challenge of Reliable Automation
Automating long-running software processes is inherently fragile. Many business operations involve multiple steps with potential delays, like waiting for human input or external system responses. These processes are vulnerable to common issues like server crashes, network outages, or application restarts, which can cause serious consequences.
Consider a multi-step online food order where payment is processed, the order is sent to the kitchen, and confirmation is sent to the customer. If the server crashes after the kitchen receives the order but before sending confirmation, the state is lost. The system has no memory of what it was doing, leaving the customer without a confirmation and the business with a potentially unfulfilled, paid order.
This complexity grows when systems are distributed across multiple computers, as each step might be handled by a different service. Manually building systems to recover from such failures is complex and distracts developers from the primary business logic.
Durable Execution as the Solution
Durable execution is the solution to this fragility, ensuring a program’s execution is “crash-proof” and can continue correctly if the underlying hardware or software fails. The Temporal platform provides this durability by acting as an external orchestrator that records a complete history of every function’s progress.
When a server running a piece of code fails, the Temporal platform detects the interruption. It automatically resumes the process on a healthy machine, picking up exactly where it left off. This is possible because the platform preserves the application’s state, including all variable values, so the code continues as if no failure occurred.
This external management of state simplifies the developer’s job. They can write code for the “happy path”—the ideal sequence of events—while the platform handles the complexities of failure recovery. This makes the application code cleaner and more focused on the business objective.
Building Blocks of a Temporal Application
A Temporal application is constructed from core components that work together to achieve durable execution. These building blocks allow for a clear separation of concerns, organizing the business logic from the work being performed.
Workflows
The central component is the Workflow, a function that contains the high-level business logic and orchestrates the sequence of tasks to complete an operation. It defines the order of operations but does not perform the tasks itself. For example, a Workflow for a travel booking would define the steps: book flight, then reserve hotel, then rent a car.
Workflows are designed to be deterministic, meaning they must produce the same output given the same input. They are not allowed to directly interact with the outside world, such as making network calls or accessing a file system. Instead, they delegate these tasks to another component, ensuring the core logic remains isolated and replayable.
Activities
Activities execute single, well-defined tasks on behalf of a Workflow, performing the actual work that involves interacting with the outside world. This is where you would place code to charge a credit card, send an email, call an external API, or interact with a database. Unlike Workflows, Activities are where failures are expected to happen, and the system is designed to handle them.
If an Activity fails—for instance, if a third-party payment service is temporarily unavailable—the Workflow that called it is notified of the failure. The Workflow’s logic can then decide how to proceed. It might instruct the platform to retry the Activity automatically after a delay, or it could execute a different set of steps to compensate for the failure. This separation allows the volatile, unpredictable parts of a process to be managed without corrupting the state of the overall Workflow.
Workers
The code for both Workflows and Activities is hosted and executed by programs called Workers. A Worker process polls the Temporal platform for tasks to execute, such as starting a new Workflow or running a specific Activity. They are stateless and can be scaled up or down independently, providing the computational power to run the applications.
Real-World Examples of Temporal Functions
The concepts of Workflows and Activities become clearer when applied to real-world scenarios. These examples show how Temporal manages complex, long-running processes common in modern applications.
A subscription service is a prime example of a long-running lifecycle managed by a Workflow. When a user signs up, a Workflow instance is created that could last for years. This single Workflow would orchestrate an initial Activity to process the sign-up, then schedule a monthly billing Activity. If a credit card is about to expire, the Workflow could trigger an Activity to send a reminder email. When the user decides to cancel, another Activity handles the cancellation and ends the Workflow.
Travel booking platforms also benefit from this model. A booking process can be encapsulated in a Workflow that calls a series of Activities: one to book a flight, another to reserve a hotel, and a third to rent a car. If the hotel reservation Activity fails because the hotel is fully booked, the Workflow’s logic can execute a compensation task—an Activity that cancels the flight and car rental—ensuring the user isn’t left with a partial, unusable booking.
Another powerful use case is in media processing, which often involves tasks that take hours or even days. A Workflow can manage the entire pipeline for processing a large video file. It would first call an Activity to transcode the video into different formats, then another Activity to add a watermark, and a final one to push the processed files to a streaming service. Temporal ensures that this multi-hour process can survive any server restart or failure, resuming automatically without losing progress.