Workflows-as-code

Lightweight, flexible, durable.

Combine the resiliency of workflows with the speed and flexibility of regular functions. Restate orchestrates and manages their execution till completion, whether it’s millis or months.

---

Familiar programming model

Restate gives workflow semantics to any function: retries, recovery of progress,... Restate provides a distributed, durable version of familiar building blocks: timers, promises, signals,...

Low latency

Restate is built from the ground up to serve low-latency workflows. You can now put workflows in the latency-sensitive path of user interactions.

Support for serverless

Run your workflow and/or its activities on Function-as-a-Service platforms. Restate lets your functions suspend whenever they wait on inputs.

Workflows with Restate

Use Restate's durable building blocks to implement workflows that are resilient to failures and recoverable.

Durable building blocks

The Restate SDK gives you access to durable building blocks that you can use to build workflows: RPC calls, events, timers, promises, signals, and more.

Learn more

Durable building blocks

The Restate SDK gives you access to durable building blocks that you can use to build workflows: RPC calls, events, timers, promises, signals, and more.

Learn more

Persist progress

Restate logs the progress your code makes and recovers it in case of a crash. This way, you can build workflows that are durable and resilient to failures.

Learn more

Persist progress

Restate logs the progress your code makes and recovers it in case of a crash. This way, you can build workflows that are durable and resilient to failures.

Learn more

Durable promises and signals

Make Promises/Futures resilient by registering them in Restate. Share them and wait until other functions resolve them.

Durable promises and signals

Make Promises/Futures resilient by registering them in Restate. Share them and wait until other functions resolve them.

TypeScript

const signupWorkflow = restate.workflow({
    name: "user-signup",
    handlers: {
        run: async (
            ctx: restate.WorkflowContext,
            user: { name: string; email: string },
        ) => {
            // workflow ID = user ID; workflow runs once per user
            const userId = ctx.key;

            await ctx.run(() => createUserEntry(user));

            const secret = ctx.rand.uuidv4();
            await ctx.run(() => sendEmailWithLink({ userId, user, secret }));

            const clickSecret = await ctx.promise<string>("link-clicked");
            return clickSecret === secret;
        },

        click: async (
            ctx: restate.WorkflowSharedContext,
            request: { secret: string },
        ) => {
            await ctx.promise<string>("link-clicked").resolve(request.secret);
        },
    },
});

Java

@Workflow
public class SignupWorkflow {

  private static final DurablePromiseKey<String> LINK_CLICKED =
      DurablePromiseKey.of("link_clicked", JsonSerdes.STRING);


  @Workflow
  public boolean run(WorkflowContext ctx, User user) {
    // workflow ID = user ID; workflow runs once per user
    String userId = ctx.key();

    ctx.run(() -> createUserEntry(user));

    String secret = ctx.random().nextUUID().toString();
    ctx.run(() -> sendEmailWithLink(userId, user, secret));

    String clickSecret = ctx.promise(LINK_CLICKED).awaitable().await();

    return clickSecret.equals(secret);
  }

  @Shared
  public void click(SharedWorkflowContext ctx, String secret) {
    ctx.promiseHandle(LINK_CLICKED).resolve(secret);
  }

  public static void main(String[] args) {
    RestateHttpEndpointBuilder.builder().bind(new SignupWorkflow()).buildAndListen();
  }
}

Kotlin

@Workflow
class SignupWorkflow {

  companion object {
    private val LINK_CLICKED = KtDurablePromiseKey.json<String>("link_clicked")
  }

  @Workflow
  suspend fun run(ctx: WorkflowContext, user: User): Boolean {
    // workflow ID = user ID; workflow runs once per user
    val userId = ctx.key()

    ctx.runBlock { createUserEntry(user) }

    val secret = ctx.random().nextUUID().toString()
    ctx.runBlock { sendEmailWithLink(userId, user, secret) }

    val clickSecret: String = ctx.promise(LINK_CLICKED).awaitable().await()

    return clickSecret == secret
  }

  @Shared
  suspend fun click(ctx: SharedWorkflowContext, secret: String) {
    ctx.promiseHandle(LINK_CLICKED).resolve(secret)
  }
}

fun main() {
  RestateHttpEndpointBuilder.builder().bind(SignupWorkflow()).buildAndListen()
}

Go

type SignupWorkflow struct{}

