What Is Restate? The Beginner's Guide to Durable Execution

CodexFuse Team · 2026-11-04T18:36:28.186Z · 11 min read min read

What Is Restate? The Beginner's Guide to Durable Execution

If you have been wondering what is Restate, here is the short answer: Restate is an open-source durable execution runtime that records every step your code runs, so a function that crashes, restarts, or redeploys resumes from its last completed step instead of starting over. You write ordinary functions in TypeScript, Python, Go, Java, Kotlin, Ruby, or Rust; the Restate Server sits in front of your services and journals each durable step — an API call, a database write, a sleep, a state change — before its result returns, which means completed work is never repeated and failed steps are retried until they succeed. This Restate explained guide covers what durable execution means, how the journal works, the three service types, how Restate compares to Temporal, Inngest, and DBOS, and how to run your first durable service locally.

If you are still getting your feet under you with a Linux box to experiment on, start with our Docker guide — Restate ships as a container, and Docker is the fastest way to try it. Pair that with our VPS hosting guide: a cheap always-on server is the natural home for a Restate cluster once you move past localhost.

What Is Restate, Exactly?

Restate is a lightweight runtime that turns AI agents, workflows, and backend services into durable processes by journaling their progress through failures. Restate's own "what is durable execution" guide defines the paradigm directly: "A durable execution engine records each step of a function as it runs, so when something fails, the function resumes from the last completed step instead of restarting from scratch, without losing state, repeating side effects, or requiring custom retry logic." (restate.dev) You may also see it called "workflows-as-code": ordinary functions get the reliability that used to require an orchestrator, a queue, a database for state, and a pile of glue code.

The architecture is deliberately simple: Restate packages its runtime into a single self-contained binary written in Rust, built as a purpose-built database for durable execution with a distributed log and consensus algorithm at its core — no external database required. Your application services run as usual, and the Restate Server sits in front of them like a reverse proxy, persisting journal entries to its replicated log and coordinating calls. One node works for development; production scales to a replicated multi-node, multi-region cluster. As of November 2026 the current release is v1.8.1-hotfix.2, published November 2, 2026. (GitHub Releases, restatedev/restate)

Say this once, because it is the single most important framing: Restate is a durable execution runtime, not a workflow-orchestrator UI. There is no visual canvas of boxes and arrows to manage — your code is the workflow, and the durability is a property the runtime gives it.

How Does Durable Execution Actually Work? The Journal Explained

Durable execution works by journaling progress as code runs: every meaningful step is recorded to a persistent log before its result is observed by the application. If the process crashes, the engine restarts the function and replays the journal — each previously-completed step returns its recorded result instantly, until execution catches up to the point of failure and continues from there.

Here is the crash-recovery arc Restate performs for you, step by step:

1. Step 1 runs and completes. Say it is a payment charge. Restate writes the step's input and result to the journal on the server before returning the result to your function.
2. Step 2 runs and completes. Say it is a notification email. Same deal: journaled first, result returned second.
3. The process crashes mid-step 3. The server is gone, the step's work is unfinished, nothing was journaled for it.
4. You restart. Restate replays the journal: step 1's recorded result is returned instantly (no second charge), step 2's recorded result is returned instantly (no duplicate email), and execution resumes at step 3 — the first unfinished step.
5. Step 3 is retried until it succeeds. If it fails again, it retries; timers, sleeps, and signals all survive restarts the same way.

Two honest nuances live here. First, journaling is how Restate gives you exactly-once-style guarantees without asking you to write idempotency logic for everything — but a step interrupted before its result was journaled can run again on retry, so genuinely side-effecting work still benefits from idempotency keys on the external service. Second, each durable step commits to the replicated log in milliseconds, which is why Restate claims fine-grained durability is practical even for workflows with thousands of steps — Restate reports under 10 ms of latency overhead per durable action under load. (restate.dev/vs/temporal)

What Can You Build With Restate? Services, Virtual Objects, and Workflows

Restate gives you three service types that compose the way your application wants, rather than forcing everything into a workflow-shaped box. A Service is a stateless collection of handlers — ordinary endpoints, but every call through the runtime is durably retried. A Virtual Object is a stateful entity with a unique key: per-key key/value state lives in Restate's embedded store, stays consistent with the code that changes it, and supports exclusive single-writer handlers plus concurrent shared readers — the natural shape for things like user accounts, shopping carts, or agent sessions. A Workflow is a durable function with an exactly-once run handler per ID, plus durable promises that let other code signal it mid-execution — the shape for long-running, human-in-the-loop business processes. (docs.restate.dev/foundations/services)

Beyond the three service types, Restate adds durable RPC (service-to-service calls persisted in internal queues, delivered and retried for you), durable timers and sleeps that survive restarts, and flow control for concurrency limits. The TypeScript quickstart shows how ordinary this looks: a Greeter service with a greet handler that does a durable ctx.run step, a ctx.sleep, and serves on port 9080 — the only new concepts are the ctx object and the fact that the server guarantees what used to be your retry code. (docs.restate.dev/quickstart)

Restate vs Temporal vs Inngest vs DBOS: What's the Difference?

The four runtimes share the journal-and-replay idea but differ in their primary model and operational shape. This comparison uses each project's own description of itself — no third-party benchmarks exist to rank them, and you should not trust a comparison that pretends otherwise.

