TLDR: This issue is way more complicated than you think, and the linked article is not very helpful in understanding it.  It&#x27;s fair to say that ZFS is as good as or better than anything else out there for any given storage topology and error case, but using ZFS in a redundant pool configuration is still necessary for universally good results.<p>As usual with a technical subject, one has to be a lot more specific to get to the truth, both in describing the problem and identifying the exact behavior of software in response.  &quot;Disk failure&quot; covers a lot of ground, and the article you linked doesn&#x27;t narrow it down all that much.<p>User data is stored on disk (or other media) along with a large number of ECC bits; the vendors know that bits rot on disk or in flash, and this allows transparent correction of most errors.  So bits rot all the time and you normally never notice it; the rot is corrected by the disk firmware before any data is ever returned.  Of greater interest are sectors that are repeatedly read in a way that they have so many errors as to be uncorrectable, which is probably what the author of that article intended to address.  A disk that reliably fails a request for such a sector produces an error visible to the OS (or off-CPU RAID controller if in use), so that it can be tried against a mirror or computed from parity as appropriate.  This case produces much the same result no matter what RAID or filesystem technology you use: a very slow read that eventually returns correct data.  Other things may happen, too, like incrementing fault counters, sparing out the disk, rewriting the bad block (onto the same or a different location on the same or another disk), etc.  These are dependent on the disk firmware and RAID or volume management implementation, and it&#x27;s worth noting them because they greatly affect what happens the next time you try to read the same block and ultimately how likely you are to lose data to these defects.<p>However, the more interesting cases (which the ZFS authors understand very well but were not specifically described in this article because its author does not appear to understand how disks work) are those in which the wrong data is returned.  Contrary to the author&#x27;s idea, this is usually not caused by media errors as those are almost always detected by ECC firmware.  Instead, they are caused by bugs in the disk firmware, or even more commonly the OS, such as enabling a disk&#x27;s write cache and then not flushing it to close the filesystem transaction.  As another example, some software RAID implementations (and&#x2F;or filesystems) by design require a nonvolatile cache for correctness, especially if parity RAID is used, but many machines do not have one installed or configured for use by software.  Such problems cannot be corrected at read time; it&#x27;s too late.  There are of course many other causes of such &quot;phantom writes&quot; and all manner of other firmware bugs, and it&#x27;s important to characterize them more fully.  For example, sometimes a re-read of the same block will return correct data, assuming it was written in the first place, and sometimes it won&#x27;t (even better, sometimes whether it does or not depends on transient and unobservable state!).  Regardless of the underlying cause, ZFS can protect the user application from being given incorrect data, assuming the corruption is not happening within the computer itself, such as may be caused by an OS bug, non-ECC DRAM, or a bad CPU.  If you use RAID (mirrors or parity) with ZFS, it can often return the correct data instead, and fix up the problem in the background as well as keeping track of these problems so that persistently or severely faulty disks can be condemned.  Even if you do not use RAID, ZFS will (possibly after various retries) turn this into something that looks like an unrecoverable media error; the application gets EIO.  Of course, in that case your data is still lost (unless you elected to enable ditto blocks for user data...).<p>There&#x27;s plenty more complexity here if you delve down into all the specific failure modes.  Disks have an awful lot of them, and doing the right thing, or even agreeing on what the right thing is, for every one is difficult.  Do you fail and spare out the disk?  Do you count the errors and fail it after N of them?  Do you rewrite the block, and if so at what address?  Do you retry?  How many times, and for how long?  What if the disk returns correct data but only after a long time (usually caused by internal firmware retries)?  And so on.<p>&quot;Bit rot&quot;, i.e., silent bit flips within underlying media, may be real, but it&#x27;s not directly observable by software and it&#x27;s only the least interesting tip of the disk failure iceberg.