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 errorsChoose NAND storage by tracing the workload’s data path, not by picking a flash label first. Training, fine-tuning, inference, retrieval, KV-cache services, and ingestion exercise different I/O sizes, queue depths, latency targets, and write volumes. A suitable design may combine local NVMe for cache or staging, shared file or object storage for active data, and lower-cost capacity for inactive data. Validate the complete path—SSD, host, network, filesystem, software and protection—under representative concurrency before committing to a drive or platform.
NVIDIA’s guidance is explicit: “There is no ‘one-size-fits-all’ storage solution for AI-driven apps.” The practical consequence is to measure the behavior your jobs actually need, then buy only the endurance, capacity and latency margin that those measurements justify.
As an Amazon Associate I earn from qualifying purchases.
What you are actually choosing
NAND is the non-volatile flash medium inside an SSD. The medium is only one layer of an AI storage system. The controller, firmware, error correction, over-provisioning, DRAM or host-memory design, PCIe/NVMe interface, form factor, cooling, filesystem, network and data-protection scheme all influence the result seen by a training or serving job. A drive with a fast interface can still deliver poor tail latency when it is full, thermally throttled, servicing garbage collection or sharing queues with other clients.
Keep three decisions separate:
- Media and device: NAND type, controller, endurance rating, capacity, sustained performance and warranty.
- Host placement: local NVMe in each server, a shared file system, an object store, or a tiered combination.
- Data path: how data is formatted, prefetched, cached, checkpointed, replicated, expired and recovered.
NVIDIA’s certification documentation warns that a narrow benchmark can miss concurrency, stress, scale, quality of service, availability and full-stack interactions. Use a drive specification to screen options, not to predict an entire deployment.
#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 NAND
The following profiles and object sizes come from NVIDIA’s AI storage workload descriptions. They describe common access patterns; they are not prescriptions for a particular SSD or NAND type. Your application may produce a different mix.
| Workload | Typical I/O pattern | Listed object size | What the storage must protect |
|---|---|---|---|
| Training | Large sequential reads of model and dataset files, periodic large sequential checkpoint writes, parallel streams | 256 KiB–4 MiB | Read bandwidth across workers and checkpoint completion without stalling the job |
| Fine-tuning | Frequent reads of base weights with iterative small or medium adapter-delta and checkpoint writes | 64 KiB–1 MiB | Low interruption during repeated update cycles and enough write endurance |
| Inference | Hot reads of weights, embeddings and prompt/context features with metadata-heavy serving lookups | 4 KiB–256 KiB | Predictable latency, especially for small reads and concurrent requests |
| KV cache | Random key/value reads and writes, temporal locality, persistence and eviction | 1–5000 KiB | Mixed random I/O, eviction behavior and recovery of retained state |
| Query and retrieval | Random approximate-nearest-neighbor or vector reads with small ingestion and update writes | 1–120 KiB | Random-read latency, metadata access and write amplification from updates |
| Agentic workflows | Frequent small state, checkpoint, memory, trace, tool-output and artifact operations | 1 KiB–4 MiB | Many small operations, ordering, durability and contention among concurrent tasks |
Use these ranges to construct test files and request mixes. Do not infer random-read latency from a sequential bandwidth number, and do not infer multi-client behavior from a single-client result.
Training
Training often rereads a dataset over multiple epochs, so aggregate read bandwidth and the ability to keep all workers supplied can matter more than an isolated latency figure. The write event that most visibly affects progress is the checkpoint. With synchronous checkpointing, the training process waits for the model state to be written; a fast forward pass can therefore be interrupted by a slower storage phase.
First determine which part of the dataset is active at once and whether it can be cached locally. Then measure a complete epoch with the intended number of workers, including checkpoint writes. Record cold-start time separately from warm-cache throughput: a cache that looks excellent after several passes may not shorten the first epoch or a job restart.
Fine-tuning
Fine-tuning repeatedly reads the base model while writing adapter deltas, optimizer state or revised checkpoints. Those writes can be smaller and more frequent than in a full pretraining run. A device selected only for large sequential reads may show unacceptable latency or endurance once these update streams are added. Test the actual adapter and checkpoint format, not a synthetic large-file copy alone.
Inference
Serving systems usually keep model weights and frequently used embeddings hot while handling many requests concurrently. Metadata and prompt/context lookups can be small even when the model file is large. Measure p95 and p99 latency at the target concurrency, with realistic cache hit and miss rates, and include model reloads or rolling updates. A local SSD can reduce fetch latency, but replicas, failover and shared access still require an architecture decision.
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
KV-cache services
A KV cache is neither a simple sequential dataset nor a purely read-only model store. Entries are written, read randomly, aged and evicted; some systems persist selected entries for restart or sharing. Test the eviction policy and the persistence mode together. If the cache is disposable, capacity and write endurance can be lower than for a durable database; if it is part of recovery, protection and restart throughput become first-class requirements.
Query and retrieval pipelines
Approximate-nearest-neighbor indexes generate small random reads and metadata lookups, while ingestion creates update writes. Index build, compaction and background refresh can temporarily change the write pattern. Benchmark steady-state queries as well as ingestion bursts and compaction. The useful metric is service latency under the combined workload, not the SSD’s peak sequential rate.
Agentic and data-pipeline state
Agent traces, tool outputs, intermediate artifacts and workflow checkpoints can create a high count of small operations. Batching, an archive or a framework-supported database can reduce filesystem overhead, but each adds its own latency and recovery behavior. Test the serialization format and commit semantics that the application will use in production.
Pick the placement: local, shared, object, or hybrid
Local NVMe for cache and staging
Microsoft recommends local NVMe or SSD filesystems when performance is the priority, including I/O-intensive deep-learning training and real-time inference. NVIDIA describes local NVMe in DGX systems as a cache or staging layer. This placement is attractive when data can be prefetched, when the working set fits, or when a node needs a fast scratch area for indexes and temporary transforms.
Local capacity does not solve every problem. Each node has its own copy, data can disappear with the host, and a dataset larger than the aggregate local cache still needs a source of truth. Size the cache from measured active data and refill time, and define what happens after eviction, node replacement or a failed job.
Shared storage for active multi-node data
Use a shared file or object platform when many workers need the same data, when the active set exceeds local capacity, or when centralized access control and recovery are required. Evaluate the storage system and network as one path: protocol, metadata service, client queues, switches, congestion control and server-side media all affect performance. An NVMe label on a component does not prove that every worker will receive the advertised rate.
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]
Object storage for inactive and retained data
Microsoft’s Azure guidance recommends moving inactive job data to Azure Blob Storage and applying lifecycle policies to older, infrequently accessed tiers. That is an Azure-specific example, not a universal service prescription. The general pattern is to keep only the hot working set on performance-oriented storage and move retained checkpoints, raw datasets and completed artifacts to a less expensive tier with an explicit restore-time expectation.
A hybrid path
A common design is object storage as the durable source, shared storage for a multi-node active set, and local NVMe for per-node cache or staging. Define ownership for every copy: which tier is authoritative, how a cache is invalidated, how checksums are verified, and how a job resumes after a node or network failure. Without those rules, adding a faster tier can create stale data or an expensive duplication of the same dataset.
Design checkpointing and cache behavior deliberately
Synchronous versus asynchronous checkpoints
NVIDIA notes that synchronous checkpoints can pause training until the write completes. With asynchronous checkpointing, model parameters can be copied to CPU memory and written in the background, allowing the next training steps to continue while storage drains. Asynchronous operation shifts pressure to host memory, copy bandwidth and queue management, so verify that the background writer cannot starve data loading or run out of memory.
Free tools Windows power users keep installed
One-click scans. No signup required.
Microsoft gives “every 500 iterations” as an example interval, not a generally correct setting. Choose an interval from the recovery-point objective, checkpoint size, measured write time and the cost of lost work. Record both checkpoint duration and the effect on examples processed per hour. A shorter interval may reduce lost work while reducing throughput; a longer interval may improve throughput while increasing restart loss.
Cold and warm cache tests
Run at least two modes: a cold start after cache eviction or node restart, and a warm run after the working set has been read. Report time to first batch, time to first inference, steady-state throughput and the point at which performance settles. If only warm results are reported, a deployment can appear fast while every scheduled job still spends minutes or hours repopulating its cache.
Many small files
NVIDIA’s DGX storage best practices warn that reading and writing many small files can reduce performance. Where the framework supports it, evaluate a database or archive and formats such as HDF5, LMDB or TFRecord. These can reduce metadata operations, but they introduce their own indexing, locking, compaction and recovery considerations. Benchmark the complete format and loader rather than assuming that packaging files will always help.
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
How NAND type and endurance affect the decision
NAND labels such as TLC and QLC describe cell density and are useful shorthand, but they do not establish the behavior of a complete SSD in your workload. Controller design, firmware, spare area, cache policy, capacity and thermal conditions can change sustained performance. There is no robust, independently attributable universal statistic that ranks TLC, QLC and other NAND types across all AI training, inference and pipeline workloads.
Use the label to formulate questions, then use the specification and your measurements to answer them:
| Question | Evidence to request | Why it matters |
|---|---|---|
| How much data will be written? | Daily and weekly host writes, checkpoint volume, ingest, compaction and cache churn | Determines endurance needs and whether background garbage collection will be a recurring performance factor |
| What is the sustained write behavior? | Performance after the device’s temporary write cache is exhausted, at the planned fill level and temperature | A short burst result may not represent a long checkpoint or ingest run |
| What does the endurance rating mean? | TBW or DWPD definition, capacity, test workload, write-amplification assumption, warranty duration and exclusions | Ratings produced under different conditions are not directly comparable |
| What happens near end of life? | Published end-of-life performance conditions and replacement or warranty process | A device can remain usable while no longer meeting the latency or throughput target |
| Is the vendor claim scoped? | The workload segment, block sizes and read/write mix used for the claim | A segment estimate cannot be generalized to every AI pipeline |
The Open Compute Project NVMe Cloud SSD specification says device documentation should state physical bytes writable under a stated write-amplification assumption and defines conditions for end-of-life performance testing. Use those disclosures when comparing TBW or DWPD, and keep the warranty terms beside the rating.
A Solidigm workload guide characterizes an AI/ML data-pipeline segment as high-bandwidth reads during training and inference, writes during ingest and preparation, variable block sizes and low-to-moderate TBW in its stated model. That is a vendor characterization for that segment, not proof that QLC suits every pipeline or will match a higher-endurance device under write-heavy use. Calculate your own write rate and validate the warranty before selecting a QLC drive.
Size capacity from the working set and retention policy
- Inventory the data. Separate raw data, transformed shards, model weights, optimizer state, adapter deltas, indexes, checkpoints, logs and temporary files. Record which copies are authoritative and which are disposable.
- Measure the active working set. For each job, record the bytes read during a cold run, bytes reread per epoch, peak concurrent files and cache hit rate. Include index build and model reload phases.
- Choose a cache target from measurements. Capacity must hold the intended hot set plus the application’s measured temporary space and an explicitly chosen operating margin. Do not assume that a cache equal to the model size is sufficient when preprocessing, multiple versions or concurrent jobs are present.
- Account for copies and failures. Include replicas, parity or other protection, a replacement device and the data needed to rebuild a node. If a local cache is disposable, document the refill time instead of silently treating it as durable capacity.
- Plan growth and tier transitions. Estimate dataset, model and checkpoint growth over the warranty period. Define when data moves from local to shared or object storage and how long a restore is allowed to take.
Capacity that is technically available but leaves no room for garbage collection, metadata, temporary files or a second model version can produce latency cliffs. The correct margin is workload- and implementation-specific; measure it rather than applying a universal percentage.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Measure the performance that users will experience
Build a test matrix from production traces or representative replays. Hold the host, firmware, filesystem, software version, network path and data format constant while changing only the storage option. Compare at least the following:
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).
| Test dimension | Procedure | Report |
|---|---|---|
| Sequential training path | Read the intended shard and model sizes with the planned worker count; add periodic checkpoint writes | Aggregate throughput, per-worker throughput, checkpoint completion time and examples per hour |
| Small-I/O serving | Replay inference or retrieval requests at target concurrency and cache-miss rate | Median, p95 and p99 latency, queue depth, error rate and throughput |
| Cold start | Evict caches or restart nodes, then launch the job or service | Time to first batch or request and refill bandwidth |
| Warm steady state | Repeat after the working set is resident | Sustained latency and throughput over a long enough interval to expose thermal or garbage-collection effects |
| Mixed workload | Run reads, checkpoints, ingest, compaction and metadata operations together | Interference, tail latency and progress of each client |
| Scale-out | Increase workers, clients and nodes while keeping the dataset and request mix representative | Scaling efficiency, network utilization, bottleneck location and failure behavior |
| Recovery | Remove a node or device, restore a cache, remount shared storage and resume a job | Recovery time, lost work, rebuild impact and data-integrity result |
NVIDIA’s certified-storage documentation is a useful checklist for this scope because it emphasizes sustained throughput and latency under concurrency, capacity and performance scaling, availability, recovery, host compatibility, endurance and cost. Certification validates tested configurations; it is not a guarantee for every workload or deployment.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Check the host, form factor and thermal envelope
- Interface: Confirm the server and backplane support the required PCIe generation, NVMe features, lane width and boot or hot-plug behavior. An adapter can change both compatibility and available bandwidth.
- Form factor: Verify the exact 2.5-inch, EDSFF or add-in-card slot, carrier, cabling and service procedure. A capacity figure is irrelevant if the chassis cannot accept the device.
- Thermals: Check airflow, heatsinks, sustained workload temperature and throttling telemetry. Test in the fully populated chassis, not only on an open bench.
- Software path: Confirm kernel or hypervisor support, multipath behavior, filesystem limits, encryption, monitoring and firmware-update procedures.
- Protection: Decide whether replication, parity, snapshots, checksums and backups are provided by the local system, shared platform or application. NAND endurance does not equal data durability.
- Operations: Require SMART or NVMe health data, wear indicators, error logs and a replacement process that fits the service-level objective.
Build a realistic cost model
Compare total cost over the planning period, not the purchase price per terabyte alone. Include devices or storage nodes, host adapters, memory used for caching, network capacity, power and cooling, software or service charges, replication, spare capacity, operations and the cost of downtime or lost training progress.
Local NVMe can avoid network traffic and deliver excellent cache performance, but duplicating a large dataset across many nodes increases capacity and refresh work. Shared storage can reduce duplication and simplify access, but its controllers, network and protection add cost and may become the throughput bottleneck. Object storage can lower the cost of retained data, while retrieval and refill time become part of the job’s operational budget. Price each tier against the latency and recovery requirement it serves.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Common selection mistakes and their fixes
| Symptom | Likely mistake | Corrective action |
|---|---|---|
| Training GPUs idle during data loading | Benchmark measured one client or a warm cache only | Replay the cold path with all workers, inspect network and metadata queues, and size local staging from measured refill time |
| Checkpoint causes a visible pause | Only steady-state reads were tested | Measure checkpoint size and duration; evaluate asynchronous writing and choose frequency from recovery-point needs |
| Inference p99 latency rises during model reload | Peak sequential bandwidth was treated as a serving guarantee | Test small reads, metadata lookups, reloads and target concurrency with tail-latency limits |
| QLC device wears faster than expected | A vendor workload characterization was generalized to a write-heavy pipeline | Measure host writes, compaction and cache churn; compare endurance assumptions and warranty terms |
| Local cache loses data after a node failure | Cache was treated as the source of truth | Keep durable data on shared or object storage, document rebuild steps and test recovery |
| Many small files consume CPU and metadata capacity | File count was ignored in the benchmark | Test HDF5, LMDB, TFRecord or another supported archive/database, including its compaction and recovery costs |
| Performance falls after deployment | Thermals, fill level or firmware differed from the lab | Run a sustained test in the populated server, monitor temperature and health telemetry, and repeat at the planned capacity level |
| Shared system scales poorly | Drive interface was used as a proxy for end-to-end bandwidth | Measure client, network, metadata and storage-server scaling together; identify the first saturated layer |
A repeatable selection procedure
- Write the workload contract. List read and write sizes, concurrency, latency percentiles, throughput, cache-hit assumptions, checkpoint policy, retention and recovery objectives for each job class.
- Separate hot, warm and cold data. Assign each dataset, model, index, checkpoint and artifact to local, shared or object storage based on access frequency and recovery needs.
- Measure bytes and operations. Capture host reads, host writes, I/O size distribution, queue depth, metadata operations, cache misses and peak concurrent clients during representative runs.
- Set endurance from measured writes. Convert the measured write volume into the planned service life, then compare it with TBW or DWPD under the vendor’s stated assumptions and warranty.
- Shortlist compatible devices or platforms. Check capacity, interface, form factor, thermal design, firmware support, health telemetry and data-protection integration before comparing performance.
- Run cold, warm, mixed and failure tests. Include checkpointing, ingestion, compaction, model reload, scale-out and recovery; collect tail latency and progress, not only averages.
- Check scaling economics. Model the number of nodes, replicas, network links, spares, power, cooling and the cost of moving data between tiers.
- Document operating limits. Record fill-level limits, temperature alerts, firmware versions, replacement procedures, cache invalidation and lifecycle policies.
- Pilot on the production-shaped system. Validate with the actual framework, dataset format, worker count and serving concurrency. Treat certification or a vendor benchmark as supporting evidence, not a deployment guarantee.
- Re-test after material changes. New model sizes, index formats, checkpoint policies, firmware or network topology can change the I/O pattern and invalidate an earlier choice.
Illustrative architecture choices
Distributed training with repeated epochs
Keep the durable dataset and checkpoints on shared or object storage, stage the active shards on local NVMe when the measured refill time justifies it, and test all workers reading in parallel. Use asynchronous checkpoints only if host-memory copies and background writes remain within the node’s resource budget. The decisive evidence is examples processed per hour and restart time, not the SSD’s headline sequential number.
Latency-sensitive inference
Place hot weights and features on local NVMe or a low-latency shared tier, then test cache misses, metadata lookups, model reloads and failover at the intended concurrency. Keep a durable copy outside the cache and define how a replacement node repopulates it. Select endurance from model-update, logging and cache-eviction writes rather than from read traffic alone.
Vector retrieval with continuous ingestion
Benchmark random ANN reads together with ingestion, index updates and compaction. A device that excels at large sequential reads may not meet the p99 latency target when small random operations and background writes share the queue. If the index can be rebuilt, local storage may be a staging tier; if rebuild time is unacceptable, include shared protection and a tested recovery path.
Bottom-line decision rule
Choose the least costly NAND-based design that passes your measured workload contract with required latency, sustained throughput, endurance, availability and recovery margin. Start with object sizes and access patterns, place hot data where it can be fed to the accelerators, keep the source of truth durable, and validate cold starts, warm runs, checkpoints, mixed clients and failures on the real host and network. NAND type is a constraint and a clue—not a substitute for end-to-end evidence.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →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.
