Microservice Orchestration

Restate provides durable execution primitives that make distributed systems resilient by default, without the operational overhead.

Resilient Orchestration

Build microservices that automatically recover from failures without losing progress:

export const orderService = restate.service({
  name: "OrderService",
  handlers: {
    process: async (ctx: restate.Context, order: Order) => {
      // Each step is automatically durable and resumable
      const paymentId = ctx.rand.uuidv4();

      await ctx.run(() => chargePayment(order.creditCard, paymentId));

      for (const item of order.items) {
        await ctx.run(() => reserveInventory(item.id, item.quantity));
      }
      return { success: true, paymentId };
    },
  },
});

@Service
public class OrderService {

  @Handler
  public OrderResult process(Context ctx, Order order) {
    // Each step is automatically durable and resumable
    String paymentId = UUID.randomUUID().toString();

    ctx.run(() -> chargePayment(order.creditCard, paymentId));

    for (var item : order.items) {
      ctx.run(() -> reserveInventory(item.id, item.quantity));
    }

    return new OrderResult(true, paymentId);
  }
}

order_service = restate.Service("OrderService")


@order_service.handler()
async def process(ctx: restate.Context, order: Order):
    # Each step is automatically durable and resumable
    payment_id = str(uuid.uuid4())

    await ctx.run_typed(
        "charge", charge_payment, credit_card=order.credit_card, payment_id=payment_id
    )

    for item in order.items:
        await ctx.run_typed(
            f"reserve_{item.id}", reserve, item_id=item.id, amount=item.amount
        )

    return {"success": True, "payment_id": payment_id}

type OrderService struct{}

func (OrderService) Process(ctx restate.Context, order Order) (OrderResult, error) {
  // Each step is automatically durable and resumable
  paymentID := restate.UUID(ctx).String()

  _, err := restate.Run(ctx, func(ctx restate.RunContext) (restate.Void, error) {
    return ChargePayment(order.CreditCard, paymentID)
  })
  if err != nil {
    return OrderResult{}, err
  }

  for _, item := range order.Items {
    _, err := restate.Run(ctx, func(ctx restate.RunContext) (restate.Void, error) {
      return ReserveInventory(item.ID, item.Quantity)
    })
    if err != nil {
      return OrderResult{}, err
    }
  }

  return OrderResult{Success: true, PaymentID: paymentID}, nil
}

Automatic recovery: Code resumes exactly where it left off after failures
Standard development: Write services like regular HTTP APIs
Resilient Sagas: Implement complex multi-step transactions with resilient rollback

Reliable Communication & Idempotency

Flexible communication patterns with strong delivery guarantees:

Zero message loss: All service communication is durably logged
Built-in retries: Automatic exponential backoff for transient failures
Scheduling: Delay messages for future processing
Request deduplication: Idempotency keys prevent duplicate processing

Code example

// Request-response: Wait for result
const payRef = await ctx.serviceClient(paymentService).charge(req);

// Fire-and-forget: Guaranteed delivery without waiting
ctx.serviceSendClient(emailService).emailTicket(req);

// Delayed execution: Schedule for later
ctx
  .serviceSendClient(emailService)
  .sendReminder(order, sendOpts({ delay: dayBefore(req.concertDate) }));

// Request-response: Wait for result
var result = InventoryServiceClient.fromContext(ctx).checkStock(item);

// Fire-and-forget: Guaranteed delivery without waiting
EmailServiceClient.fromContext(ctx).send().emailTicket(order);

// Delayed execution: Schedule for later
EmailServiceClient.fromContext(ctx).send().sendReminder(order, Duration.ofDays(21));

# Request-response: Wait for result
result = await ctx.service_call(charge_payment, req)

# Fire-and-forget: Guaranteed delivery without waiting
ctx.service_send(send_ticket_email, ticket)

# Delayed execution: Schedule for later
ctx.service_send(send_reminder, ticket, send_delay=timedelta(days=7))

// Request-response: Wait for result
result, err := restate.Service[StockResult](ctx, "PaymentService", "Charge").Request(req)
if err != nil {
  return err
}
_ = result

// Fire-and-forget: Guaranteed delivery without waiting
restate.ServiceSend(ctx, "EmailService", "EmailTicket").Send(ticket)

// Delayed execution: Schedule for later
restate.ServiceSend(ctx, "EmailService", "SendReminder").Send(ticket, restate.WithDelay(7*24*time.Hour))

Durable Stateful Entities

Manage stateful entities without external databases or complex consistency mechanisms:

Durable persistence: Application state survives crashes and deployments
Simple concurrency model: Single-writer semantics prevent consistency issues and race conditions
Horizontal scaling: Each object has its own message queue. Different entity keys process independently
Built-in querying: Access state via UI and APIs

Code example

