Join the waitlist for Restate Cloud Get access

Restate is durable async/await for...

Lambda Workflows as Code

  • Workflows as sequential code + RPC
  • No more JSON/YAML + many Lambdas
  • Stellar local dev & debugging experience
  • Long-lived transactional state across workflows
  • Reliable timers & schedulers

Transactional RPC Handlers

  • Idempotency and partial progress recovery
  • Program with simple request-response
  • Executes like async event handlers
  • Full observability
  • Transactional state

Event Processing with Kafka

  • Event handlers as durable functions
  • Consistent dual-/multi writes
  • Delaying events
  • No head-of-line waiting on slow events
  • Durable side effects
  • Flexible routing/fan-out

A bedrock for robust applications

Resiliency & consistency

Durable execution retries on transient failures and recovers partial progress.

Transactional state

Embedded K/V state that commits updates atomically with durable execution progress.


Typescript, Java, and more languages coming


Built in OTel tracing for services and RPCs.

Robust building blocks

Reliable messaging, durable RPCs, transactional K/V store, durable timers, …


Get started

TypeScript Java

1. Develop a service:

npx -y @restatedev/create-app@latest && cd restate-node-template

2. Run your service:

npm install && npm run build && npm run app

3. Launch Restate:

docker run --name restate_dev --rm -p 8080:8080 -p 9070:9070 -p 9071:9071 --add-host=host.docker.internal:host-gateway

4. Register your service:

curl localhost:9070/deployments  -H 'content-type: application/json' -d '{"uri": "http://host.docker.internal:9080"}'

5. Send a request:

curl localhost:8080/myservice/hello -H 'content-type: application/json' -d '{"request": "Restate"}'

Get inspired!

Restate’s flexible SDKs allows you to implement a large set of useful patterns in a few lines of code.

// the request router for the target service
const callee = restate.router({
  call: async (ctx: restate.RpcContext, request: { arg: string }) => {
    // this will be reliably invoked via a durable event from the caller

// defines the logical location and the type signature
const calleeApi = { path: "callee" } as restate.ServiceApi<typeof callee>

// invoke from another Restate-backed service
const result = await ctx.rpc(calleeApi).call("hello " + request);

// invoke (or re-attach) with an external client
`curl http://<restate>/callee/call --json '{"request": {"arg": "..."}}' -H 'idempotency-key: <key>'`

How does it work?

Restate implements low-latency durable execution with a partitioned command log.

The Restate Runtime pushes invocations to services and functions, journals the execution, and handles retries and failover. Via the journal, functions can recover partial progress after failures or actively suspend when waiting.

Restate stores long-lived k/v state for functions and pushes relevant state together with invocations.


cartService: Joe - cart=[]


Deploy anywhere

Restate comes as a single binary that runs without any dependencies. It runs as well on your laptop as it does in the cloud.

Restate is built for modern cloud architectures and works seamlessly with services standalone, on FaaS (AWS Lambda), and as scale-out deployments on container engines like Kubernetes.

Open-source Restate

  • Self-contained single binary
  • BSL-licensed
  • Currently public beta

Restate Cloud

  • Fully managed service
  • Early access version
  • Join the waitlist

Observe everything

Detailed insight in execution progress and state across services

Generate OpenTelemetry traces and call trees for services, without any code or configuration.

Restate's unique way of managing inter-service communication and durable execution together means that it can generate detailed observability data right out of the box.

To the docs

Latest news

Release announcement: Restate 0.8 has arrived 🎉

The 0.8 release of Restate ships many new API improvements such as deterministic promise combinators, operation timeouts, better state management, and much more. Restate now supports patching service state in case you need to repair a service's state. Last but not least, you can deploy Restate on Kubernetes very quickly using the new Helm chart or Restate's Kubernetes operator.

Posted March 7, 2024 by Till Rohrmann and Francesco Guardiani and Giselle van Dongen and Igal Shilman and Jack Kleeman ‐ 4 min read

Code that sleeps for a month

Part two of 'Solving durable execution’s immutability problem': How can we write code that works across time without introducing versioning problems?

Posted February 23, 2024 by Jack Kleeman ‐ 9 min read

Solving durable execution’s immutability problem

The hardest problem in durable execution, as in many areas of infrastructure, is safe updates.

Posted February 2, 2024 by Jack Kleeman ‐ 8 min read

Ready to get started?

Restate is in beta

Try out the preview release of Restate’s managed cloud deployment:

> Get access

Want to get updates on releases
and other news?

> Subscribe