func (SignupWorkflow) Run(ctx restate.WorkflowContext, user User) (bool, error) {
  // workflow ID = user ID; workflow runs once per user
  userId := restate.Key(ctx)

  if _, err := restate.Run(ctx, func(ctx restate.RunContext) (restate.Void, error) {
    return restate.Void{}, CreateUserEntry(user)
  }); err != nil {
    return false, err
  }

  secret := restate.Rand(ctx).UUID().String()
  if _, err := restate.Run(ctx, func(ctx restate.RunContext) (restate.Void, error) {
    return restate.Void{}, SendEmailWithLink(userId, user, secret)
  }); err != nil {
    return false, err
  }

  clickSecret, err := restate.Promise[string](ctx, "link-clicked").Result()
  if err != nil {
    return false, err
  }

  return clickSecret == secret, nil
}

func (SignupWorkflow) Click(ctx restate.WorkflowSharedContext, secret string) error {
  return restate.Promise[string](ctx, "link-clicked").Resolve(secret)
}

func main() {
  if err := server.NewRestate().
    Bind(restate.Reflect(SignupWorkflow{})).
    Start(context.Background(), ":9080"); err != nil {
    log.Fatal(err)
  }
}

Python

user_signup = Workflow("user-signup")

@user_signup.main()
async def run(ctx: WorkflowContext, user: User) -> bool:
    user_id = ctx.key()

    await ctx.run("create_user", lambda: create_user_entry(user))

    secret = await ctx.run("secret", lambda: str(uuid.uuid4()))
    await ctx.run("send_email", lambda: send_email_with_link(user_id, user.email, secret))

    click_secret = await ctx.promise("link_clicked").value()
    return click_secret == secret


@user_signup.handler()
async def click(ctx: WorkflowSharedContext, secret: str):
    await ctx.promise("link_clicked").resolve(secret)

app = restate.app(services=[user_signup])

Workflows as regular, lightweight functions

Restate is a single binary and its workflow functionality is integrated in its core.
Your workflows run like any other function in your infrastructure: on K8S, FaaS, or mix-and-match.
No need to spin up extra infrastructure or dedicated workers.

Invoke idempotently and latch on

A workflow runs exactly one time. Restate makes sure that duplicate requests do not lead to duplicate execution.

If the caller loses the connection to the workflow, he can latch on again to retrieve the result.

TypeScript

// import * as clients from "@restatedev/restate-sdk-clients";
const restateClient = clients.connect({ url: "http://localhost:8080" });
await restateClient
  .workflowClient<SignUpWorkflow>({ name: "user-signup" }, user.id)
  .workflowSubmit(user);

// do something else, with workflow running in the background

// attach back to the workflow
const result = await restateClient
  .workflowClient<SignUpWorkflow>({ name: "user-signup" }, user.id)
  .workflowAttach();

Java

// import dev.restate.sdk.client.Client;
Client restateClient = Client.connect("http://localhost:8080");
SignupWorkflowClient.fromClient(restateClient, user.id())
    .submit(user);

// do something else, with workflow running in the background

// attach back to the workflow
boolean result =
    SignupWorkflowClient.fromClient(restateClient, user.id())
        .workflowHandle()
        .attach();

Kotlin

// import dev.restate.sdk.client.Client;
val restateClient = Client.connect("http://localhost:8080")
SignupWorkflowClient.fromClient(restateClient, user.id)
    .submit(user)

// do something else, with workflow running in the background

// attach back to the workflow
val result =
    SignupWorkflowClient.fromClient(restateClient, user.id)
        .workflowHandle()
        .attach()

Go

const RESTATE_URL = "http://localhost:8080"
client := &http.Client{}

url := fmt.Sprintf("%s/SignupWorkflow/%s/Run/Send", RESTATE_URL, userId)
userData, _ := json.Marshal(user)
req, err := http.NewRequest("POST", url, bytes.NewBuffer(userData))
if err != nil {
  return err
}
req.Header.Set("Content-Type", "application/json")

resp, err := client.Do(req)
if err != nil {
  return err
}
defer resp.Body.Close()

// ... do other things while the task is being processed ...

// Later on, you can retrieve the result of the task (possibly in a different process)
attachUrl := fmt.Sprintf("%s/restate/workflow/SignupWorkflow/%s/attach", RESTATE_URL, userId)
resp, err = http.DefaultClient.Get(attachUrl)
if err != nil {
  return err
}
defer resp.Body.Close()

// ... Process the result ...

Python

restate = "http://localhost:8080"

# 1. Submit the workflow
user_id = "myUser123"
requests.post(
    f'${restate}/signupWorkflow/${user_id}/run/send',
    json = {
        "email": "[email protected]",
        "name": "Pete"
    },
    headers = {"Content-Type": "application/json"}
)

# Do something else, with workflow running in the background

