Today we are excited to announce a major milestone for Restate: the availability of Restate 1.0, early access to Restate Cloud, as well as our Series Seed funding round led by Redpoint Ventures, with participation from Essence VC, firstminute.capital and several angel investors (more on that below).

But first… an introduction to Restate #

For those who are new to Restate, allow us to introduce ourselves.

When building applications, we have the most amazing building blocks at our disposal, like fast and scalable databases, simple APIs to access powerful tools like LLMs or messaging, and infrastructure to run them in distributed manner that survives crashes, failures, and outages of entire data centers.

And yet, it is still surprisingly hard to build resilient applications, especially when correctness and reliability are paramount, because there are so many loosely coupled moving parts to deal with. Our daily business is now stuff like writing code to recover partial failure scenarios, debugging distributed concurrency issues, or wrangling with infra to get reliable ordered callbacks for an asynchronous task.

Enter Restate #

Restate takes the guesswork out of building distributed applications. Core to the system is a unique take on workflows-as-code (also called Durable Execution) implemented on a specialized event log that lets it handle use cases that have previously been out of reach for workflow systems.

Restate is low latency, lightweight to run, and interoperates seamlessly with serverless platforms (FaaS). Restate’s APIs let developers use workflows-as-code semantics and other tools like Durable Promises/Futures or atomic state directly in their functions and (micro)services, rather than needing to refactor and redeploy the application to a workflow system.

Restate makes it mind-blowingly simple to build distributed apps and asynchronous logic. Below is an example of how easily you can build an agent system with an LLM chatbot interface and let Restate reliably handle all context and memory, async interactions, scheduled tasks, and reliable communication. Everything just works through failures and crashes, without having to write any code for handling infra-failures at all.

Even if building a chatbot isn’t on your task list today, Restate helps with a broad spectrum of use cases:

• Serverless task queues and event processing
• Workflows (e.g., user-signups, payment processing, order processing, invoicing) or custom workflow interpreters
• Service orchestration (e.g., inventory management, reservation systems)
• Microservice architectures, like a food delivery service where Restate runs order workflows, digital twins for the drivers, order-driver-matching, and handles communication between services.

What makes Restate stand out is how it brings together a unique set of properties that bring the magic of workflows-as-code and event-driven applications into more use cases and in an easier form than ever before.

1. A unique programming model combining Durable Execution (workflow-as-code) with Durable Promises/Futures for communication and Virtual Objects for state management.
2. A low-latency architecture that brings workflows-as-code to latency-sensitive services.
3. A free, open, and source-available runtime, shipping as a self-contained single binary. Run it locally, in containers, in the Cloud - Restate is lightweight to run and operate.
4. Direct support for FaaS (like AWS Lambda or Cloudflare Workers). Deploy workflows-as-code and other services on FaaS platforms and don’t pay for wait times.

Many of the design principles behind Restate are inspired by our previous work on Stream Processing and Apache Flink, but re-thought for general-purpose applications and transaction processing.

Here is what Restate’s early users and supporters say:

“It’s still challenging to make distributed transactional applications correct, resilient, and scalable. Restate’s approach of marrying durable execution and event-driven architectures is a big step towards fixing that.”

– Jay Kreps - Founder / CEO @ Confluent

“Restate is tapping into a huge opportunity to radically simplify the way resilient applications are built today. The team has a track record of building leading solutions with Apache Flink and is releasing another outstanding technology with Restate 1.0 today. They’re well positioned for success and we are thrilled to lead their Seed round.”

– Jordan Segall - Partner @ Redpoint Ventures

“Restate’s focus on simple APIs to do complex things is what attracted me to try it. We are now using it to handle 90+% of production workloads. I cannot recommend it enough!”

– Vishal Thukral - Founding Engineer, Health-tech Startup

Announcing Restate 1.0 #

Restate 1.0 is our latest release, which incorporates a load of feedback that we received since we released our first early version last December. Here are some of the highlights:

Most importantly, starting from this version, Restate will maintain compatibility for APIs and storage.

1. TypeScript, Java, Kotlin #

Restate 1.0 has matured the Java and Kotlin SDKs to bring them on-par with the TypeScript SDK in terms of features and flexibility. All languages add new features like workflow constructs with shared promises to support signals and queries.

const signup = workflow({
  name: "usersignup",
  handlers: {
    run: async (ctx: WorkflowContext, params: { ... }) => {
      // ...
      const secret = await ctx.run("gen secret", () => crypto.randomUUID());
      await ctx.run("send email", () => sendEmailWithLink({ email, secret }));

      const clickSecret = await ctx.promise<string>("email-secret");
      if (clickSecret !== secret) {
        throw new TerminalError("verification failed");
      }
      // proceed with verification
    },

    linkClick: async (ctx: WorkflowSharedContext, secret: string) => {
      ctx.promise<string>("email-secret").resolve(secret);
    }
  }
});

