introducing thawwritten by Ajay Kumar · Founder, PandaStack

We made a cold start take 164 milliseconds

Vercel Fluid works to avoid the cold start — pre-warming and sharing instances so you rarely hit one. We took the other path: scale fully to zero — the sandbox is deleted — then thaw a frozen microVM in the time it takes to read this sentence.

thawthawed · running
runningserving trafficidleno trafficfrozen · scaled to zerosandbox deleted · $0 idlethawedon the next requestseedmemory + its own diskGET /restore164 mscold restoretimenot to scalerunningserving trafficidleno trafficfreeze to a seedfrozen · scaled to zerosandbox deleted · $0 idleseedmemory + its own diskGET /thawed164 mscold restore · on the next request

a normal cold boot

~54s

thaw · cold restore

164ms

a frozen microVM, thawed

cold restore

164ms

measured on a real Node app, prod

while idle

$0

true scale-to-zero — sandbox deleted

ext4 errors

0

coherent by construction

wake paths

3

thaw → cold image → redeploy, never-fail

Every scale-to-zero platform makes the same trade

the problemScale to zero and you pay nothing while idle — but the next request eats a cold start. Keep something warm and the cold start disappears — but you pay for idle. For a decade that's been the whole conversation.

before thaw

~54s

A scaled-to-zero app woke by cold-booting from its baked disk image: ~26s to pull the multi-gigabyte image, ~8s for the kernel and init, then ~20s for the app to start and bind its port. Honest $0 idle — slow wake.

the number we already had

50–100ms

measured on the host; your network round trip is extra

How long it takes to restore a baked Firecracker snapshot — the same path that gives our sandboxes a 50–100 ms create with no warm pool. A restore isn't a boot: the kernel is up, init has run, the process is in memory.

So the question wrote itself. App wake was 54 seconds because it was a boot. Snapshot restore was 50–100 milliseconds because it wasn't. What would it take to make app wake a restore?

From 54 seconds to 164 milliseconds

measuredThat's not an optimization — it's a different mechanism. One built a machine. The other unfroze one.

wake latency · log scalemeasured on prod · kernel 6.17

Thaw restore

wake lands on the seed's node
164ms

Cold boot · image cached

no download, full boot + app start
~14s

Cold boot · cold cache

full image pull from object storage
~54s

Redeploy from git

last-resort never-fail fallback
~10min

Thaw is a memory-snapshot restore, not a boot — roughly 330× faster than a cold-cache boot. Every path eventually reaches a serving app; Thaw just makes the common case sub-second.

Deploy once. Sleep to zero. Thaw on demand.

the lifecycleNothing runs while the app is idle — the sandbox is deleted. It thaws when a request arrives, so the visitor just waits ~164ms instead of ~54s.

  1. 01

    Deploy

    Git push builds the app inside a microVM and serves it.

  2. 02

    Idle

    No traffic for the idle window. The reaper claims it.

  3. 03

    Freeze

    App stopped, then one atomic pause snapshots memory + its own disk into a seed.

  4. 04

    Scale to zero

    Sandbox deleted. CPU, RAM, and disk freed. $0 while idle.

  5. 05

    Thaw

    A request restores the frozen microVM (~164ms) and starts the app fresh.

  6. 06

    Serving

    Live again, warm latency, with current env and rotated secrets.

A memory snapshot and the disk under it are a matched pair

how it stays safeRestore the memory over a different disk and you've built a machine that lies to itself. We learned that the hard way — every decision in Thaw exists to make that mismatch impossible.

one atomic pause~24 s · off the request path

guest · app stopped

The app process is stopped and its env file deleted first. The memory we're about to freeze has no in-flight request, no half-held lock, and no plaintext secrets.

memorydiskapp stopped · env file deletedpauseone instantvm.mem + vm.statethe frozen machineclone.ext4its own disk · sha256-gated= the seedone frozen instantmemorydiskapp stoppedenv file deletedpauseone instantvm.mem + vm.stateclone.ext4the frozen machineits own disksha256-gated= the seed · one frozen instant

Because the memory snapshot and the disk copy come from the same instant, they cannot drift. On wake we restore over the seed's own disk — never a fresh template — so the frozen page cache sits over exactly the disk it was cached from. A write-fsync-read liveness gate runs before any request is served.

Thaw vs Fluid

different betsSame problem, opposite directions. Both bets are defensible — they just optimize for different shapes of traffic.

Vercel Fluid compute

  • Reduces cold starts via bytecode caching + function pre-warming on production.
  • Shares one instance across concurrent invocations; reuses idle resources before scaling up.
  • Bills active CPU (time your code is executing) plus provisioned memory.
  • A managed, no-config model that's a great default for steady traffic.

Per Vercel's own docs — verify against vercel.com, they move fast.

PandaStack Thaw

  • Scales to actual zero — the sandbox is deleted, so there's nothing to bill while idle.
  • Makes the cold start cheap (~164ms) instead of working to avoid hitting one.
  • Shines for the long tail: previews, side projects, agents idle most of the time.
  • Built on real microVMs — a container can't be frozen to a file and thawed.
Fluid works to avoid the cold start. Thaw makes the cold start fast — and goes all the way to zero.

The boring security choice unlocked the exciting result

why hereYou don't get Thaw on a substrate that was never a real machine in the first place.

A container shares the host kernel — there's no self-contained machine to snapshot. A Firecracker microVM is a complete machine: its own guest kernel, its own memory, its own virtual disk. That's exactly what makes it freezable. The same property that gives a microVM stronger isolation than a container is the property that lets it cold-restore in milliseconds.

Ship on the millisecond cloud.

Spin up a full Linux sandbox in the time it takes to blink. Fork it, snapshot it, throw it away. Then do it ten thousand more times.

Free tier with $5.40/mo usage credit. No card. Apache-2.0.

each mark is one eight-step bootreal time: one every 100 ms