Time to Temporal
How a thought experiment everyone ignored in 2022 became the roadmap in 2026
In the spring of 2022, Dominik Tornow ran a thought experiment.
He called it TTT — Time to Temporal.
The question was simple: for any given company or platform, how far are they from offering durable execution? Not “will they buy it” or “will they partner” — how much ground would they actually have to cover to stand up a durable execution platform of their own? What’s the distance between what they already run and what Temporal is?
TTT was that distance, measured in effort.
A database company with strong consistency primitives? Closer than you’d think. A message broker with persistence and exactly-the-right storage semantics? Also close. A cloud provider with all of the above? Uncomfortably close.
Internally, the idea went nowhere. The polite version of the feedback was that it was too complex, too abstract, not practical. The impolite version was silence. Interesting thought experiment, Dominik. Anyway.
Here’s the thing about measuring the distance to a destination, though: to do it honestly, you have to define the destination precisely. And once you define durable execution precisely enough to measure anyone’s distance from it, you’ve discovered something the product framing hides.
Durable execution isn’t a product. It’s a set of guarantees.
Four years later
Fast forward to spring 2026. Dominik co-founded Resonate HQ, and the thesis at the center of it is the thought experiment, fully grown:
Durable execution is a protocol, not a product.
Any platform that can give you durable storage plus an atomic compare-and-swap can host the full Resonate protocol — durable promises, tasks, schedules, all of it. That’s the whole list of requirements. Not a cluster. Not a new database. Not a dedicated workflow engine bolted onto your stack. Storage that survives, and one atomic primitive.
And this isn’t a whiteboard claim. It’s been built, three times, on three substrates that could not be less alike:
Relational SQL — the core Resonate server, on SQLite and Postgres
Wide-column NoSQL — a complete implementation of the protocol on ScyllaDB, using lightweight transactions as the CAS
A message broker — a complete implementation on NATS JetStream, using KV compare-and-swap, where the broker is both the storage and the transport
A relational database, a Cassandra-descendant, and a message broker, all speaking the same protocol, all providing the same guarantees. The implementations are independent — not plugins. Each one takes the protocol specification and answers it with whatever the platform natively has.
That last part is the point. The mechanism isn’t “install our adapter.” It’s “your platform already has the primitives — implement the spec against them.”
What this does to TTT
Go back to the 2022 question. How far is any given platform from offering durable execution?
In 2022, the honest answer was: years. You’d need to design the programming model, the recovery semantics, the state machine, the API surface, the failure model — and then build all of it, and then convince anyone it was correct. The distance was the moat. That’s why the question read as academic. Every answer was “far.”
In 2026, the answer is: implement a published protocol against storage you already operate.
And as of today, if you run Postgres, the distance is even shorter than that. All you need to convert it to durable execution is a migration file and the Resonate programming model. Not a new service, not a cluster — a migration.
NATS did not have to become a workflow company. ScyllaDB does not have to acquire one. The protocol meets their platforms where they already were, and the distance has collapsed.
Now extend the list. Confluent has durable storage and the coordination primitives to build a CAS. So does Redis. So does DynamoDB. So does FoundationDB — CAS is practically its love language. Every one of these platforms could offer durable execution directly, through the infrastructure their customers already run, without asking anyone to adopt a new system - just an Async Await programming model.
That’s the inversion. Durable execution stops being a destination you travel to and becomes a capability your existing platform switches on.
In other words: Resonate brings everyone’s TTT to effectively zero.
The part I keep thinking about
The 2022 reaction wasn’t wrong because the people were dumb. It was wrong because the question was ahead of its category. When durable execution meant “a product you deploy,” asking how close everyone else was to building that product sounded like competitive paranoia dressed up as theory.
But Dominik wasn’t asking a competitive question. He was asking a structural one: what is this thing actually made of, and who already has the ingredients? The answer — durable storage plus atomic CAS, which is to say, almost everyone — was sitting there the whole time. It just took defining the protocol precisely enough to see it, and then building it three times to prove it.
The thought experiment didn’t fail. It was a spec waiting for its implementations.
TTT: four years, and falling to zero.