2. Durable Execution, Durable Promises/Futures, Virtual Objects #

All application logic is ultimately a combination of computation, communication, and state management. Correctly handling the interplay of those is what makes an app resilient and correct.

Restate 1.0 encapsulates this as core building blocks: Durable Execution (workflow-as-code) for resilient compute, Virtual Objects for state management, Durable Promises/Futures for resilient communication & asynchrony. Check out the Intro to Restate’s Programming Model for details.

3. Handlers = Async Tasks = Workflows = Deferrable Functions #

A modern app stack should be able to navigate synchronous and asynchronous interactions seamlessly and make async tasks as straightforward to use as synchronous functions.

In Restate 1.0, every handler you connect to Restate has workflow-as-code semantics and

• Can be invoked synchronously (req/resp), asynchronously, delayed
• Supports idempotency keys and deduplication
• Can pass an awaitable handle for the result to other processes
• Has exactly-once semantics between two workflow-as-code handlers

4. Single binary #

Restate 1.0 ships as a single binary. Lightweight, fast, simple to operate. You can run it on your laptop for development, on containers, on servers, or in the cloud, etc. Restate’s lightweight package is a superpower for ease of use and operations, which we saw first-hand when building Restate Cloud.

5. Event-based low-latency Architecture #

Restate 1.0 brings the foundational log-based architecture in place and supports single node deployments at this time, utilizing persistent volumes for the log storage. We will release distributed versions based on this architecture in the coming months.

The single Restate process already packs a punch and can process many workflow steps and events per second - and most importantly, keep latencies for the operations low. To give you a rough indication of what we are talking about, on a typical server instance on AWS with EBS for durability, Restate can process thousands of 3-step workflows per second, while the latencies for the full sequence of steps is around 50 msecs - that includes communication between Restate the workflow handlers running as a Kubernetes service. And it is with proper durability: every intermediate operation (invocations and steps) are committed with fsync to EBS.

And this is before we even started the work on performance optimization. So far, this is purely courtesy of Restate’s event-driven design.

Trying out Restate 1.0 #

We are very excited about all these changes. We have been using this internally and believe Restate really is a game changer for distributed app development.

If you want to try it out yourself, here is how you get started on Mac (server+CLI) with a sample project. (See Get Restate for alternatives for Linux native, Docker, npm, Maven…)

brew install restatedev/tap/restate restatedev/tap/restate-server
restate example

Restate Cloud - Early access #

We are equally excited to announce early access to Restate Cloud today - our fully serverless offering. No clusters, no partitions, no queues. Create a Restate environment, generate access keys, connect your app, and go! We run the Restate server, you run your application code the same way you are used to.

All the details are in the Intro to Restate Cloud blog post. Here are the most important parts:

Restate Cloud is available as a free tier for public signup. The free tier supports two environments per user, and a limited number of actions per second (durable workflow steps, timers, RPC events).

If you have a GitHub or Google Account, you are four clicks away from your first Restate environment. Go to https://cloud.restate.dev to get started:

We will add self-signup for paid premium tiers in the future, for now, please use this contact form to reach out to us for paid tiers with SLAs.

You can find a more detailed rundown of Restate Cloud and its architecture in the announcement blog post. But one important thing we’d like to highlight here already:

Restate Cloud is built on our own tech stack (delicious dog food anyone?). It runs Restate server on Kubernetes via the Restate Kubernetes Operator and it implements the control plane also as Restate-backed services running on AWS Lambda. We built Restate Cloud with a small team in just a few months - a testament to Restate’s ability to make distributed services simple to build, and Restate itself being easy to host and operate. And to our incredible team, of course!

Our Seed Funding Round #

To keep pushing this vision, we are excited to announce that we have raised $7 million in seed funding from Redpoint Ventures, with participation from Essence VC and firstminute.capital.

We are also excited to have a series of exceptional people support us as angel investors and advisors, including Jay Kreps and Neha Narkhede (creators of Apache Kafka and founders of Confluent), Olivier Pomel (founder of Datadog), Shawn “Swyx” Wang (DevRel All Star), fellow infrastructure founders Monica Sarbu, Guy Fighel, Roopak Venkatakrishnan, Aris Koliopoulos, as well advisors and investors Julia Schottenstein, Ameet Patel, Jan Sessenhausen, Chris Schagen, and Andrew van Nest.

Our company plans to use the funds primarily for hiring and infrastructure. We will keep developing our vision for Restate, support SDKs in more languages, and expand Restate Cloud.

Let’s get started… #

We’d love to hear what you think about today’s news and encourage you to take Restate for a spin and tell us how it works for you!

Give us a follow at @restatedev, or join Discord to share your feedback and to stay in the loop for updates, because we are just getting started. There is a long pipeline of features coming up, like distributed deployments, or an amazing UI to navigate all tasks, workflows, and distributed interactions.