There are many ways to introduce and teach Temporal based on what background you are coming from. Temporal doesn't have a monopoly on explaining Temporal.
Here, we list great blogposts and videos by Temporal staff and users that may be helpful in increasing your understanding or convincing your team.
If you have made a tutorial or explanation of Temporal, please submit them here so that others can find it!
There have been many high-level descriptions of Temporal from our Series A and B PR. This may be helpful for non-technical or technical-adjacent audiences:
- Series B (2022) Linked in our Series B press roundup
- Series A (2020): Linked in our Series A blogpost
How Temporal works
Don't forget our own explainers on What is Temporal!
- ⭐ Designing a Workflow Engine from First Principles by Maxim Fateev (23 min talk given at Systems @ Scale 2021)
- 🆕 Fault Tolerant, Distributed Microservices Orchestration with Temporal (slides) by Maxim Fateev and Tihomir Surdilovic (35 min talk at TheDevConf 2021)
- State of Affairs or Affairs of State by Sergey Bykov (35 min talk on Stateless vs Stateful, Orleans vs Temporal)
- Introduction to Temporal Architecture by Dominik Tornow (16 min talk + Q&A)
- Temporal in 7 Minutes - The TL;DR Intro by swyx (7 min presentation)
- Maxim and Samar on Gremlin's podcast - Origin story, Choreography vs Orchestration, and Tips (21 min listen/read)
- Workflow Engine with Maxim Fateev on Software Engineering Daily (56 min listen)
- Maxim Fateev on Temporal Origin Story on the OSS Startups Podcast (41 min listen)
- Temporal Product with Ryland Goldstein on Software Engineering Daily (53 min listen)
- Temporal Developer Experience with swyx on Devtools.fm (56 min listen)
- Temporal Overview on the MongoDB Podcast (33min listen, starts at 15min mark)
- Temporal vs the Serverless Ecosystem on the Serverless Chats Podcast (65min listen)
- Temporal's previous iteration was Cadence, which shares a lot of the same design principles:
- Cadence Architecture Talk (24 min) by Samar Abbas at the 2017 Uber Cadence meetup
- Cadence: Micro service Architecture Beyond Request/Response (34 min) by Maxim Fateev at Data@Scale 2017
- Note: we have documented the difference between Cadence and Temporal separately.
Why Workflow Orchestration
Build a Reliable System in a Microservices World on Snap Engineering Blog
Building a reliable “simple” microservices system is not simple. It often requires engineers to think through edge cases and write boilerplate error handling logic in any places where systems are integrated. Beyond error handling, in certain systems like payment or billing systems if we are not able to track the application states, it could mean money loss or other worse consequences.
How Chronosphere built a deployment system with Temporal on Chronosphere Blog
Temporal has enabled Chronosphere to more safely and reliably automate complex, long-running tasks. It has also enabled us to easily reuse common activities across different types of workflows. For example, the helper that pauses a workflow if an alert fires can be used by our deployment system and capacity tooling with just a few lines of code. This empowers engineers across different teams to ship features quickly while meeting our rigorous standards for safety and customer trust.
Dealing with Failure on Dev.to
Dealing with failures is the most important aspect of any system. Oftentimes, it is what stands between a product that runs as expected and one that keeps producing surprises and causing investigations. When done right, handling of failures is what differentiates a professional from an amateur.
Microservices Architecture With Temporal.io on the SpiralScout blog
The Temporal Workflows engine is incredibly powerful and provides full control over workflows, including retries, timeouts, backpressure, and the parallel execution of activities. Workflows can be written in most programming languages and include checks, conditions, and sequences of execution.
The macro problem with microservices on the StackOverflow blog
In just 20 years, software engineering has shifted — from architecting monoliths with a single database and centralized state — to microservices where everything is distributed across multiple containers, servers, data centers, and even continents. Distributing things solves scaling concerns, but introduces a whole new world of problems, many of which were previously solved by monoliths.
Temporal Tackles Microservice Reliability Headaches on the New Stack blog
Using code, it aims to hide the complexity of building with microservices across distributed systems. It employs durable virtual memory not linked to a specific process that preserves the application state despite a whole range of possible failures.
Polyglot Microservices with gRPC on the Red Hat blog
Temporal's benefit is that developers can implement activities easily in a variety of languages. Each activity sends its mission-critical data to a gRPC client that forwards it to a gRPC server. The gRPC server then passes all that data from those language-specific tasks onto the backend Temporal service. Temporal does the heavy lifting of ensuring execution in the face of danger, such as a momentary network outage or an unexpected slowdown in disk access.
Using Temporal to outsource operational concerns by Jon Cheng
Unlike Step Functions and Conductor, the entire Temporal Workflow is defined by code. This makes the behavior of the entire program easier to understand. Moreover, for users of the Go or Java SDK, the users may take advantage of the compiler to catch a wide array of errors as well as improve quality in a large team. Then code is guaranteed to execute as you specified on the Temporal Platform. All of the operational stuff: Retries, recovery, persistent state, message queues, scaling, work distribution, tracing and monitoring are all handled by the platform itself. This really is amazing stuff! If C simplified writng portable code, and GC simplified memory management, and serverless simplified scalable architectures, Temporal simplifies implementing a computer program on top of a fragile, distributed system.
A comparison of Temporal Workflows vs Actor Toolkits like Akka and Vert.X by Manuel Bernhardt
Just like actors provide the illusion of single-threaded, sequential execution, workflows provide the illusion of persistent method calls.
Note: Each of our SDK docs have a Hello World and Run Your First App tutorial!
- Alternative Databases
- Getting Started with YugabyteDB, Temporal, and the Temporal-Maru Benchmarking Tool by Eric Pratt (7 min read)
- Just plug it in - Aiven & Temporal by Andrew Staller (7 min read)
- Easily Manage Workflows at Scale with Temporal.io and Astra DB by Melissa Herrera, Ranjan Melanta (10 min read)
- (Go) Intro to Temporal by Horst Gutmann (6 min read)
- (Go) Writing a Workflow, Simulating Failures, Comparing Retries with Apache Airflow, and Testing by Jon Cheng (8 min read)
- (Go) Intro to Temporal Workshop by Márk Sági-Kazár (3 hour full workshop)
- (Go) How to migrate from Mailchimp to Postmark + Temporal by Roelof Jan Elsinga (5 min tutorial)
- (Go) Passing Context with Temporal by Aliaksei Novikau of SpiralScout (7 min read)
- (Go) Creating a custom Temporal data convertor for encryption by Chris Cowell and Rohan Sathe
- Other Languages
- (Español) Construye aplicaciones invencibles con Temporal y Aplicando el patrón SAGA en tus microservicios construidos by Hernán Moreno
- (Türkçe) Nedir Bu Temporal.IO? by Alameddin Çelik
- (русский) PHP Russia talks by Anton Titov
- (中文) Temporal 简介 by Abser Ari 杨鼎睿
- submit yours here!
Mitchell Hashimoto, Hashicorp
So every "cluster create" is a long-running Cadence operation. Once complete, this kicks of a variety of Cadence workflows per cluster that run forever until it is destroyed. This lets you have a central "event loop" per cluster. For example: a "snapshot" triggers an event in the main event loop for a cluster, which ensures that no other ops (upgrades, etc.) are running at the same time, kicks off the snapshot job, then continues.
We have long (multi-day/week) sleeps in the main event loop that wake up to renew TLS certs. And if any of the Cadence workers die, they come back up and continue right where they left off.
Software Delivery Building Blocks at Datadog by Jacob LeGrone and Kevin Devroede (Datadog) (starting at 6min 30s)
Temporal lets [Datadog]:
- write "fault oblivious" stateful control flow and business logic, in the programming language of your choice,
- respond to external events,
- support very long running operations,
- Communicate with 3rd party services
Building Reliable Workflows: Cadence as a Fallback for Event-Driven Processing by Alan Lin (DoorDash)
Moving to a fully asynchronous-based event driven processing system will in our case result in big performance gains as we move off a synchronous processing model for one of our core flows. Eventually... we will eventually build enough confidence in the platform to use it solely for our primary delivery creation flow. This will bring us massive gains in developer productivity due to its ease of use and abstraction of fussy details.
Reuben Bond, Microsoft
"Certain programming models allow more to be in the lower layers, not exposed to the application, due to their semantics and failure models. Eg, as was mentioned with Temporal - the app code is failure oblivious and retries/backoff/jitter/durability can be handled below"
Richard Kettelerij, Mindloops
"Pretty awesome tech. Allows you to express long running processes in a fault tolerant way using Java (or Go) without explicit timers, queues, polling, etc. Like in this example: "pause" a method for 30 days, something you wouldn't normally do."
Ido Shamun, Daily.dev
"A fault-tolerant sleep statement is what caught my attention and convinced me to try @temporalio. This is so fun to use!"
Guillermo Rauch, Vercel
"Temporal does to backend and infra what React did to frontend. If you're in the React world, you've forgotten about manually adding and removing DOM elements, updating attributes and their quirks, hooking up event listeners… It's not only been a boost in developer experience, but most importantly in consistency and reliability. In the backend world, this reliability problem is absurdly amplified as monoliths break into SaaS services, functions, containers… You have to carefully manage and create queues to capture each side effect, ensure everything gets retried, state is scattered all over the place. Temporal's engine is quite complex, much like React's, but the surface exposed to the developer is a beautiful "render()" function to organize your backend workflows."
- Airbyte - ELT data pipeline platform (see talk)
- Roadrunner - PHP application server
- Coinbase/temporal-ruby - Ruby SDK with Rails example
- DataDog/temporalite - Single binary distro for CI (see talk)
- Nunchi Blacksmith - ETL data platform
Everything that doesn't fit above goes here.
If you can't find what you need, don't hesitate to ask on the Temporal Slack, or search in the Forums where there are common questions like:
- What is the best practice for a polling activity?
- How to create a Signalling system for Human driven workflows? SMS OTP use case
- What is the recommended setup for running Cadence/Temporal with Cassandra on production?
- Why use Temporal over a combination of AWS Step Functions and AWS Lambda?
- Do we need Kafka with Temporal?