Loading field map
Every computer system must keep data somewhere, but where that 'somewhere' is, how it is organized, and who can reach it have changed dramatically over five decades. The central tension in storage systems is between locality and sharing: keeping data close to the processor gives speed and simplicity, while making data accessible across a network enables collaboration, scale, and resilience. Each major framework in the field has navigated this tension differently, and the frameworks that survive today coexist because they serve different points on that spectrum.
The earliest and simplest framework, Direct Attached Storage (DAS), treats storage as a peripheral wired directly to a single computer. A disk drive inside a server or connected by a cable like SCSI or ATA belongs to that machine alone. DAS dominated from the 1970s through the 1990s because it was straightforward: the operating system saw a block device, the bus was fast, and there was no network latency or contention. Its limitation became obvious as organizations acquired many computers: each machine had its own storage, data could not be easily shared, and capacity was stranded on underused servers. DAS never disappeared—it remains in laptops, desktops, and many single-server deployments—but its role narrowed as networking storage emerged.
Network Attached Storage (NAS) broke the one-to-one binding between a computer and its disks by placing storage on the local network and serving files over protocols like NFS and SMB/CIFS. A NAS appliance is a specialized file server that lets multiple clients read and write the same files, solving the sharing problem that DAS could not address. NAS operates at the file level: clients request a file path, and the appliance handles block-level details internally. This made NAS popular in offices and departmental settings where users needed to collaborate on documents. However, file-level access introduced overhead and limited performance for database or virtual-machine workloads that prefer raw block access. NAS did not replace DAS; it coexisted with it, taking over shared storage while DAS continued to serve local needs.
Storage Area Networks (SAN) emerged as a rival to NAS, addressing the same sharing problem but at a lower level of abstraction. Instead of serving files, SAN presents block devices over a dedicated high-speed network, typically using Fibre Channel or iSCSI. A server sees a SAN-attached disk as if it were local, allowing applications that require raw block access—databases, virtual machine hypervisors, enterprise applications—to run unchanged. SAN offered better performance and lower latency than NAS for these workloads, but at the cost of greater complexity: it required separate network infrastructure, specialized switches, and skilled administrators. The NAS versus SAN debate was never resolved by one winning; instead, the two frameworks settled into a division of labor. NAS handles file sharing for general-purpose workloads; SAN handles block storage for performance-sensitive enterprise systems. Both coexist with DAS, which remains for single-machine scenarios.
Redundant Array of Independent Disks (RAID) is not a storage architecture in the same sense as DAS, NAS, or SAN—it is a technique for combining multiple physical disks into a single logical unit to improve reliability, performance, or both. RAID levels (0 for striping, 1 for mirroring, 5 for parity-based striping, and others) gave system designers a toolkit for tolerating disk failures without data loss. RAID was introduced in 1988 and quickly became a standard layer beneath DAS, NAS, and SAN alike. A NAS appliance might internally use RAID to protect its file system; a SAN array almost always does. RAID did not replace any earlier framework; it became infrastructure that made other frameworks more robust. Over time, software-defined approaches have absorbed some RAID functionality, but hardware RAID controllers remain common in enterprise storage.
By the late 1990s, the block and file abstractions that underlay DAS, NAS, and SAN were showing strain under web-scale data. Object Storage rejected both abstractions in favor of a flat namespace of self-describing objects. Each object contains data, metadata, and a globally unique identifier, accessed over HTTP using RESTful APIs. This design eliminates the hierarchical directory trees of file systems and the fixed-size blocks of SAN, making object storage ideal for unstructured data like photos, videos, backups, and web content. Amazon’s S3, launched in 2006, popularized the model, but the academic and industrial work on object storage began earlier in the early 2000s. Object Storage differs from NAS in a fundamental way: NAS preserves the file metaphor, while Object Storage discards it entirely, trading POSIX compatibility for massive scalability and simplified management.
Cloud Storage combines the object storage model with the operational and business model of cloud computing: multi-tenant, pay-as-you-go, globally distributed infrastructure. When Amazon Web Services introduced S3 in 2006, it offered object storage as a utility service, accessible from anywhere over the internet. Cloud Storage inherits the flat namespace and HTTP access of Object Storage but adds features like geo-replication, lifecycle policies, and fine-grained access controls managed by the provider. It also introduced a new economic model: instead of buying and maintaining hardware, customers pay only for the storage they use. Cloud Storage did not replace on-premises NAS or SAN; it created a new category for workloads that benefit from elastic capacity and global reach. Many organizations run a hybrid model, keeping sensitive or latency-sensitive data on local storage while using cloud storage for backup, archival, and web-facing content.
Software-Defined Storage (SDS) decouples the storage software that manages data placement, replication, and tiering from the underlying hardware. Instead of buying a proprietary storage array from a single vendor, SDS runs on commodity servers and uses standard disks or SSDs. This framework emerged around 2010 as a response to the lock-in and high cost of traditional SAN and NAS appliances. SDS absorbs many functions that were previously handled by dedicated hardware, including RAID-like redundancy, snapshots, and thin provisioning. It does not replace RAID entirely; rather, it implements RAID logic in software, often with more flexibility (e.g., erasure coding instead of fixed parity). SDS coexists with both NAS and SAN: some SDS products present file or block interfaces, while others offer object storage. The key shift is architectural: storage intelligence moves from the controller to the software layer, enabling commodity hardware and centralized management.
Hyperconverged Infrastructure (HCI) goes a step further than SDS by merging compute and storage into a single cluster of commodity nodes, managed as a unified system. In HCI, each node runs both the hypervisor for virtual machines and the storage software that pools local disks into a distributed store. This eliminates the separate SAN or NAS network entirely. HCI typically uses SDS as its storage layer, so the two frameworks are closely related: SDS provides the software-defined storage fabric, and HCI adds the compute integration and unified management. HCI emerged around 2012, with products like Nutanix and VMware vSAN leading the way. Compared to Cloud Storage, HCI is a local, on-premises approach: it unifies resources within a datacenter rather than across the internet. HCI narrows the role of traditional SAN by absorbing its block-storage function into a software-defined cluster, but it does not replace cloud storage, which remains the choice for geographically distributed or elastic workloads.
Today, no single framework dominates. DAS persists in personal devices and edge servers. NAS and SAN remain entrenched in enterprise datacenters, with NAS serving file-sharing needs and SAN handling high-performance block workloads. RAID continues as a reliability layer embedded in hardware and software. Object Storage has become the standard for unstructured data at scale, both on-premises (via systems like Ceph and MinIO) and in the cloud. Cloud Storage leads for internet-facing applications, backup, and archival. SDS and HCI are the fastest-growing frameworks in on-premises deployments, driven by the desire to escape proprietary hardware. The major agreement among today’s leading frameworks—Cloud Storage, SDS, and HCI—is that storage should be software-defined, scalable, and manageable through APIs rather than manual configuration. The major disagreement is about location and integration: Cloud Storage pushes storage into remote provider datacenters, while SDS and HCI keep it local but disaggregate or converge it differently. The field’s trajectory points toward further abstraction, with storage becoming a programmable service regardless of where it runs.