Storage Explained

The memory post ended at the bottom of the hierarchy: the world where data rests for years. This post stays there. Filesystems (how bytes become files and folders) belong to a future series, not this one.

Persistent storage: memory that survives power loss

Computer data storage¹ keeps information without power, for years, at a price per byte far below RAM. The trade is speed and a different contract: the CPU never touches storage byte by byte. It talks in fixed chunks through a controller.

Programs rest on storage. Running means copying into memory first. Boot, launch an app, open a document: each step moves up from the slow persistent world into the fast volatile one.

Real example: open a game and it starts loading content from SSD into RAM as needed, like asset streaming. Pull the plug and RAM empties, SSD keeps everything.

HDD: bits as magnetism

A hard disk drive² stores bits as magnetic patterns on spinning platters. An arm with read heads floats nanometers above the surface and reads those patterns.

Moving parts bring three effects:

• Position takes time: the arm must seek the right track, then wait for rotation to bring the sector under the head. That is several milliseconds before any byte flows.
• Capacity is cheap: platters are simple surfaces, so terabytes cost little.
• It is fragile and hungry: it spins, vibrates, and dislikes drops.

Real example: a 4 TB external drive for backups. Huge and cheap, but you hear it spin and you feel every random read stall.

SSD: bits as trapped charge

A solid-state drive³ has no moving parts. It stores bits as charge trapped in NAND flash⁴ cells, transistors with an isolated pocket where charge stays put for years without power.

No arm to move means silent, shock resistant, and far quicker to the first byte. But it is not just fast memory. Flash has its own rules below, and an SSD hides them with a controller, firmware, DRAM cache, and flash chips working together.

The same flash lives in many shapes: a 2.5 inch SATA SSD, a stick-like M.2 NVMe drive, or a tiny microSD card in your phone. Same bits as trapped charge, different package and speed.

Real example: swap a laptop HDD for a SATA SSD and the same machine boots in 15 seconds instead of 2 minutes. Same files, no mechanics.

NAND flash: cells, pages, blocks

A flash cell stores charge levels, not just on or off. Manufacturers name each density by how many bits it stores per cell. Common densities trade precision for capacity:

• SLC (Single-Level Cell): 1 bit per cell, 2 levels. Fastest, toughest, priciest.
• MLC (Multi-Level Cell): 2 bits per cell, 4 levels. Balanced.
• TLC (Triple-Level Cell): 3 bits per cell, 8 levels. Dense, common in laptops.
• QLC (Quad-Level Cell): 4 bits per cell, 16 levels. Densest, slowest, wears fastest.

More bits per cell means cheaper gigabytes but thinner margins, so slower writes and more error correction. No free density.

Cells form pages (4 to 16 KiB), the unit for read and write, grouped into blocks (hundreds of pages), the unit for erase. Flash has one hard rule: you can write a page only when it is erased, and erasing wipes a whole block at once.

So overwrite means write elsewhere and mark the old page invalid. Later the drive moves valid pages away and erases the block. That extra copying is write amplification. Blocks also wear out after thousands of erases, so firmware spreads writes evenly (wear leveling).

Real example: save a 4 KiB text file again. The SSD writes a fresh page elsewhere, marks the old one dead, and cleans it later. You never see this, the controller does.

Sectors and blocks: the language of drives

Drives speak in chunks. A disk sector⁵ (classically 512 bytes, today often 4 KiB) is the smallest piece the OS reads or writes. Flash pages and blocks are the matching units inside SSDs.

Byte access like RAM is gone here. Everything is parcels. That is why small scattered writes cost more than their size: seeks on disks, mapping and cleanup inside SSDs. Systems align their structures to these sizes for a reason.

Real example: a database writes in 4 KiB or 16 KiB pages to match the drive, not byte by byte. One aligned write, one parcel, no extra tax.

Sequential vs random access: the pattern decides the speed

The same drive shows two speeds depending on how you ask. Sequential access reads one long run. Random access jumps between scattered spots.

• On HDD the gap is huge: sequential is fast once positioned, random is very slow because each jump pays a fresh seek.
• On SSD the gap is smaller: sequential fills the link, random is slower but still thousands of times faster than disk.

Layout matters. Logs, video, and backups are kind because they are sequential. Much of systems work (caches, prefetching, log designs) turns random into sequential before it hits the drive.

Real example: copy a 5 GB movie file: fast. Copy 5 GB made of ten thousand tiny files: slow on the same drive. Same bytes, different pattern.

Three numbers: latency, throughput, capacity

Three numbers describe any drive:

• Latency: wait before the first byte. HDD answers in milliseconds (mechanics). SSD answers in tens of microseconds³, thousands of times quicker than a disk, yet thousands of times slower than RAM. Latency is what makes a system feel snappy.
• Throughput: flow once started. Disks hold near 100 MB/s sequential. SATA SSDs near 0.5 GB/s. NVMe drives reach several GB/s⁶. The cable sets the ceiling: SATA, then PCIe generations carrying NVMe.
• Capacity: how much rests there. Terabytes are normal on disks and common on SSDs, far beyond RAM at a fraction of the price per byte.

Each level down the hierarchy gets larger, slower, and cheaper per byte.

Real example: opening 50 browser tabs wants capacity. Launching an app fast wants low latency. Copying 4K video wants throughput.

The big picture

need: keep data without power, cheap per byte
  ↓
HDD                     (magnetism + moving arm, vast and cheap, seeks hurt)
SSD                     (trapped charge, silent and quick, pages and blocks rule)
  ↓
talk in parcels         (sectors, pages, blocks)
  ↓
pattern decides speed   (sequential fast, random slow)
  ↓
describe with latency / throughput / capacity

Storage trades speed for persistence. The machine is now almost complete: processor, memory, and storage in place. What remains is how it talks to the outside world.

Footnotes

1. Computer data storage - Wikipedia

2. Hard disk drive - Wikipedia

3. Solid-state drive - Wikipedia

4. Flash memory - Wikipedia

5. Disk sector - Wikipedia

6. NVM Express - Wikipedia