export default restate.object({
  name: "UserAccount",
  handlers: {
    updateBalance: async (ctx: restate.ObjectContext, amount: number) => {
      const balance = (await ctx.get<number>("balance")) ?? 0;
      const newBalance = balance + amount;

      if (newBalance < 0) {
        throw new TerminalError("Insufficient funds");
      }

      ctx.set("balance", newBalance);
      return newBalance;
    },

    getBalance: shared(async (ctx: restate.ObjectSharedContext) => {
      return (await ctx.get<number>("balance")) ?? 0;
    }),
  },
});

@VirtualObject
public class UserAccount {
  private static final StateKey<Double> BALANCE = StateKey.of("balance", Double.class);

  @Handler
  public double updateBalance(ObjectContext ctx, double amount) {
    double balance = ctx.get(BALANCE).orElse(0.0);
    double newBalance = balance + amount;

    if (newBalance < 0) {
      throw new TerminalException("Insufficient funds");
    }

    ctx.set(BALANCE, newBalance);
    return newBalance;
  }

  @Shared
  public double getBalance(SharedObjectContext ctx) {
    return ctx.get(BALANCE).orElse(0.0);
  }
}

user_account = restate.VirtualObject("UserAccount")


@user_account.handler()
async def update_balance(ctx: restate.ObjectContext, amount: float):
    balance = await ctx.get("balance", type_hint=float) or 0.0
    new_balance = balance + amount

    if new_balance < 0.0:
        raise TerminalError("Insufficient funds")

    ctx.set("balance", new_balance)
    return new_balance


@user_account.handler(kind="shared")
async def get_balance(ctx: restate.ObjectSharedContext):
    return await ctx.get("balance", type_hint=float) or 0.0

type UserAccount struct{}

func (UserAccount) UpdateBalance(ctx restate.ObjectContext, amount float64) (float64, error) {
  balance, err := restate.Get[float64](ctx, "balance")
  if err != nil {
    return 0.0, err
  }

  newBalance := balance + amount
  if newBalance < 0.0 {
    return 0.0, restate.TerminalError(errors.New("insufficient funds"))
  }

  restate.Set(ctx, "balance", newBalance)
  return newBalance, nil
}

func (UserAccount) GetBalance(ctx restate.ObjectSharedContext) (float64, error) {
  return restate.Get[float64](ctx, "balance")
}

Operational simplicity

Reduce infrastructure complexity (no need for queues + state stores + schedulers, etc.). A single binary including everything you need.

Key Orchestration Patterns

Sagas

Implement resilient rollback logic for non-transient failures

Database interaction

Use Durable Execution to make database operations resilient and consistent

Parallel Processing

Execute independent operations concurrently while maintaining durability

Durable RPC, Idempotency & Concurrency

Call other services with guaranteed delivery, retries, and deduplication

Event-Driven Coordination

Wait for external events and webhooks with promises that survive crashes

Durable State Machines

Implement consistent state machines that survive crashes and restarts

Comparison with Other Solutions

Feature	Restate	Traditional Orchestration
Infrastructure	Single binary deployment	Message brokers + workflow engines + state stores
Service Communication	Built-in reliable messaging	External message queues required
State Management	Integrated durable state	External state stores + locks
Failure Recovery	Automatic progress recovery	Manual checkpoint/restart logic
Deployment Model	Standard HTTP services	Standard HTTP services
Development Experience	Regular code + IDE support	Regular code + IDE support
Observability	Built-in UI & execution tracing	Manual setup

Getting Started

Ready to build resilient microservices with Restate? Here are your next steps:

Quickstart

Run your first Restate service

Hands-on Tutorial

Learn orchestration patterns with interactive examples

Examples

Explore templates, patterns, and end-to-end applications

Evaluating Restate and missing a feature? Contact us on Discord or Slack.

Use Cases

Foundations

Tour of Restate for...

Microservice Orchestration

Resilient Orchestration

Reliable Communication & Idempotency

Durable Stateful Entities

Operational simplicity

Key Orchestration Patterns

Sagas

Database interaction

Parallel Processing

Durable RPC, Idempotency & Concurrency

Event-Driven Coordination

Durable State Machines

Comparison with Other Solutions

Getting Started

Quickstart

Hands-on Tutorial

Examples

​Resilient Orchestration

​Reliable Communication & Idempotency

​Durable Stateful Entities

​Operational simplicity

​Key Orchestration Patterns

Sagas

Database interaction

Parallel Processing

Durable RPC, Idempotency & Concurrency

Event-Driven Coordination

Durable State Machines

​Comparison with Other Solutions

​Getting Started

Quickstart

Hands-on Tutorial

Examples

Resilient Orchestration

Reliable Communication & Idempotency

Durable Stateful Entities

Operational simplicity

Key Orchestration Patterns

Comparison with Other Solutions

Getting Started