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 restore108 posts
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.
A Real Red-Green Loop for Coding Agents, One MicroVM per Attempt
The single highest-signal tool you can hand a coding agent is a test runner it can actually run. Here is the two-layer architecture that makes the loop fast enough to use, the output format a model can read, and the limits the loop exists to discover you forgot.
Audit Trails When the Machine Is Gone in 200 Milliseconds
The thing that makes a sandbox safe — it is destroyed — is exactly what makes "what did the agent do at 03:14?" unanswerable. You cannot keep the machine. You can keep its memory and disk.
Running MATLAB and Octave Workloads in Isolated microVMs
Most runtime isolation problems are technical. This one starts with a contract: you cannot fan out 200 MATLAB processes without the entitlements to match. Here is the honest version — licence manager, MATLAB Runtime, Octave's real compatibility cliff, and why the guest boundary wants to be a VM.
Self-Hosting a Compiler Explorer: Running Strangers' Compilers Safely
"I'm not running their code, I'm only compiling it" is the most expensive sentence in this genre. A compiler is a programmable machine with a filesystem, a plugin loader and an unbounded appetite for RAM — and on a compiler explorer, the flags are user input too.
Mutation Testing at Scale: Thousands of Broken Builds on Purpose
A test suite is a claim: that if this code were wrong, something here would fail. Mutation testing is the only honest way to check that claim — break the code on purpose, thousands of times, and see what the suite notices. Which makes it a scheduling problem.
One microVM per Attendee: Hands-On Labs for a Whole Room at Once
Two hundred people arrive inside the same ninety seconds, all do the same thing at the same time, and all vanish at 5pm. That load shape breaks pre-provisioning in both directions — and it is exactly what snapshot-restore-per-create is for.
More posts in this topic
- 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