iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
The right NAND storage choice starts with the workload’s I/O pattern and data path—not with a NAND label such as TLC or QLC. Map reads, writes, block sizes, concurrency, latency sensitivity, checkpoint behavior, sharing, endurance and recovery requirements; then validate the complete storage system under cold-cache and warm-cache conditions. A local NVMe drive may be ideal for a hot cache or staging tier, while shared file or object storage remains necessary for multi-node access, durability and lifecycle management.
Start with the I/O pattern, not the NAND type
NAND is the non-volatile flash media inside an SSD. The SSD adds a controller, firmware, DRAM or other mapping resources, error correction, a host interface and thermal limits. A storage system adds servers, networking, software, data protection and failure recovery. Those layers determine what an AI job actually experiences.
Two drives with the same PCIe generation and NAND classification can behave very differently under mixed reads and writes, queue depth, sustained load or thermal throttling. Conversely, a drive with lower peak sequential bandwidth can deliver better job completion if it has lower tail latency, stronger quality of service or better behavior when several workers access it at once. NVIDIA’s certification guidance therefore recommends evaluating the full stack rather than inferring deployment performance from an interface label alone: NVIDIA-Certified Storage.
As NVIDIA’s André Franklin wrote in a July 21, 2022 technical blog, “There is no ‘one-size-fits-all’ storage solution for AI-driven apps.” The practical implication is to define the data path first: where data originates, where preprocessing occurs, which workers read it, where checkpoints land, how models are served, and what must survive a node or device failure.
#1 Best Overall
- MEET THE NEXT GEN: Consider this a cheat code; Our Samsung 990 PRO Gen4 SSD helps you reach near max performance with lightning-fast speeds; Whether you’re a hardcore gamer or a tech guru, you’ll get power efficiency built for the final boss
- REACH THE NEXT LEVEL: Gen4 steps up with faster transfer speeds and high-performance bandwidth; With a more than 55% improvement in random performance compared to 980 PRO, it’s here for heavy computing and faster loading
- THE FASTEST SSD FROM THE WORLD'S FLASH MEMORY BRAND: The speed you need for any occasion; With read and write speeds up to 7450/6900 MB/s you’ll reach near max performance of PCIe 4.0 powering through for any use
- PLAY WITHOUT LIMITS: Give yourself some space with storage capacities from 1TB to 4TB; Sync all your saves and reign supreme in gaming, video editing, data analysis and more
- IT’S A POWER MOVE: Save the power for your performance; Get power efficiency all while experiencing up to 50% improved performance per watt over the 980 PRO; It makes every move more effective with less consumption
Map the workload before selecting a drive
The following profiles and object sizes come from NVIDIA’s AI storage workload descriptions. They describe common access patterns, not a prescription for a particular SSD or NAND technology.
| Workload | Typical I/O pattern | Listed object size | What storage must handle |
|---|---|---|---|
| Training | Large sequential reads of model and dataset files; periodic large sequential checkpoint writes; parallel streams | 256 KiB–4 MiB | High aggregate read bandwidth, predictable multi-stream throughput and checkpoint writes that do not stall workers |
| Fine-tuning | Frequent reads of base weights; iterative small or medium adapter-delta and checkpoint writes | 64 KiB–1 MiB | Repeated reads plus a more mixed write pattern than a full training epoch |
| Inference | Hot reads of weights, embeddings and prompt/context features; metadata-heavy serving lookups | 4 KiB–256 KiB | Low latency and consistent tail latency for many concurrent requests |
| KV cache | Random key/value reads and writes with temporal locality, persistence and eviction | 1–5000 KiB | Fast small and medium random I/O, efficient eviction and predictable behavior as the cache fills |
| Query and retrieval | Random approximate-nearest-neighbor or vector reads; small ingestion and update writes | 1–120 KiB | Random-read latency, metadata access and sustained small writes during index updates |
| Agentic workflows | Frequent small state, checkpoint, memory, trace, tool-output and artifact operations | 1 KiB–4 MiB | Mixed-size I/O, concurrency and reliable handling of many small objects |
Use the table to build a workload model for each tier. Record average and peak request size, read/write ratio, parallel workers, queue depth, burst duration, acceptable latency and the amount of data that can be regenerated. A training dataset that is read repeatedly may benefit from caching even when its total capacity is large; a retrieval index may fit locally but still require shared persistence and coordinated updates.
Choose where each data class lives
Local NVMe for hot cache and staging
Local NVMe or SSD storage is appropriate when latency and bandwidth close to the accelerator or CPU are the priority. Microsoft recommends local NVMe or SSD file systems for I/O-intensive deep-learning training and real-time inference on Azure infrastructure, while NVIDIA describes local NVMe on DGX systems for caching or staging. See Microsoft’s storage recommendations for AI on Azure infrastructure and NVIDIA DGX Best Practices: Storage.
Recommended Free Tools
Size a local cache against the active working set, not the entire data lake. Measure the hit rate and the time required to populate it after a reboot or node replacement. Local storage does not by itself provide shared access for multiple nodes, durable copies, centralized policy, or recovery after a host failure.
Shared storage for active multi-node data
Use a shared file or object platform when several workers need the same data, when the active set exceeds local capacity, or when centralized access control, snapshots and replication are required. Test throughput and latency at the system and network level. The SSD’s advertised bandwidth is only one component of the path; network contention, metadata servers, object-store request behavior, filesystem locking and data layout can dominate.
Rank #2
- Ideal for high speed, low power storage
- Gen 4x4 NVMe PCle performance
- Up to 6,000MB/s read, 4,000MB/s write
- Includes Acronis cloning software
- 5-year limited warranty
Object storage for inactive and retained data
Inactive job outputs, older checkpoints and historical datasets generally belong in an economical durable tier rather than on expensive local flash. Microsoft’s Azure example recommends moving inactive job data to Azure Blob Storage and applying lifecycle policies that transition older, infrequently accessed data to lower-cost tiers. This is an Azure-specific architecture example; apply the same principle with the object platform used in your environment.
Separate scratch, checkpoints and source data
Scratch space can be recreated and may tolerate node-local storage. Checkpoints are recovery assets and need a durable destination, retention policy and a tested restore path. Source datasets and labels may require immutability, versioning or legal retention. Giving these classes separate paths prevents a temporary preprocessing burst from consuming the capacity or endurance reserved for checkpoints.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Account for checkpoint behavior
Synchronous checkpointing can pause training until model state has been written, reducing accelerator utilization during every checkpoint. NVIDIA describes asynchronous checkpointing as copying parameters to CPU memory and writing them in the background. That can reduce visible pauses, but it consumes host memory and still requires enough write bandwidth to finish before the next checkpoint or failure.
Checkpoint frequency is a recovery-point decision, not a universal constant. Microsoft gives “every 500 iterations” as an example interval, not a generally optimal setting. Select an interval by measuring lost work after a failure, checkpoint duration, background write interference and available capacity. Keep enough generations to recover from a corrupted or logically incorrect checkpoint, and verify that asynchronous copies are complete before declaring a checkpoint durable.
Evaluate the complete system, not one benchmark number
Compare candidate configurations with the same representative dataset, software stack, worker count and concurrency. NVIDIA notes that narrow benchmarks can miss concurrency, stress behavior, scale, quality of service, availability and full-stack interactions. Record at least the following dimensions.
Rank #3
- SPEED UP PROJECTS. Launch creator applications fast with uncompromising PCIe 4.0 read speeds up to 7,100MB/s,[2] (1TB and 2TB[1] models) and write speeds up to 6,700MB/s[2] (1TB[1]-4TB[1] models).
- CREATE AND STORE MORE. Make more room for your 4K videos and high-resolution images with capacities from 500GB[1] up to 4TB[1] on M.2 2280 built with our trusted 8th generation SANDISK BiCS QLC 3D CBA NAND.
- IT GOES WHERE YOU GO. With an all-new power efficient design, your drive delivers high performance with low power, giving you more time to be productive while on the go.
- UNCOMPROMISED RELIABILITY. With up to 1,200 TBW[3] (4TB[1] model) endurance rating, your drive is designed for creators.
- KEEP YOUR DRIVE UPDATED. Monitor your SSD’s performance and check for updates with the downloadable SANDISK Dashboard application.[5]
| Measure | How to interpret it |
|---|---|
| Sustained throughput | Read and write bandwidth maintained for the duration of an epoch, ingest run or checkpoint, rather than a short burst |
| Latency distribution | Report median and high-percentile latency; tail latency often controls request timeouts and inference batching |
| Concurrency scaling | Observe performance as workers, clients and queue depth increase; a single-client result is insufficient |
| Cold versus warm cache | Measure first-run behavior after cache eviction and steady-state behavior after data is resident |
| Checkpoint completion | Measure write duration and the effect on forward progress, including background asynchronous writes |
| Capacity and scaling | Check usable capacity after protection overhead and whether adding devices or nodes increases useful throughput |
| Availability and recovery | Test device, node, path and network failures; record rebuild, remount and restore times |
| Host compatibility | Confirm PCIe generation, NVMe protocol, form factor, firmware, power, cooling and server qualification |
| Endurance | Compare the rated write volume with measured writes and the warranty’s assumptions |
| Total cost | Include drives, servers, networking, power, cooling, support, replication, software and replacement labor |
Run the test on the actual filesystem, database, vector index or object client used in production. Include preprocessing, metadata operations and background replication where they will coexist with training or serving. A peak sequential test cannot predict random 4 KiB inference lookups or multi-client tail latency.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsMatch endurance to real writes
Endurance is a workload and warranty question. Estimate bytes written per day from ingestion, preprocessing, index updates, checkpoints, cache churn, replication and garbage-collection amplification. Multiply by the planned service life, then compare the result with the drive’s stated TBW or DWPD rating at the same capacity and warranty duration.
The Open Compute Project NVMe Cloud SSD Specification requires device documentation to state physical bytes writable under a stated write-amplification assumption and defines conditions for end-of-life performance testing. Consult the specification at NVMe Cloud SSD Specification v1.0a. Two endurance figures tested under different assumptions are not directly comparable.
QLC can be reasonable for read-dominant workloads with low-to-moderate writes in the workload model described by Solidigm’s QLC NAND workload guide: high-bandwidth reads during training or inference and writes during ingest or preparation. That is a vendor characterization of a segment, not evidence that QLC suits every AI pipeline. Write-heavy fine-tuning, frequent checkpointing, index mutation or cache churn may require a higher-endurance design. There is no robust, independently attributable universal statistic that ranks TLC, QLC and other NAND types across all AI workloads; use measured write rates and the published warranty conditions.
Size capacity for the active working set
Calculate usable rather than raw capacity. Account for filesystem or object-store overhead, replication or erasure coding, snapshots, spare area, retained checkpoints, failed-device rebuild space and headroom for garbage collection. Keep operational headroom so a nearly full SSD does not turn a burst into sustained garbage-collection latency.
Free tools Windows power users keep installed
One-click scans. No signup required.
Rank #4
- HUGE SPEED BOOST: Get random read/write speeds that are 40%/55% faster than 980 PRO; Experience up to 1400K/1550K IOPS, while sequential read/write speeds up to 7,450/6,900 MB/s reach near the max performance of PCIe 4.0*
- BREAKTHROUGH POWER EFFICIENCY: Use less power and get more performance; Enjoy up to 50% improved performance per watt over 980 PRO, plus optimal power efficiency with max PCIe 4.0 performance**
- SMART THERMAL CONTROL: Samsung's own nickel-coated controller delivers effective thermal control; With its slim size, 990 PRO is a perfect fit for desktops and laptops that meet the PCI-SIG D8 standard***
- THE CHAMPION MAKER: Up to 65% improvement in random performance enables faster loads for an ultimate gaming experience on PS5 and DirectStorage PC games****
- SAMSUNG MAGICIAN SOFTWARE: Get the most out of your SSD with Samsung Magician's advanced yet intuitive optimization tools; Monitor drive health, protect valuable data, and receive important updates for your 990 PRO
For training, size the fastest tier for the files read concurrently by workers and for at least one checkpoint stream. If the dataset is larger than local capacity, design a prefetch and eviction policy and measure whether network fetches overlap compute. For inference, include model weights, tokenizer and embedding files, hot feature data, logs and rolling deployments. For retrieval, include the vector index, metadata, ingestion staging and a second copy or rebuild source. For agentic systems, count traces, tool outputs and state snapshots; many small objects can consume more metadata and I/O operations than their byte count suggests.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Workload-specific selection guidance
Training
Prioritize sustained parallel reads and predictable checkpoint writes. Large 256 KiB–4 MiB streams can use bandwidth efficiently, but multiple workers may turn a nominally sequential job into a contended workload. Benchmark a full epoch with the real number of readers, then add checkpoint writes at the intended interval. Compare cold-start epoch time with warm-cache epoch time; the difference determines whether investing in local cache actually shortens jobs.
NVIDIA’s DGX guidance mentions planning for 150–200 MB/s per GPU in its stated 1080p-file context and considering more for 4K or uncompressed files. That is legacy, context-specific guidance, not a universal target for every training dataset or accelerator. Do not multiply it blindly without verifying file format, preprocessing and the rest of the data path.
Fine-tuning
Fine-tuning repeatedly reads base weights while writing adapter deltas and checkpoints in 64 KiB–1 MiB objects. Measure the mixed read/write ratio rather than using a full-training sequential-read benchmark. If many experiments run concurrently, test metadata and small-file behavior as well as aggregate bandwidth.
Inference serving
Inference commonly keeps weights and embeddings hot while serving metadata-heavy lookups in 4 KiB–256 KiB requests. Tail latency, queueing and recovery from a model rollout matter more than a one-time sequential read. Test the maximum request concurrency, batch size, model-loading path and behavior when the cache is empty. Ensure a model can be reloaded from durable storage after a host replacement.
Best Value
- This product has been replaced by our latest generation. Please search for the SANDISK Optimus GX 7100 NVMe SSD
- HIGH-OCTANE GAMING. Experience speeds up to 7,250MB/s read and 6,900MB/s write (1-2TB models), with up to 35% faster performance than previous generation.
- PURPOSE-BUILT. Designed for serious on-the-go gamers, with a PCIe Gen4 interface and SANDISK’s next generation TLC 3D NAND.
- MORE TIME TO CLEAR THAT CHECKPOINT. Built with laptops and handheld gaming devices in mind, with up to 100% more power efficiency over the previous generation.
- DO MORE WITH DASHBOARD. Ensure your drive is optimized for prime performance with the downloadable WD_BLACK Dashboard (Windows only).
KV cache
KV-cache workloads combine random reads and writes, temporal locality and eviction, with listed objects from 1 KiB to 5000 KiB. Measure the eviction policy, persistence frequency and cache-fill phase. A drive that is excellent for large sequential reads may deliver unacceptable tail latency when many sessions perform small random updates.
Query and retrieval
Approximate-nearest-neighbor queries issue random vector reads, while ingestion and updates create small writes in the 1–120 KiB range. Benchmark concurrent queries during index construction and compaction. Include metadata lookups, index reload time and the time to restore from a durable copy; isolating the vector-read benchmark can hide the write interference that users experience.
Agentic workflows
Agentic applications generate frequent state, checkpoint, memory, trace, tool-output and artifact operations from 1 KiB to 4 MiB. Treat operation count, metadata latency and concurrency as first-class metrics. Batching or an application-supported archive can reduce small-file overhead, but validate durability and recovery semantics before changing the data format.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Control small-file overhead
Many small files can reduce performance through metadata operations, open and close calls, directory traversal and fragmented access. NVIDIA DGX best practices suggest framework-supported databases or archive formats such as HDF5, LMDB or TFRecord, while noting that each introduces its own trade-offs. Consolidation can improve throughput, but it may complicate partial updates, parallel writes, portability or recovery. Benchmark the chosen format with the actual framework and worker count.
A practical selection procedure
- Inventory data classes. List source data, preprocessing output, caches, indexes, model weights, checkpoints, logs and artifacts. Mark each as reproducible, durable, shared, retained or disposable.
- Capture the I/O trace. Measure request sizes, read/write ratio, concurrency, burst length, queue depth, latency percentiles and bytes written per day for each class.
- Draw the data path. Show accelerator host, local NVMe, shared file or object service, network links, caches, replication and lifecycle transitions.
- Set service objectives. Define epoch time, checkpoint pause or completion time, inference tail-latency target, query throughput, recovery-point objective and recovery-time objective.
- Build capacity and endurance budgets. Use usable capacity, protection overhead, retained generations, growth and measured write amplification; compare with warranty-qualified TBW or DWPD.
- Filter for compatibility. Verify form factor, PCIe and NVMe support, firmware, slot bifurcation, power delivery, cooling, server qualification and operating-system support.
- Test cold and warm states. Run representative jobs after cache eviction and at steady state. Include concurrent users, checkpointing, ingestion, compaction and background replication.
- Test failure and recovery. Remove a path or device in a controlled environment, rebuild or restore data, and record lost work, service interruption and operator steps.
- Compare total cost. Include acquisition, support, power, cooling, network, software, spare capacity, replacement and operations—not just price per raw terabyte.
- Revalidate after changes. Repeat the measurements when models, batch sizes, dataset formats, worker counts or retention policies change.
Common selection mistakes and fixes
- Choosing by peak sequential bandwidth: Replace the headline number with sustained mixed-workload and tail-latency measurements.
- Treating a local SSD as shared storage: Keep durable shared copies and a recovery plan even when local NVMe accelerates the hot path.
- Ignoring cold starts: Measure cache population and model reload time after reboot or node replacement.
- Underestimating checkpoints: Include checkpoint writes in the training benchmark and verify asynchronous completion and durability.
- Comparing endurance ratings without assumptions: Align capacity, write-amplification model, test conditions and warranty term before comparing TBW or DWPD.
- Assuming QLC or TLC is universally better: Match the media and SSD design to measured writes, latency and budget; no single NAND class wins every AI workload.
- Filling drives to their nominal limit: Reserve operational headroom for performance stability, snapshots and rebuilds.
- Benchmarking one client only: Reproduce production concurrency, metadata activity, network traffic and background jobs.
- Changing file format without testing recovery: Confirm framework support, partial-update behavior, portability and restore procedures for any archive or database format.
Make the decision
Select the least expensive NAND-backed tier that meets the measured service objectives with required endurance and failure protection. Use local NVMe when it removes a demonstrated hot-path bottleneck; use shared storage when access, durability or scale require it; move inactive data to lifecycle-managed object tiers. Keep the benchmark tied to the real application, because the decisive result is completed training, predictable serving and recoverable data—not a peak number on an SSD datasheet.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
