Go back Computational Storage and eBPF: The Next Shift in Data Processing /* by Ayush Makwana - February 11, 2026 */ Tech Update For as long as most of us can remember, storage devices have had one job: hold onto data and hand it back when someone asks. Everything else happened on the CPU. Data was read from disk, pulled into memory, processed, and often discarded. That model worked when datasets were small. But the scale quietly changed. Modern systems routinely handle terabytes and even petabytes of data, including logs, metrics, videos, and training datasets. And in many of these systems, the slowest and most expensive part is no longer the computation itself. It is the act of moving data back and forth. That pressure is what makes computational storage interesting right now. What computational storage really means The idea is simple. Instead of pulling large chunks of data out of an SSD (Solid State Drive) just to inspect or filter them on the CPU, you move some of that logic closer to where the data already lives. Traditionally, data flows from SSD to CPU, gets processed, and most of it is thrown away. With computational storage, the SSD does part of that work and only sends back the results. Here you are just reducing unnecessary data movement. And once you see it that way, the benefits become obvious. Less bandwidth pressure. Fewer wasted CPU cycles. Lower latency. Often lower power consumption too. Networking went through a similar shift when NICs (Network interface controller) started processing packets themselves. Storage is now on the same path. Why is this happening now? Three things are converging to make this practical: First, data volumes exploded. In many systems today, reading and scanning data dominates total execution time. Even if your CPU is fast, pulling data across buses and memory hierarchies is still expensive. Second, SSDs changed. Modern NVMe (Non-Volatile Memory Express) drives are not simple devices anymore. They ship with capable controllers, their own CPUs, memory, and firmware. Third, standards started to form. Until recently, running code inside storage devices was vendor-specific or purely experimental. New NVMe extensions are now defining how programs can be deployed, executed, and managed on storage hardware in a more structured way. Where eBPF fits into this picture eBPF (Extended Berkeley Packet Filter) is a way to run small, restricted programs inside low-level system environments. It allows small, verified programs to run safely in constrained environments. It is already widely used for networking, observability, and security. Its key properties matter here. Programs are sandboxed. They can be loaded dynamically. They run fast. And they do not require modifying core firmware logic. In practice, eBPF gives us a plausible mechanism for pushing small, safe bits of logic into SSD controllers. That makes eBPF a natural fit for running controlled logic inside storage controllers. Programmable storage is becoming real NVMe is evolving beyond basic read and write operations. New capabilities allow storage devices to accept programs, manage execution, and operate on data internally. This does not turn SSDs into general-purpose computers. It turns them into active participants in the data path. Storage stops being a passive endpoint and starts acting like a specialized compute node. What kind of work actually belongs on an SSD Not everything belongs there, and that is important to be clear about. Filtering is the classic case. Instead of reading massive datasets into memory and discarding most of them, the SSD can filter records internally and return only what matters. Compression, encryption, simple search, indexing, and data preprocessing for ML pipelines also fit well. Where this shows up in real systems Large cloud environments are an obvious match. At that scale, shaving off data movement directly translates into lower costs and faster analytics. Databases benefit too. Full table scans are expensive largely because of I/O volume. If storage can pre-filter rows before they reach the query engine, scan-heavy workloads change dramatically. Video platforms can extract metadata or select frames without transferring entire files. Machine learning pipelines can preprocess training data at the source. Edge devices can reduce what they send upstream by processing locally. Where things stand today This space is early, but not speculative. We already have prototype hardware, evolving NVMe specifications, research systems running eBPF inside SSD controllers, and open-source projects that model programmable storage stacks. What is still missing is maturity. Tooling is rough. Debugging is hard. Programming models are still forming. A useful analogy is early GPUs. The potential was clear long before the software ecosystem caught up. Computational storage feels like it is at a similar stage now. Why this matters if you are building systems today This space sits at the intersection of storage systems, operating systems, compilers, and hardware architecture. There are open problems around safety, scheduling, JIT compilation, observability, and developer experience. These are foundational problems, not incremental ones. Early work here can shape how the entire ecosystem evolves. The hard parts are the interesting parts Running code inside storage devices introduces new risks. Security boundaries matter more. Resource isolation is tricky. Firmware is harder to debug than user-space code. Vendor differences complicate portability. None of this is surprising. Every major architectural shift comes with friction. What matters is that the problems are now visible and concrete. And that usually means progress is close behind. Looking ahead System architectures are slowly becoming more distributed. CPUs coordinate and handle complex logic. GPUs handle parallel compute. SSDs handle data-heavy preprocessing at the source. Data gets processed where it lives, not where it is consumed. Computational storage, with eBPF as a key enabler, is a step toward that model. Final thought Storage is no longer just about holding data. As networking hardware evolved into programmable packet processors, storage is beginning a similar transition. The hardware is ready. The standards are forming. The software is early. That combination usually signals a meaningful shift ahead.