# 2. Attach back to the workflow
response = requests.get(
    f'${restate}/restate/workflow/signupWorkflow/${user_id}/attach'
)

LOW-LATENCY

Restate’s event-driven foundation built in Rust lets you put workflows in the latency-sensitive path of user interaction.

Learn more

DURABLE EXECUTION

Restate handles retries and recovers your code to the exact point before the crash. State changes take part in durable execution, so the state never gets out of sync.

Learn more

Flexible, Stateful Workflows with Restate

Flexible logic and failure handling

Restate guarantees code runs to completion. This makes it easy to implement resilient sagas in a simple try-catch block.

Track all rollback actions in a list and run them on unrecoverable failures.

Restate takes care of retries and recovery and makes sure all compensations run.

Learn more

Flexible logic and failure handling

Restate guarantees code runs to completion. This makes it easy to implement resilient sagas in a simple try-catch block.

Track all rollback actions in a list and run them on unrecoverable failures.

Restate takes care of retries and recovery and makes sure all compensations run.

Learn more

Queryable workflow state

Use Restate’s built-in key-value store to store workflow state. Restate guarantees that it is consistent and persistent, since state updates are tracked together with the rest of the execution progress.

You can retrieve the current state of the workflow from within other handlers and expose it to external clients.

Queryable workflow state

Use Restate’s built-in key-value store to store workflow state. Restate guarantees that it is consistent and persistent, since state updates are tracked together with the rest of the execution progress.

You can retrieve the current state of the workflow from within other handlers and expose it to external clients.

Stateful, serverless workflows

You can run stateful workflows on serverless infrastructure, like AWS Lambda. Restate attaches the state to the request. Your handlers work on local state

Learn more

Stateful, serverless workflows

You can run stateful workflows on serverless infrastructure, like AWS Lambda. Restate attaches the state to the request. Your handlers work on local state

Learn more

TypeScript

const subscriptionWorkflow = restate.workflow({
  name: "SubscriptionWorkflow",
  handlers: {
    run: async (ctx: restate.WorkflowContext, req: SubscriptionRequest) => {
      const compensations = [];

      try {
        const paymentId = ctx.rand.uuidv4();
        compensations.push(() => removeRecurringPayment(paymentId))
        await ctx.run(() => createRecurringPayment(req.creditCard, paymentId));
        ctx.set("status", "payment_success");

        for (const subscription of req.subscriptions) {
          compensations.push(() => removeSubscription(req.userId, subscription))
          await ctx.run(() => createSubscription(req.userId, subscription));
        }
        ctx.set("status", "subscribed");
      } catch (e) {
        if (e instanceof restate.TerminalError) {
          for (const compensation of compensations.reverse()) {
            await ctx.run(() => compensation());
          }
          ctx.set("status", "rolled_back");
        }
        throw e;
      }
    },
  },
})

export const awsLambdaHandler = restate
    .endpoint()
    .bind(subscriptionWorkflow)
    .handler();

Java

@Workflow
public class SubscriptionWorkflow {

  StateKey<String> STATUS = StateKey.of("status", STRING);


  @Workflow
  public void run(WorkflowContext ctx, SubscriptionRequest req) {
    List<Runnable> compensations = new ArrayList<>();
    try {
      var paymentId = ctx.random().nextUUID().toString();
      compensations.add(() -> removeRecurringPayment(paymentId));
      ctx.run(STRING, () -> createRecurringPayment(req.creditCard(), paymentId));
      ctx.set(STATUS, "payment_success");

      for (String subscription : req.subscriptions()) {
        compensations.add(() -> removeSubscription(req.userId(), subscription));
        ctx.run(() -> createSubscription(req.userId(), subscription));
      }
      ctx.set(STATUS, "subscribed");
    } catch (TerminalException e) {
      for (Runnable compensation : compensations) {
        ctx.run(() -> compensation.run());
      }
      ctx.set(STATUS, "rolled_back");
      throw e;
    }
  }
}

class MyLambdaHandler extends BaseRestateLambdaHandler {
  @Override
  public void register(RestateLambdaEndpointBuilder builder) {
    builder.bind(new SubscriptionWorkflow());
  }
}

Kotlin

@Workflow
class SubscriptionWorkflow {

  companion object {
    val STATUS = KtStateKey.json<String>("status")
  }

