Snapshots, forking and cold starts
Restoring a snapshot instead of booting from scratch is how a microVM starts in milliseconds, and copy-on-write is how one running machine becomes many. These posts cover snapshot-restore internals, forking a live VM, hibernation and scale-to-zero, and what those primitives enable for agents and tests.
Thaw: sub-second cold restore114 posts
Top 14 Ephemeral Development Environment Platforms in 2026: The Resume Path Nobody Benchmarks
Every platform in this category publishes a create number. None of them publish the one you hit ten times a day: the wait after the platform decided nobody was looking. Fourteen platforms graded on what idle actually means -- stop, suspend, hibernate or destroy -- what survives it, what it costs at rest, and whether coming back is the same code path as create or a slower one nobody measured.
Per-Tenant Map Tile Rendering in MicroVMs: When Your Customers Write the Stylesheet
A map style is not configuration, it is a program: a few kilobytes of JSON that tells thirty years of C++ how much memory to allocate and which files to open. Here is what happens when one tenant writes a bad one, and the per-tenant microVM shape that keeps it their problem instead of everybody's.
Per-Tenant Payroll and Tax Engines in microVMs: Determinism Is the Product
A payroll or tax engine is a pure function on paper and a function of fifteen undeclared arguments in production: tzdata, ICU, glibc, a rounding mode nobody chose, and the customer's own deduction formula. Then an amended return arrives three years later and asks for the same number, plus an explanation.
Readahead Inside a microVM: The Kernel Guessing Wrong, 4 KiB at a Time
There is no disk. A guest read is a descriptor on a virtqueue, an exit to the VMM, a file read on the host, and a second page cache doing its own speculation underneath yours. Both layers are guessing about the same access pattern, and only one of them is paying for the exits.
kvm-clock vs TSC: How a Firecracker Guest Tells the Time, and What a Snapshot Does to It
A guest clock is not one thing. It is a rated list of clocksources, a shared memory page the host writes into, and a userspace fast path that silently becomes a trap when you pick wrong. Then you snapshot it, and the whole stack starts lying in a very specific way: TLS first, loudly.
Firecracker vs Hyper-V Isolated Containers: Two Ecosystems, One Verdict
Microsoft shipped Hyper-V isolated containers because Windows containers on a shared kernel were not a boundary they would stand behind for other people's code. The Linux world shipped Firecracker, Kata and gVisor for exactly the same reason. Same verdict, opposite engineering — and one of them cannot run your Windows binary.
Encryption at Rest for Sandbox Disks and Snapshots
"Is customer data encrypted at rest?" is one checkbox covering four very different files, three of which are not what the reviewer is picturing. One of them is a verbatim copy of someone's RAM.
Giving an AI Agent a Language Server: The Index Is Code Execution
An agent that edits code by grepping and guessing is the agent everyone complains about. A language server fixes that — and quietly runs the repository's build scripts to do it. So run the indexer in a microVM, snapshot the warm index, and restore it per session.
Letting Customers Run Their Own Container Image
“Bring your own container image” is a remote-code-execution endpoint with a product manager attached. The admission pipeline, the baked-RAM surprise, and why the escape surface you just inherited belongs to the kernel rather than to Docker.
More posts in this topic
- A Real Red-Green Loop for Coding Agents, One MicroVM per Attempt
- Audit Trails When the Machine Is Gone in 200 Milliseconds
- Running MATLAB and Octave Workloads in Isolated microVMs
- Self-Hosting a Compiler Explorer: Running Strangers' Compilers Safely
- Mutation Testing at Scale: Thousands of Broken Builds on Purpose
- One microVM per Attendee: Hands-On Labs for a Whole Room at Once
- Cold Start Is Four Problems: JVM Warmup vs the microVM Snapshot
- Julia, R and the Cost of the First Import
- Distributed Data Processing on Ephemeral MicroVM Fleets
- The Carbon and Energy Case for Scale-to-Zero Compute
- Snapshot the Failure, Not the Log Line
- Running EDA and Chip-Design Workloads in MicroVMs
- How to Put a CDN in Front of a Scale-to-Zero App
- virtiofs vs virtio-blk: How Files Actually Get Into a MicroVM
- Why the disk under your sandbox fleet decides your boot time
- Golden Images vs Snapshot Baking
- Per-Tenant SQLite: One File, One microVM, and No Noisy Neighbours
- Where Sleeping Workloads Live: Storage Tiering Explained
- Your Scale-to-Zero App Never Sleeps, and Bots Are Why
- tmpfs in a microVM: The Filesystem That Eats Your RAM
- Where Scale-to-Zero Wake Time Actually Goes
- UFFDIO_ZEROPAGE vs UFFDIO_COPY: Stop Paying RAM for Zeros
- The Snapshot-Restore Thundering Herd, Explained
- Morph Cloud vs E2B: Fork the Machine or Rent a Session
- How to Benchmark Sandbox Cold Start Honestly
- PandaStack vs Azure Container Apps: an honest head-to-head
- Sparse Files and Hole Punching: Why Your Snapshot Lies About Its Size
- MAP_PRIVATE vs MAP_SHARED: The mmap Flag That Decides Everything
- One Demo per Prospect: Sales Environments You Can Throw Away
- Your Firecracker Snapshot Restore Failed: A Field Guide
- You Ship the Kernel: Firecracker Guest 5.10 vs 6.1
- Should You Compress Firecracker Memory Snapshots?
- The best Morph Cloud alternatives in 2026
- fsfreeze and the Three Tiers of Snapshot Consistency
- overlayfs Inside the Guest: Read-Only Rootfs, Writable Upper Layer
- Firecracker on arm64 vs x86_64: What Actually Differs
- How to persist data in a sandbox
- Running academic artifact evaluation on microVMs
- Memory Prefetch: The Working Set Is the Real Unit of a Fast Restore
- Running background workers next to your web app
- Keeping a browser logged in without storing passwords
- Best Postgres Database Branching Platforms (2026)
- Snapshot-Restore vs Live Migration: Not the Same Problem
- Scale-to-zero app hosting, and what it costs you
- Suspending idle Postgres databases
- PandaStack vs Morph Cloud: Snapshot-First Sandboxes
- How to Write a userfaultfd Handler for Firecracker
- Merging and Inspecting Firecracker Snapshots: snapshot-editor and the Rebase Workflow
- Snapshot, Restore, and the Connections You Left Open
- virtio-blk Discard and TRIM in Firecracker, Explained
- Database Branching with Copy-on-Write MicroVMs
- Firecracker Hugepages for Guest Memory, Explained
- What's Actually Inside a Firecracker Snapshot
- NUMA Locality and Firecracker Snapshot Restore
- Snapshot Restore vs Process Preforking: Same Idea, Different Boundary
- Snapshot Restore vs Cold Boot: The Tradeoffs Nobody Lists
- Guest Clocks, Snapshots, and the Time Travel Problem
- Replicating Firecracker Snapshots Across Regions
- Snapshot Restore vs Container Image Pull: Two Ways to Start Fast
- The Snapshot Clone Randomness Problem
- Swap and zram Inside a Firecracker MicroVM: What Actually Happens
- Guest Clock Drift After a Firecracker Snapshot Restore
- Firecracker CPUID masking, explained
- Guest page cache: why it bloats microVM snapshots
- Snapshot vs restore vs fork vs clone, explained
- Firecracker Dirty Page Tracking, Explained
- Firecracker Guest Memory Layout, Explained
- How Firecracker Restores Guest Memory: mmap & MAP_PRIVATE
- Guest Clocks and the TSC After a Firecracker Restore
- Restoring a Firecracker Snapshot on a Different CPU
- The Firecracker VMGenID Device, Explained
- Snapshot-Restore vs Fork: When to Use Which
- How Copy-on-Write Page Tables Work (and Why VM Fork Is Fast)
- Giving AI Agents Persistent Memory & State via microVM Snapshots
- Always-On vs Scale-to-Zero AI Agent Infrastructure
- Firecracker virtio-rng and Guest Entropy Explained
- Firecracker Snapshot Version Compatibility & Cross-Version Restore
- microVM Memory: Balloon vs Hotplug vs Re-Provision
- Best Firecracker Snapshot & Restore Tools (2026)
- Firecracker Diff Snapshots Explained
- Copy-on-Write and the Page-Fault Lifecycle, Step by Step
- Firecracker Snapshot-Restore vs AWS Lambda SnapStart
- Fan Out Monte Carlo Trials by Forking a Warm MicroVM
- Copy-on-Write Memory: Why Forking a VM's RAM Is Cheap
- Running Long-Lived AI Agent Tasks in microVMs Without Paying for Idle
- The Zygote Pattern: Fork One Warm Snapshot Into Thousands of MicroVMs
- Firecracker Snapshot/Restore vs CRIU Checkpoint/Restore
- The Serverless Cold-Start Problem, Explained
- Firecracker CPU Templates, Explained
- Shared Pages & Copy-on-Write: Packing MicroVMs Densely
- Snapshot-Restore vs Warm Pools: Two Ways to Kill Sandbox Cold Starts
- The Security Gotchas of Firecracker Snapshots (Secrets Frozen in RAM)
- Copy-on-Write Rootfs: dm-snapshot vs reflink for MicroVMs
- The Anatomy of a Sub-200ms MicroVM Create
- Kill Cold Starts with microVM Snapshotting: Warm Starts Without a Warm Pool
- Fork a microVM for Tree-of-Thought Agents
- Memory Overcommit & Page Sharing: How MicroVMs Get Dense
- The Snapshot-Restore Boot Path: Every Sandbox in Under 200ms
- How to Optimize MicroVM Cold Start
- How Firecracker Memory Snapshots Actually Work
- Thaw: How We Made a Cold Start Take 164ms
- Copy-on-Write Rootfs: Why MicroVM Create Is O(metadata)
- userfaultfd: Lazy Memory for Instant VM Restore
- How PandaStack Creates a MicroVM in Under 200ms
- Snapshots and Forks: Copy-on-Write for Running Machines