GitHub
Powered by Temporal

A real Temporal server in your browser, in seconds.

Boots an ephemeral sandbox running a real Temporal dev server and a live worker. Edit the workflow, start a durable order, then kill the worker mid-flight and watch it resume exactly where it left off.

Ephemeral · ~15-minute sessions Nothing to install
sandman · order-workflow.ts
export async function orderWorkflow() {
// durable, replayable
await charge(payment);
await notify(restaurant);
const ok = await condition(
() => accepted, '15m'
);
await deliver(order);
}
Event history
WorkflowStarted
ActivityCompleted · charge
TimerStarted · 15m
SignalReceived · accept
ChildWorkflow · delivery
Send signal Kill worker
The durability demo

Kill the worker. Watch it recover.

Workflow state lives in the Temporal server, not the worker process. So when the process dies, nothing is lost — a restarted worker replays history and picks up exactly where it stopped.

Worker process
running order-workflow.ts
Workflow progressevent history
Temporal server
Holds the full event history — survives every worker restart.
State preserved
1
Workflow runs — Each durable step is appended to Temporal’s event history.
2
Worker is killed — The Node process dies mid-flight — the code stops executing.
3
History is preserved — The Temporal server still holds every recorded event. Nothing is lost.
4
Worker restarts — It replays history and resumes at the exact point it left off.
One screen, three surfaces

Edit, run, and inspect — side by side.

Monaco editor

Edit the workflow and activities live. Saving re-syncs the file and hot-restarts the worker while in-flight workflows survive.

Temporal Web UI

The real Temporal Web UI, reverse-proxied same-origin into an iframe — inspect executions, history, and search.

Control plane

Start workflows, send signals, run queries — plus a kill-worker chaos button to prove durable recovery.

A deliberately over-engineered food order

Every core Temporal concept, in one workflow.

The demo workflow is intentionally maximal, so you can trigger each primitive from the control plane and watch it land in real history.

Activities & retries

The payment charge runs as an activity with a retry policy — transient failures back off and retry automatically.

Non-retryable failures

A declined card is permanent — the activity throws a non-retryable failure that skips the retry policy, and the workflow cancels the order.

Signals

Restaurant acceptance, delivery completion, and cancellation all arrive as signals. The workflow blocks on condition() until they land.

Queries

getStatus returns a live snapshot of workflow state without advancing execution — read-only inspection at any time.

Durable timers

A deadline timer fires if the restaurant doesn’t accept in time. The timer lives in the server and survives worker restarts.

Durable recovery

The kill-worker button ends the process mid-flight. Because the server preserves state, the workflow resumes exactly where it stopped.

Guided tour

Learn by watching real events arrive.

The tour advances step-by-step as actual workflow events land — not on button clicks. Here's the path from your first order to durable recovery.

1
Place a food order start-order

Start one durable order workflow. Temporal records the start, then a worker begins running your code.

2
An activity runs — with automatic retries

The payment charge runs as an activity. Transient failures retry with exponential backoff — no retry loops to write.

3
A durable timer guards the deadline

The workflow starts an acceptance-deadline timer that lives in the server and fires even if the worker crashes.

4
Send a signal to resume accept-restaurant

The order parks waiting for the restaurant. The accepted signal appends an event and resumes the workflow.

5
Read state with a query query-status

Ask the running workflow for its snapshot. Queries inspect state without moving the workflow forward.

6
Kill the worker — watch it recover kill-worker

Kill the process running your code. On restart it replays history and resumes exactly where it left off.

7
Finish the delivery complete-delivery

Send the delivery-completed signal. The workflow resumes from its final wait and finishes as delivered.

Get started

Enter your email to boot a sandbox.

  1. 1. Share your email so we can see who tried the demo.
  2. 2. A Firecracker MicroVM boots with Temporal and a worker.
  3. 3. Start ordering, then break things — the session self-destructs after ~15 minutes.

No account is created. Sessions are temporary and expire automatically.

Frequently asked

What is Temporal?

A durable execution platform. You write ordinary code; Temporal records every step so workflows survive process crashes, restarts, and long waits — resuming exactly where they left off.

Do I need to install anything?

No. Everything runs in an ephemeral E2B Firecracker MicroVM that boots inside your session — the Temporal dev server, the CLI, and a TypeScript worker.

How long does a session last?

Sessions are ephemeral and self-destruct after roughly fifteen minutes. It’s a playground, not persistent storage — boot a fresh one whenever you like.

Why a food-ordering workflow?

It’s a familiar scenario that exercises the core Temporal primitives — activities with retries, signals, queries, durable timers, and crash recovery — in under 200 lines of code.

Why ask for my email?

It gives us lightweight attribution for who tried the demo. No account is created, and sessions stay temporary.

Can I edit the workflow code?

Yes. Edit the workflow and activities in the Monaco editor. Saving hot-restarts the worker while the Temporal server keeps in-flight workflows alive — that’s the durability demo.

See durability for yourself.

Boot a sandbox, start an order, and kill the worker mid-flight. It comes back.