Two sibling lines to draw once. Temporal is the incumbent workflow engine Restate most often gets compared against; Restate's own framing is that Temporal models applications as workflows and activities with task-queue dispatch, while Restate lets you compose durable functions, RPC, state, and queues in whatever shape fits — and Replit's agent team publicly migrated from Temporal to Restate, with Replit's Michele Catasta quoted on restate.dev saying "Restate fit that bill perfectly. It now handles all durable orchestration at Replit." (treat the accompanying numbers — up to 25,000 durable actions per second per cell — as Restate-reported.) Inngest, by contrast, is the event-driven sibling: our event-driven Inngest guide covers the step-function-as-a-service model — Inngest itself describes Restate as journaling durable handlers "inside a compact runtime," with "less ceremony than a full workflow cluster," which is a fair one-line distinction. (inngest.com/blog/best-job-queue-alternatives) DBOS takes the "just use Postgres" line: durability built directly on the database you already run. None of these is a rival in the sense of doing the same job — pick the model that matches your application's shape.

How Do You Run Restate and Try Your First Service?

This Restate tutorial arc gets the server and a sample durable service running in five steps, straight from the current quickstart docs. (docs.restate.dev/quickstart)

1. Install the server. On macOS: brew install restatedev/tap/restate-server restatedev/tap/restate. Linux gets binaries, Docker images (docker.restate.dev/restatedev/restate:latest), or npm/npx installs.
2. Start it. Run restate-server. The UI opens at http://localhost:9070, and the ingress port for calls is 8080.
3. Scaffold the example service. Run restate example typescript-hello-world, then cd typescript-hello-world && npm install && npm run dev — the service listens on port 9080.
4. Register the deployment. restate deployments register http://localhost:9080 tells the server about your service.
5. Invoke it. curl localhost:8080/restate/call/Greeter/greet --json '{"name": "Sarah"}' returns "You said hi to Sarah!" — and if you kill the server between steps, the call resumes instead of failing.

The Docker route is a single command: docker run --rm -p 8080:8080 -p 9070:9070 -p 9071:9071 --add-host=host.docker.internal:host-gateway docker.restate.dev/restatedev/restate:latest. For real deployments, run it on a box you control — a throwaway VPS sandbox is perfect for learning the registration and invocation flow before anything matters.

Who Built Restate and Why Does It Matter?

Restate was founded by the original creators of Apache Flink — CEO Stephan Ewen, Igal Shilman, and Till Rohrmann, all Flink committers formerly of Data Artisans/Ververica — under Restate Software, Inc. (Restate GmbH), based in Berlin and San Francisco. (TechCrunch, June 2024) The Flink lineage matters because it is a team that has spent a decade on exactly-once stream processing selling you durable execution; they have seen every failure mode a distributed log can produce.

On licensing, one honest sentence: Restate is source-available under the Business Source License 1.1, which converts to Apache License 2.0 four years after each release — ordinary production deployments of your own services are permitted, while running a competing public Restate platform service is not. (LICENSE, restatedev/restate) On money: the company raised a $20M Series A in September 2026 led by Singular with Redpoint Ventures and Capital One Ventures participating, bringing total funding to $27M — a signal that durable execution is a real infrastructure category, not a weekend experiment. (vcaonline.com, eustartups.news)

When Should You Not Use Restate?

Restate is the wrong pick when your workflow's durability needs are trivial. If your "workflow" is a single HTTP request that either succeeds or returns an error page, adding a journal and a replicated log is pure overhead — a plain retry in your handler is enough.

It is also worth one caution: the low-latency story is strongest when the Restate Server is near your services. Every durable step round-trips through the server's log, so a server in another region adds that round trip to each step — run the cluster in the same region as your application, and treat Restate-reported benchmarks as marketing until you measure your own workload.

Sources

• restate.dev — "What is Durable Execution? A Definitive Guide" (Restate Team, updated June 16, 2026) — https://restate.dev/what-is-durable-execution
• restate.dev — "Restate vs Temporal" (Restate Team, updated September 25, 2026) — https://restate.dev/vs/temporal
• docs.restate.dev — Key Concepts, Foundations: Services, Quickstart — https://docs.restate.dev/foundations/key-concepts
• GitHub Releases — restatedev/restate (v1.8.1-hotfix.2, published November 2, 2026) — https://github.com/restatedev/restate/releases
• LICENSE — restatedev/restate (BSL 1.1, converts to Apache 2.0 four years after release)
• TechCrunch — "Restate raises $7M for its lightweight workflows-as-code platform" (June 12, 2024)
• vcaonline.com / eustartups.news — $20M Series A led by Singular (September 30, 2026; $27M total)
• inngest.com — "Best Job Queue Alternatives" (Inngest's own positioning of Restate)
• dbos.dev — "Durable Workflows Just Use Postgres"
• aegisos.cc — "Durable Execution for AI Agents: Temporal, Inngest, and Restate" (9 days ago)

Frequently Asked Questions

What is Restate used for?

Restate is used to make backend services, workflows, and AI agents resilient to crashes and restarts. Typical uses include multi-step order processing, AI agent tool loops where each tool call is journaled so LLM responses are never re-fetched after a crash, and long-running workflows with human-in-the-loop signals.

Is Restate the same as Temporal?

No. Both are durable execution systems, but Temporal models applications as workflows and activities dispatched through task queues to polling workers, while Restate runs durable functions with inline steps, virtual objects, and durable RPC in a single binary with no external database required.

What programming languages does Restate support?

Restate's SDKs cover TypeScript, Python, Go, Java, Kotlin, Ruby, and Rust, per the current quickstart docs. Your services stay ordinary code in one of these languages — the runtime adds the durability around them.

Is Restate open source?

Restate is source-available: it ships under the Business Source License 1.1, which converts to Apache License 2.0 four years after each release. Running Restate for your own production services is permitted; running a competing public Restate platform service is not.

Does Restate need a database?

No external database is needed. Restate is a self-contained binary with an embedded store and a distributed log with consensus at its core; it runs as a single node for development or as a replicated multi-node cluster in production.