  @Workflow
  suspend fun run(ctx: WorkflowContext, req: SubscriptionRequest) {
    val compensations: MutableList<suspend () -> Unit> = mutableListOf()

    try {
      val paymentId = ctx.random().nextUUID().toString()
      compensations.add { removeRecurringPayment(paymentId) }
      ctx.runBlock { createRecurringPayment(req.creditCard, paymentId) }
      ctx.set(STATUS, "payment_success")

      for (subscription in req.subscriptions) {
        compensations.add { removeSubscription(req.userId, subscription) }
        ctx.runBlock { createSubscription(req.userId, subscription) }
      }
      ctx.set(STATUS, "subscribed")
    } catch (e: TerminalException) {
      compensations.reversed().forEach { ctx.runBlock { it() } }
      ctx.set(STATUS, "rolled_back")
      throw TerminalException("Subscription failed")
    }
  }
}

class MyLambdaHandler : BaseRestateLambdaHandler() {
  override fun register(builder: RestateLambdaEndpointBuilder) {
    builder.bind(SubscriptionWorkflow())
  }
}

Go

type SubscriptionWorkflow struct{}

func (SubscriptionWorkflow) Run(ctx restate.WorkflowContext, req SubscriptionRequest) error {
  compensations := make([]func() error, 0, len(req.Subscriptions)+1)
  handleError := func(err error) error {
    if restate.IsTerminalError(err) {
      for _, compensation := range compensations {
        if _, err := restate.Run(ctx, func(ctx restate.RunContext) (restate.Void, error) {
          return restate.Void{}, compensation()
        }); err != nil {
          return err
        }
      }
    }
    restate.Set(ctx, "status", "rolled_back")
    return err
  }

  paymentId := restate.Rand(ctx).UUID().String()
  compensations = append(compensations, func() error {
    return RemoveRecurringPayment(req.CreditCard, paymentId)
  })
  if _, err := restate.Run(ctx, func(ctx restate.RunContext) (restate.Void, error) {
    return CreateRecurringPayment(req.CreditCard, paymentId)
  }); err != nil {
    return handleError(err)
  }
  restate.Set(ctx, "status", "payment_success")

  for _, subscription := range req.Subscriptions {
    compensations = append(compensations, func() error {
      return RemoveSubscription(req.UserID, subscription)
    })
    if _, err := restate.Run(ctx, func(ctx restate.RunContext) (restate.Void, error) {
      return CreateSubscription(req.UserID, subscription)
    }); err != nil {
      return handleError(err)
    }
  }
  restate.Set(ctx, "status", "subscribed")
  return nil
}

func main() {
  handler, err := server.NewRestate().
    Bind(restate.Reflect(SubscriptionWorkflow{})).
    Bidirectional(false).
    LambdaHandler()
  if err != nil {
    log.Fatal(err.Error())
  }
  lambda.Start(handler)
}

Python

subscription_workflow = Workflow("SubscriptionWorkflow")


@subscription_workflow.main()
async def run(ctx: WorkflowContext, req: SubscriptionRequest):
    compensations = []

    try:
        payment_id = await ctx.run("payment id", lambda: str(uuid.uuid4()))

        compensations.append(lambda: remove_recurring_payment(payment_id))
        await ctx.run("recurring payment",
                            lambda: create_recurring_payment(req.credit_card, payment_id))
        ctx.set("status", "payment_success");

        for subscription in req.subscriptions:
            compensations.append(lambda: remove_subscription(req.user_id, subscription))
            await ctx.run("subscription",
                      lambda: create_subscription(req.user_id, subscription))
        ctx.set("status", "subscribed");

    except TerminalError as e:
        for compensation in reversed(compensations):
            await ctx.run("run compensation", compensation)
        ctx.set("status", "rolled_back");
        raise e


aws_lambda_handler = restate.app([subscription_workflow])

Detailed Observability

Understand what is happening in your workflows, by using the UI, the CLI, and the built-in tracing.
Debug failing workflows, inspect the K/V state, and manage deployments.

What can you do with UI?What can you do with CLI?

What you can build with Workflows and Restate

User sign-up workflow

Create user in the system, wait until email confirmation, schedule a reminder, send welcome email, etc.

Order processing and logistics

Handle the payment, request the order preparation, wait for driver acceptance callback, etc.

Infrastructure provisioning

Go through a set of steps to provision a setup. Retry until resources are up, handle timeouts, rollbacks, etc.

Workflow interpreters and AI agents

Dynamically compose workflows based on user input. For example, an image transformer that lets users specify the steps to be taken.

AI workflows

An ingestion workflow to make documents available for RAG.

Wondering about a specific use case?

Let’s brainstorm together on Discord or Slack.

Developer Resources

Blog post

The simplest way to write workflows-as-code.

Docs

Read the docs to learn more.

Need help?

Join the Restate Discord or Slack communities