Storage Explained
September 6, 2026 • 7 min read
Table of Contents
Part of the series:Computers
The memory post ended at the bottom of the hierarchy: the non-volatile world where data rests for years. This post stays there. We will look at what makes storage different from memory, the two machines that dominate it, spinning disks and flash drives, the cells and blocks they are built from, the two access patterns that decide their speed, and the three numbers that describe every drive. Filesystems (how bytes on a drive become files and folders) belong to the future operating-systems series, not to this one.
Persistent storage: memory that survives power loss
Computer data storage1 answers a need memory cannot: keeping information without power, for years, at a cost per byte orders of magnitude below RAM. The price is speed: conventional persistent storage such as hard drives and SSDs is far slower than main memory, and it comes with a different contract: storage is accessed in fixed-size chunks through a controller, never byte by byte by the CPU directly.
That contract shapes everything below. Programs and data rest on storage; running means being copied into memory first. Booting, launching an app, and opening a document each migrate up the hierarchy from the slow persistent world to the fast volatile one.
HDD: bits as magnetism
A hard disk drive2 stores bits as magnetic patterns on spinning metal platters coated with magnetic material. An arm carrying read/write heads floats nanometers above the surface and reads magnetic patterns that encode bits.
Three consequences follow from moving parts. First, mechanical positioning dominates: before any byte flows, the arm must seek to the right track (seek time) and then wait for the platter to rotate the right sector under the head (rotational latency), together several milliseconds of mechanics and electronics. Second, capacity is cheap: platters are simple surfaces, so terabytes cost little. Third, the drive is fragile and power-hungry next to solid-state alternatives: it spins, vibrates, and dislikes being dropped.
SSD: bits as trapped charge
A solid-state drive3 has no moving parts. It stores bits as electrical charge trapped in NAND flash4 cells: transistors with an isolated charge-storage structure where charge, once forced in, stays put for years without power.
An SSD is therefore silent, shock-resistant, and far quicker to first byte than a disk: there is no arm to move, only electronic addressing. But it is not simply “fast memory.” Flash imposes its own rules, covered below, and an SSD is a whole computer in miniature, with controller, firmware, DRAM cache, and flash chips cooperating to hide those rules from the operating system.
NAND flash: cells, pages, blocks
A NAND flash cell stores charge levels, not just presence or absence. The common densities trade precision for capacity:
SLC 1 bit per cell 2 levels fastest, most durable, priciest
MLC 2 bits per cell 4 levels balanced
TLC 3 bits per cell 8 levels dense, common in consumer drives
QLC 4 bits per cell 16 levels densest, slowest, wears fastestMore bits per cell means cheaper gigabytes but narrower margins between levels, which tends to mean slower writes, lower endurance, and more error correction. There is no free density.
Cells are organized into pages (typically 4–16 KiB), the unit of programming and reading, grouped into blocks (typically hundreds of pages), the unit of erasing. And here is flash’s central asymmetry: a page can only be programmed when it is in an erased state, and erasing destroys the whole block at once. When software overwrites data, the flash translation layer typically writes the new version to a different erased page and marks the old one invalid; later, during garbage collection, it relocates still-valid pages and erases the block. That extra internal copying is a hidden tax called write amplification. Each block also wears out after a finite number of erase cycles (typically thousands of cycles for common consumer NAND, more for some MLC and enterprise parts), so firmware spreads writes evenly (wear leveling) to age the drive uniformly.
Sectors and blocks: the language of drives
Whatever the physics, drives speak in chunks. A disk sector5 (classically 512 bytes, on modern drives usually 4 KiB) is the smallest unit the operating system reads or writes on a disk. Flash pages and blocks are the corresponding internal units on SSDs: pages for programming and reading, blocks for erasure.
This chunking is why small scattered writes can cost more than their size suggests, through positioning delays on disks or extra mapping and cleanup work inside SSDs, and that is why operating systems, databases, and filesystems align their structures to these sizes. The byte-addressability of memory is gone; storage deals in parcels.
Sequential vs random access: the pattern decides the speed
The same drive shows two very different speeds depending on how it is asked. Sequential access reads or writes one long run of consecutive chunks; random access jumps between scattered locations.
On a hard drive the gap is enormous: sequential reads stream at well over a hundred megabytes per second once positioned, while random reads of small chunks collapse to well under one megabyte per second, since each jump pays a fresh multi-millisecond seek. On an SSD the gap is far narrower but still real: sequential transfers saturate the interface (gigabytes per second on NVMe), while small random reads, though thousands of times faster than a disk’s, still run at a fraction of sequential throughput.
Two practical lessons fall out. First, layout matters: logs, video files, and backups, which are naturally sequential, are the kindest workloads for any drive. Second, much of systems engineering (caches, prefetching, and log-structured designs) is often the art of turning random access into sequential access before it reaches the drive. Defragmentation follows the same idea on hard drives by regrouping scattered data; on SSDs it generally brings little performance benefit and can add unnecessary writes.
Three numbers: latency, throughput, capacity
As with memory, three numbers describe a drive to first order:
- Latency: how long before the first byte arrives. Hard drives answer in milliseconds (mechanical positioning); SSDs in tens of microseconds6, roughly a hundred times quicker, yet still thousands of times slower than main memory’s tens of nanoseconds. Latency is what makes a system feel responsive.
- Throughput (bandwidth): how much streams per second once flowing. Spinning disks sustain on the order of a hundred megabytes per second sequentially; SATA SSDs around half a gigabyte per second; NVMe drives several gigabytes per second7. The connection sets the ceiling: the SATA interface, then successive PCIe generations carrying NVMe traffic, each raising it.
- Capacity: how much rests on the drive. Terabytes are ordinary on disks and increasingly so on SSDs, far larger than typical main memory and at a fraction of the cost per byte.
The pattern across the series holds: each level down the hierarchy is larger, noticeably slower, and generally cheaper per byte than the one above.
The big picture
Storage keeps data without power at the cost of speed and chunk-wise access. Hard drives write magnetism with moving arms: vast and cheap, punished by seeks. SSDs trap charge in NAND flash, silent and quick but governed by pages, blocks, erasure, and wear. Sectors and blocks set the parcel size; sequential versus random decides the realized speed; latency, throughput, and capacity describe every drive.
The machine is now nearly complete: processor, memory, and storage in place. What remains is how it talks to the outside world (input, output, and the interconnects between machines) before the series steps back to view the computer as a whole.
Footnotes
Enjoyed this post? You can sponsor me and this site.