Inside ESA: How vSAN Writes Now
Most explanations of vSAN were written against the original architecture (OSA) and never got revised. They start with disk groups and cache tiers, because for a decade that's how vSAN stored data. The Express Storage Architecture (ESA) replaced the storage engine underneath the same distributed object model, and that changed what a write is: where it lands, what makes it durable, and which of the old trade-offs still exist.
A write is acknowledged when it's durable (on the default path, from a mirrored durable log), and the expensive work, parity and deduplication, happens later, off the guest's clock. Compression runs in line, at the top of the stack as the write enters, so every byte downstream travels smaller. One class of write, on the adaptive write path, reaches durability a different way.
A VMDK is an object spread across hosts
A virtual disk is an object: a set of components that a placement engine scattered across the cluster's hosts according to policy. It doesn't map to a LUN or to a file on a datastore, and it doesn't sit whole on the host running the VM. The VM's home directory (the namespace object) is built the same way. A running VM carries a swap object as well; the drawing leaves it out.
In ESA, every object has the same two-part anatomy. The performance leg is a mirrored log component. It's a mirror under every policy; the policy only sets how many copies it keeps: two at FTT=1, three at FTT=2. The capacity leg holds the long-term packaged form of the data. When a policy says RAID-1 or RAID-5, it's describing the capacity leg's shape.
Whether the VM's host holds a component depends on placement. On three hosts a 2+1 stripe puts data on every host, and here the VM's host also holds a log mirror.
The six roles
Six roles handle every object.
- DOM client lives on the host running the VM and takes the guest's I/O first. It consults its host's cached copy of the directory, so it doesn't look anything up over the wire per I/O.
- CMMDS is that directory. It tracks which objects exist, where their components sit, and the state of the cluster. Every host keeps a cached copy and consults it from memory; CMMDS isn't in the data path.
- DOM owner coordinates everything that happens to an object, and there's one per object. It can live on any host (the VM's own, one that holds a component, or neither), and ownership can move.
- DOM component manager runs on each host that holds components and manages them on the owner's behalf. When a write crosses the cluster, the conversation is DOM-to-DOM: owner to component manager.
- LSOM is the local storage layer on each host, and it doesn't talk to other hosts. It takes the component manager's instructions and turns them into durable writes on that host's devices (in ESA, appends to a log).
- CLOM decides where components go when an object is created, when policy changes, and when something breaks and the object must be rebuilt. CLOM isn't in the I/O path.
For resilience, a policy states how many failures the object must tolerate (FTT) and how the capacity leg achieves it, by mirroring or erasure coding. With Auto-RAID, it leaves both choices to vSAN by cluster size.
The write, end to end
In this example the VM's host holds one of the object's two log mirrors, and the write still goes through the owner on another host.
The DOM client on the VM's host checks its cached directory, finds the object's owner, and forwards the write to it, here on Host B. The owner fans the write out in parallel to both log mirrors. One mirror is local to the owner, so the write goes straight down through the component manager to LSOM and into the log on Host B's pool. The other crosses back to the VM's own host (DOM-to-DOM, owner to Host A's component manager) and lands in the log there the same way. Each side acknowledges back to the owner; the owner confirms to the client; the guest's I/O completes.
The guest's write is acknowledged once both log mirrors have it, and at that point the write is durable twice. The final, packaged form of the data comes later.
That's the default path. Since vSAN 8 U1, ESA also has an adaptive write path for the writes the log serves worst: large I/O sizes, or large amounts of I/O outstanding. Those writes skip the log for their data. The payload commits as a full stripe write, in the policy's final shape, and only the metadata rides the durable log, mirrored like everything else in it. The acknowledgment waits for both (data durable in the stripe, metadata durable in the log), so the guest gets the same guarantee. Only the mechanism changes; mirroring a large streaming payload through a log would be pure overhead on data that's already stripe-shaped.
Reads go through the owner too: it serves recent writes from its in-memory stripe buffer while it still holds them, and finds everything else through metadata and reads it from the stripe member that holds the block. Neither log takes part; VMware's reads post says so explicitly. In current ESA, the only read locality is per site, in stretched and two-node clusters, where reads stay on the VM's site.
How OSA and ESA store a write
Everything above (objects, owners, the fan-out) is the same distributed system in both architectures. What changed is the storage layer underneath it.
The misunderstanding I run into most often is that the performance leg is OSA's cache tier with a new name. In OSA, the fast landing zone was a device. In ESA, it's a role the same drives play.
In OSA, the unit of storage on a host is the disk group: one cache device fronting a set of capacity devices. A write lands in the cache device's write buffer and is acknowledged from there. Later, on the cache's schedule, it destages: it's read back, assembled, and written down to the capacity devices, which are separate devices. The cache tier is a physical boundary and a behavioral one: a cache device failure takes its entire disk group with it, destage pressure is a latency cliff you plan around, and services like deduplication run at destage time, scoped to the disk group. That kept the dedup domain small, and the ratios with it.
ESA drops the disk group. A host has one storage pool: a set of NVMe devices, all peers, with no separate cache device and no second tier of drives below it. Writes don't destage between tiers, because nothing crosses a device boundary. (Broadcom's documentation also uses the word for the log drain.) The write lands in a log-structured store (the LFS log) on the pool's own devices. The log entry is durable, checksummed data from the moment it lands, on the same pool of drives the capacity leg uses. The boundary between ESA's two legs is logical; in OSA it was a physical device.
Afterward, the logged write is reorganized into its long-term form.
The write arrives, is appended to the log, and the guest is acknowledged. The data stays in log form, durable, until the packaging pass runs in the background and assembles the logged data into the capacity leg's long-term form (full stripes, in the policy's shape); the log space is reclaimed as the log wraps. The two events, acknowledge the guest and put the data in its final form, happen separately, and on the default path only the first is on the guest's clock.
My lab runs this architecture, and I wrote up separately the operational side of its newer services: the cluster-wide dedup store and what it creates when you turn it on. ESA's efficiency work runs off the guest's clock, on machinery that was already running: on the default path, parity rides the packaging pass in that diagram, and deduplication runs as throttled post-processing.
Why dedup and erasure coding stopped being trade-offs
On the default path, ESA writes everything twice. Once into the log, fast, on the guest's clock, and once into the packaged capacity leg, later, in the background. Large streaming writes skip the first of those and land in final form directly. The second write is part of the architecture, and the pass runs whether you use any efficiency feature or not. That makes a pass that rewrites every byte in final form a good place for the expensive work storage people used to apologize for, because the guest already has its acknowledgment. Deduplication follows the same rule one step later: it runs after the pass, as post-processing on data already in its long-term form.
Deduplication is the first example. In OSA, dedup's domain was the disk group: it deduplicated within one disk group's devices, at destage, tied to a cache device whose behavior changed when you enabled it. The question was "can we afford dedup?" and it was a real question. In ESA the domain is the whole cluster: one store, cluster-wide, because object management already is. As of VCF 9.1, global deduplication isn't supported on stretched or two-node clusters. The deduplication itself is post-processing: a background service works over data already persisted in its long-term form (adaptively throttled, cold data first), keeping one copy and referencing the rest. The guest doesn't wait on hashing, and the service is designed to run in the background when CPU demand is low. Turning it on doesn't change any device's role, because there's no cache tier for it to take from. The question becomes "why wouldn't you?" The caveats stay: hashing costs CPU, and ratios depend on your data. Dedup still has a cost; it's no longer a trade-off.
Erasure coding works the same way, and it took me longer to see it because its reputation is older. RAID-5 and RAID-6 carried that reputation for two decades: capacity-efficient and write-punishing, with parity math in the data path, so you mirrored what you cared about and erasure-coded what you had to. In ESA that objection has no mechanism left. On the default path, the performance leg takes the write as a mirror, at mirror speed, under every policy. On the adaptive path, the write lands as a full stripe, the one shape erasure coding produces without a read-modify-write. Either way, parity math never forces a read-modify-write before the guest's acknowledgment; on the default path it is computed during packaging, afterward, from data already durable.
VMware's stated claim is that ESA's erasure coding performs equal to or better than RAID-1 mirroring. The drawing shows why: on the default path, the guest is acknowledged before the write reaches the capacity leg. The policy sets capacity and failure tolerance: 2.0× for the mirror, 1.5× for erasure coding at small scale, and under a manual policy the RAID-5 stripes widen as the cluster grows. That's the decision it always should have been, without the performance penalty it used to carry. Current Broadcom guidance recommends erasure coding by cluster size as the default, and VCF 9.1's Auto-RAID makes the choice for you: it holds RAID-5 at 2+1 and steps up to RAID-6 once the cluster is large enough, at the same 1.5× either way. The rebuild math is still a capacity-planning question: resyncs spend CPU and network, and parity rebuilds spend more of both.
A device failure costs the pool only the data that was on that device. There's no destage cliff, because nothing drains across a device boundary anymore. ESA has one kind of device, one pool, and one path built for NVMe, where OSA's design also had to serve spinning disks behind flash cache devices.
From the support seat, the pattern I watch now is where the pain moved. Once the storage layer acknowledges from a log and reorganizes in the background, it stops being the slow, fragile part of the write, and the pressure increasingly lands on the wire between the hosts. That is a different argument, with numbers, and it gets its own piece.
Sources
- Performance Improvements with the Express Storage Architecture in vSAN 8 U1: the adaptive write path.
- Performance Improvements with the Express Storage Architecture in vSAN 8 U2: the I/O bank, where data and metadata are prepared in memory for the full stripe write.
- Performance Recommendations for vSAN ESA: erasure coding performance and policy guidance.
- More Capacity with VMware vSAN Compression and Global Deduplication in VCF 9.1: global deduplication and its topology limits.
- Auto-RAID in VMware vSAN for VCF 9.1: system-managed resilience by cluster size.
- vSAN Frequently Asked Questions: where the witness components went, and how ESA objects reach quorum.
- Fast and Efficient Reads in vSAN ESA: reads are served from the owner's stripe buffer and through metadata, and neither log takes part.
- RAID-5/6 with the Performance of RAID-1 using the vSAN ESA: the LFS write path (coalesce, mirror, acknowledge, full-stripe write later).
- vSAN Space Efficiency Technologies: compression, encryption, and checksum processing run in line, near the top of the storage stack.
- vSAN VM Creation Workflow (KB 326497): DOM client, owner, and component manager roles.
- Glossary of vSAN Terms and Acronyms (KB 326549): the vocabulary of the roles section.
- vSAN 8.0 ESA and Compression by Default (Yellow Bricks): compression happens once, on the source host.
Updated Nov 16, 2026: corrected the owner-placement and reads descriptions, removed a commit-protocol claim I couldn't source publicly, and redrew the object and write-flow diagrams from my own lab captures. Updated Nov 17, 2026: redrew the object, lifecycle and policy diagrams, corrected the packaging description throughout, and edited the prose and diagram labels for clarity.