What is a microVM? Dedicated-kernel isolation, explained

Contents
What is a microVM?
A microVM is a virtual machine built to behave like a container. It runs a real guest kernel on top of hardware virtualisation, KVM on Linux hosts, but it throws away nearly everything a traditional VM emulates: no legacy device-bus enumeration, no graphics stack, no chipset trivia, just a minimal set of virtio-style interfaces for network, block and a serial console. Strip that much machinery and the interesting properties fall out. Boot times land in the tens of milliseconds rather than the tens of seconds. Memory overhead per machine drops to single-digit megabytes. A single host can create and destroy them at rates measured in hundreds per second, which is what makes per-request virtual machines economically sane at all.
The term entered the industry vocabulary through large-scale serverless platforms, and the pattern is now the standard answer to one specific question: how do you run thousands of strangers’ processes on one machine without trusting any of them? AWS documents Lambda as running each workload in a dedicated microVM, and sandbox products across the field, including ours, use the same shape. The published design targets for modern minimal VMMs are a boot under 125 ms and creation of well over 100 microVMs per second per host core.
Container, VM, microVM: the actual differences
| Container | Traditional VM | MicroVM | |
|---|---|---|---|
| Kernel | Shared with the host | Own guest kernel | Own guest kernel |
| Isolation boundary | Namespaces and cgroups (a kernel feature) | Hypervisor (hardware-assisted) | Hypervisor (hardware-assisted) |
| Boot time | Milliseconds | Tens of seconds | Tens of milliseconds |
| Memory overhead | Near zero | Hundreds of MB | Single-digit MiB plus guest |
| Density per host | Very high | Low | High |
| Right for | Your own reviewed code, single tenant | Long-lived stateful machines, custom kernels | Multi-tenant code, untrusted or generated workloads, per-task isolation |
The middle column is what microVMs replaced for serverless work, and the left column is what they feel like from the developer’s seat. You still ship an OCI image. You still get a process that starts fast. The difference is what sits between your process and your neighbour’s: a shared kernel with a namespace boundary, or a hypervisor with a hardware one.
Why the kernel boundary is suddenly the question
For most of cloud history this was an architecture-astronaut’s question. You deployed code your team wrote and reviewed, containers isolated tenants well enough, and the marginal risk of a shared kernel was priced in and accepted. Two shifts changed the calculus.
The first is multi-tenant compute at the function level: platforms that run a different customer’s code in every invocation cannot vet what they are running, so they isolate per workload with hardware and treat every invocation as untrusted. The second is newer and sharper. Agents now write code at runtime and execute it immediately, a shell command composed by a model, a script generated to answer a question, a test suite invented on the spot. Nobody reviewed it because nobody wrote it. When we built agent sandboxes for exactly this workload, the constraint that mattered was trust rather than performance: whatever executes generated code must not share a kernel with anything else, including our own services. That is a microVM requirement, and it is why the isolation line on hosting comparison tables stopped being a footnote. The fuller version of this argument, including where shared-kernel containers remain the right call, is in app hosting in 2026.
One honesty note, because comparison tables rarely carry it: several popular platforms publish no statement either way about the kernel boundary between tenants. Absence of a published claim is not evidence of a weak boundary, and shared-kernel isolation holds up for the overwhelming majority of workloads. But if your workload is the minority case, runtime-generated or genuinely hostile code, the right move is to ask the vendor directly and get the answer in writing.
How we use microVMs
On Scalix, the dedicated kernel is the default unit of compute rather than a tier you buy. Every Scalix Run deployment boots its own microVM from your container image or source directory; every function invocation runs in one that scales to zero between calls; every sandbox an agent provisions for generated code is one with a lifetime measured in minutes; every persistent computer is a long-lived one you can ssh into and park.
The numbers we publish, with their exact meanings: the microVM boot on our hardware measures about 76 ms, VMM to userspace, which is the kernel coming up in isolation and not a create-to-ready or cold-start figure. A function cold start, which includes runtime and application init after the boot, runs about 1.6 s, and warm invocations return in roughly 15 ms. Because the machines are this cheap to create, the billing model can follow them down: compute meters per second while a microVM is awake and stops at zero when it parks, which is the mechanism behind scale-to-zero on every product above.
When you do not need one
A microVM is not automatically the right answer, and the vendors selling them should say so. If you run your own reviewed services on hardware you control, with a single tenant per host, containers give you nearly the same density with less machinery, and the hypervisor layer buys you a boundary you may never test. If your workload needs a kernel module, exotic sysctls, or a network stack the minimal device model does not expose, a traditional VM or bare metal remains the honest choice. The microVM earns its place precisely where the trust model demands it: other people’s code, generated code, and per-task isolation you can defend to a security team without a caveat sentence.
If you want to feel the difference rather than read about it, provision a sandbox through the API and watch it come up in seconds, or run the same generated-code experiment against your current host and ask what sits between it and the neighbours. Both are afternoon exercises, and the second one is the more interesting.
FAQ
What is a microVM in simple terms?
A microVM is a small, fast virtual machine. It runs a real guest kernel on hardware virtualisation (KVM on Linux), but strips everything a traditional VM carries: a minimal device model with only a handful of emulated devices, a slim kernel, and a small memory footprint. The result boots in tens of milliseconds instead of tens of seconds and packs densely onto a host, while keeping the isolation property that counts: each workload has its own kernel.
What is the difference between a microVM and a container?
A container is a namespaced process on the host's shared kernel; the isolation is a kernel feature, not a kernel boundary. A microVM runs the workload inside its own guest kernel, separated by the CPU's hardware virtualisation. If the workload is your own reviewed code, containers are good isolation and cheaper. If the workload was generated at runtime by a model, or belongs to another tenant, the hardware boundary is the defensible one.
Why do serverless platforms use microVMs?
Multi-tenancy. A serverless host runs code from thousands of unrelated customers, often code that was written seconds ago by an LLM, and cannot reason about what any of it will try. Hardware-level isolation per invocation is the only boundary that holds without trusting the guest. AWS documents Lambda as running workloads in dedicated microVMs, and the pattern is now standard across sandbox and function products.
How fast does a microVM boot?
The published design targets for modern minimal VMMs are under 125 ms and creation rates of well over a hundred per second per host core. On our own hardware the microVM boot measures about 76 ms from VMM to userspace. A function cold start is a longer number than the boot, because the runtime and application initialise after the kernel comes up: on Scalix Functions a cold start runs about 1.6 s, with warm invocations returning in roughly 15 ms.
Does Scalix run containers or microVMs?
Both words apply, which is the point. You deploy an OCI container image or a source directory, and it runs inside a dedicated-kernel microVM: every Scalix Run deployment, function invocation, sandbox and computer gets its own kernel by default rather than as a premium tier. The developer surface is a container; the isolation boundary is a VM.