Every data hoarder eventually hears that you can “throw an SSD at ZFS” to speed things up, and then runs into the problem that ZFS actually has three unrelated ways to do that, with very different costs and very different payoffs. A special vdev, L2ARC, and a SLOG solve three different problems, and for a typical bulk-storage pool full of media, backups, and archives, one of them is genuinely worth doing, one is situational, and one does almost nothing for this workload no matter how fast the drive is. Mixing them up is the single easiest way to spend money on flash and get disappointed.
This article assumes a pool of spinning disks doing what spinning disks in a data hoard normally do: storing a large, mostly-static collection of big files, written once and read occasionally, with a long tail of small files (thumbnails, .nfo sidecars, config, metadata) mixed in. If your workload looks different, a database, a hypervisor’s VM storage, heavy synchronous NFS writes, the answer changes, and those cases are called out separately below.
The three layers, briefly
L2ARC (Level 2 Adaptive Replacement Cache) is a read cache. ZFS already caches hot data in RAM (the ARC), and L2ARC extends that cache onto a fast device when RAM runs out, holding evicted ARC entries so a repeat read can come from flash instead of spinning disk. It is purely a cache: losing the L2ARC device loses nothing, ZFS just falls back to reading from the pool like the cache was never there.
SLOG (Separate intent LOG) accelerates the ZFS Intent Log, which exists to make synchronous writes safe without waiting for the full transaction group to commit to the pool. A SLOG only helps sync=always writes or explicit fsync() calls, things like NFS with default sync behavior, databases, or VM storage. It does nothing at all for ordinary asynchronous writes, which is most of what a media server, backup target, or torrent client actually does.
Special vdev is not a cache, it’s a real part of the pool. You tell ZFS to store metadata (and optionally small file data below a size threshold you set) on a dedicated set of fast devices instead of on the spinning disks. Unlike L2ARC, a special vdev holds data ZFS cannot regenerate from the main pool. Lose it without redundancy and you lose the pool, full stop. It needs mirrored redundancy matching the rest of the pool’s risk tolerance, not a single bare SSD.
Why special vdev is usually the one worth doing
A data hoard’s directory-listing and metadata operations, ls, scrubs, rsync dry-runs, Plex/Jellyfin library scans, Sonarr/Radarr checking what already exists, are murder on spinning disks specifically because metadata is small and scattered, which turns a sequential-read-friendly HDD array into a seek-bound mess. None of that workload is sequential. A special vdev moves exactly that traffic onto flash permanently, not as a cache that can miss, and the difference shows up immediately in anything that touches “does this file exist and what are its attributes” across a large tree: full scrubs, media server library scans, and backup software doing its initial file-list pass before it even starts moving bytes.
The optional small-file threshold (special_small_blocks) extends this further: files below a size you set get written to the special vdev entirely instead of the spinning disks. For a hoard with a long tail of tiny files, subtitle files, .nfo metadata, thumbnail caches, this can meaningfully cut the number of HDD seeks per directory, since those tiny reads never touch spinning disk at all.
The catch that matters most: special_small_blocks only applies to new writes going forward. Setting the property on an existing dataset does not retroactively move already-written small files onto the special vdev; they stay on spinning disk until rewritten. If you want the effect across your existing library, you need to actually rewrite the data (a zfs send/receive into a fresh dataset with the property already set, or a straight file copy into a new dataset, is the practical way to do it), not just flip the setting and expect it to apply itself.
The other catch: a special vdev is a single point of total pool failure if it isn’t redundant. This isn’t optional risk-tolerance tuning the way it might be for L2ARC. If your main pool is, say, a RAIDZ2 that survives two drive failures, a special vdev on a single unmirrored SSD undoes that entire guarantee, because losing that one drive takes the whole pool’s metadata with it, and the pool is gone. Mirror it (two or three small, reliable SSDs) at a redundancy level you’re comfortable losing the whole pool over, and size it generously, metadata plus the small-file tier can genuinely consume more space than people expect once you’ve been running it a while. Check actual usage with zpool list -v after it’s been live for a few weeks rather than guessing up front.
Why L2ARC is situational, not automatic
L2ARC sounds like the obvious answer, cheap flash extending your read cache, but it has a cost that catches people off guard: L2ARC headers live in RAM, not just the device itself. Every entry cached on the L2ARC device needs a small amount of ARC memory to track it, which means a large L2ARC on a RAM-constrained box can actually shrink the effective size of the real (and much faster) RAM-based ARC, making things worse, not better. This is a smaller problem on modern OpenZFS than it was years ago (compressed ARC headers help), but it’s still a real tradeoff, not a free lunch, and it’s the reason the old rule of thumb “don’t bother with L2ARC under ~32GB of RAM” still has some truth to it even if the exact number has loosened.
For a data hoard specifically, L2ARC earns its keep when there’s a genuinely hot, bounded working set that doesn’t fit in RAM, a frequently re-watched media library, a *arr stack’s active-download working directory, a photo library’s thumbnail set, something with real read locality rather than a one-time archival dump nobody touches again. It does nothing for data you write once and read once, years later, if ever, because nothing about that pattern benefits from caching: there’s no repeat read to accelerate. If your pool is mostly cold archival storage, skip it; the special vdev is doing the real work and L2ARC would just be flash sitting there mostly idle.
If you do add it, size expectations honestly: L2ARC is a cache, not a tier, so it only helps the fraction of your data that’s actually re-read, and monitoring whether it’s earning its slot (arcstat or zpool iostat -v showing real hit rates on the cache device) matters more here than for special vdev, where the benefit is structural and doesn’t depend on access patterns.
Why SLOG is almost always the wrong answer here
This is the one people reach for first because “write cache” sounds like exactly what a storage pool needs, and it’s almost always the wrong tool for a data hoarder’s workload specifically. SLOG only accelerates synchronous writes, and the overwhelming majority of what fills a media/archival pool, bulk file copies, torrent downloads, rclone/rsync transfers, backup software writing full files, is asynchronous by default. ZFS already batches async writes efficiently through its normal transaction group mechanism; a SLOG device sits there unused for that traffic because there’s nothing synchronous happening to accelerate.
SLOG earns its cost on a different workload: NFS exports where clients force sync writes (some NFS clients default to sync, VMware’s NFS datastore writes being the canonical example), database files living on the pool, or VM disk images where the guest OS expects write durability guarantees on every commit. If none of that describes your pool, a SLOG device is close to dead weight, and the money is better spent on the special vdev or just more spinning disk.
Putting it together
For a typical data hoarder’s pool, mixed media, backups, and archives, the practical order of priority is usually: add a mirrored special vdev first, since it fixes the directory/metadata slowness that affects every single operation on the pool, every scrub, every scan, every ls; add L2ARC only if there’s a real, bounded hot set you can name (a specific frequently-accessed library, not “the whole pool”); and skip SLOG entirely unless you can point to a specific synchronous-write workload, an NFS datastore, a database, actually living on that pool. None of these decisions are reversible for free, a special vdev especially can’t be removed from some older pool layouts without rebuilding, so it’s worth being honest about which problem you actually have before buying flash to solve it.