what are the different types of solid state media

Solid-state storage has fundamentally changed how data centers and personal computers are built, replacing spinning mechanical disks with chip-based storage that has no moving parts. This article explains how solid-state storage works at a fundamental level and covers the different types of NAND flash, form factors, and interfaces you’ll encounter today.

How Flash Memory Works (First Principles)

Solid-state drives (SSDs) store data using NAND flash memory — a type of non-volatile memory made of memory cells that trap electrical charge in a floating gate to represent bits, even with power removed.

graph TD
    Cell[Flash Cell] --> Page[Page: smallest unit written at once, typically 4-16KB]
    Page --> Block[Block: smallest unit that can be erased, made of many pages]
    Block --> Die[NAND Die]
    Die --> Chip[Flash Chip / Package]

A key quirk of NAND flash: you can write to a page, but you can only erase at the block level (a much larger unit). This means updating a small piece of data often involves reading the whole block, modifying it in memory, erasing the block, and rewriting it — a process managed by the SSD’s controller and firmware, largely hidden from the host system.

NAND Flash Cell Types

The number of bits stored per memory cell is the primary factor determining an SSD’s performance, endurance, and cost.

More bits per cell means more distinct voltage levels the controller must distinguish, which increases density and lowers cost per gigabyte, but reduces the number of program/erase cycles the cell can reliably endure before wearing out. SLC is now mostly reserved for high-endurance enterprise caching layers, while TLC dominates the mainstream consumer and enterprise market, with QLC growing for capacity-focused use cases.

SSD Form Factors

Interfaces and Protocols

SATA (Serial ATA)

Legacy interface originally designed for HDDs, capped around 600 MB/s. SATA SSDs remain common for budget builds and as a drop-in HDD replacement, but the interface itself is now the primary bottleneck for flash performance.

NVMe (Non-Volatile Memory Express)

A protocol purpose-built for flash storage, running directly over PCIe rather than the older AHCI protocol SATA relies on. NVMe supports vastly more command queues and much higher queue depth, unlocking flash’s true performance potential.

PCIe Generations and NVMe Throughput

Enterprise-Focused Solid-State Technologies

Endurance Ratings: DWPD and TBW

Enterprise SSDs are rated for how much data can be written over their lifespan:

• DWPD (Drive Writes Per Day): How many times the drive’s full capacity can be rewritten daily over the warranty period.
• TBW (Terabytes Written): A total lifetime write budget.

Storage Class Memory (SCM) / Persistent Memory

Technologies like Intel Optane bridged the gap between DRAM and NAND flash — offering much lower latency than NAND (though at higher cost per GB) — historically used for caching tiers and write-intensive workloads, though the market for this category has narrowed significantly in recent years.

Emerging Non-Volatile Memory Technologies

These remain niche compared to NAND flash’s overwhelming market dominance, but represent active areas of research for future storage-class memory.

SSD Controller Functions

The controller is effectively a small dedicated computer managing the flash:

• Wear leveling: Spreads writes evenly across all cells to avoid prematurely wearing out any single block.
• Garbage collection: Reclaims space from blocks containing stale data by consolidating valid data and erasing the rest.
• TRIM support: Lets the OS inform the SSD which blocks are no longer in use, improving garbage collection efficiency.
• Error correction (ECC): Detects and corrects bit errors inherent to flash storage at scale.
• Over-provisioning: Reserves extra physical capacity (not visible to the OS) to improve endurance and sustained write performance.

Practical Examples: Managing SSDs on Linux

Checking Drive Type and Interface

lsblk -d -o NAME,ROTA,SIZE,MODEL
# ROTA=0 indicates a non-rotational (solid-state) drive

nvme list        # for NVMe drives specifically

lsblk -d -o NAME,ROTA,SIZE,MODEL
# ROTA=0 indicates a non-rotational (solid-state) drive

nvme list        # for NVMe drives specifically

Checking SSD Health with SMART

sudo apt install smartmontools
sudo smartctl -a /dev/nvme0n1
sudo smartctl -a /dev/sda

sudo apt install smartmontools
sudo smartctl -a /dev/nvme0n1
sudo smartctl -a /dev/sda

Key fields to watch for SSD health:

Percentage Used:            12%
Data Units Written:         45,203 [23.1 TB]
Available Spare:            100%
Media and Data Integrity Errors: 0

Percentage Used:            12%
Data Units Written:         45,203 [23.1 TB]
Available Spare:            100%
Media and Data Integrity Errors: 0

Enabling TRIM

# Run TRIM manually across all mounted filesystems that support it
sudo fstrim -av

# Enable the weekly automatic TRIM timer (recommended over continuous discard)
sudo systemctl enable fstrim.timer

# Run TRIM manually across all mounted filesystems that support it
sudo fstrim -av

# Enable the weekly automatic TRIM timer (recommended over continuous discard)
sudo systemctl enable fstrim.timer

Python: Parsing SMART Data for Monitoring

import subprocess
import json

def get_ssd_health(device):
    result = subprocess.run(
        ["smartctl", "-a", "-j", device],
        capture_output=True, text=True
    )
    data = json.loads(result.stdout)
    return {
        "device": device,
        "percentage_used": data.get("nvme_smart_health_information_log", {}).get("percentage_used"),
        "temperature": data.get("temperature", {}).get("current")
    }

print(get_ssd_health("/dev/nvme0n1"))

import subprocess
import json

def get_ssd_health(device):
    result = subprocess.run(
        ["smartctl", "-a", "-j", device],
        capture_output=True, text=True
    )
    data = json.loads(result.stdout)
    return {
        "device": device,
        "percentage_used": data.get("nvme_smart_health_information_log", {}).get("percentage_used"),
        "temperature": data.get("temperature", {}).get("current")
    }

print(get_ssd_health("/dev/nvme0n1"))

Best Practices

• Match cell type (TLC vs QLC vs enterprise MLC) to workload write intensity — don’t put a heavy logging/database workload on consumer QLC drives.
• Enable TRIM (fstrim.timer) on Linux to maintain long-term SSD write performance.
• Monitor SMART data (Percentage Used, Available Spare) proactively rather than waiting for failure.
• Leave some unpartitioned free space on SSDs (informal over-provisioning) to improve sustained write performance and endurance.
• For enterprise workloads, size DWPD/TBW ratings to the actual expected write volume rather than defaulting to the cheapest option.
• Prefer NVMe over SATA for any performance-sensitive workload — the interface, not just the flash, is often the real bottleneck.

Troubleshooting

Further Reading

• JEDEC NAND Flash Standards
• NVM Express (NVMe) Specification
• SNIA Solid State Storage Resources
• smartmontools Documentation
• Linux Kernel fstrim Documentation

Conclusion

Solid-state storage isn’t a single technology — it spans a wide range of cell types, form factors, and interfaces, each with different tradeoffs between cost, performance, and endurance. Understanding these distinctions, from raw NAND cell behavior up through NVMe’s queue architecture, is essential for choosing the right storage media for any given workload and for keeping it healthy over its lifespan.