There’s a quiet tension in the self-hosted and cloud-native space right now. On one side: shiny, fashionable distributed storage systems — MinIO, Ceph, Longhorn, you name it. On the other: something that’s older than most programming languages we use today, yet still powers huge chunks of the internet behind the scenes.

I’ve been testing them all. And I keep coming back to NFS.

The Allure of the New

Let me start by being fair: MinIO is fantastic for S3-compatible object storage. Ceph is a beast when you need block, object, and file all in one cluster. They solve problems that NFS never set out to — especially at massive scale, with geo-distribution, and extremely high throughput across hundreds of nodes.

But here’s the thing: most of us — myself included — don’t actually need that. What we need is reliable storage that doesn’t require a PhD to operate, doesn’t chew through CPU and RAM just to exist, and has stood the test of time.

Why I Still Trust NFS

🕰️ Decades of Real-World Wear

NFS isn’t the new kid on the block — it’s been around since the early 1980s. That sounds like a downside until you realise what that actually means: every major bug has been found and fixed. Every edge case has been hit. Every performance bottleneck is documented and understood.

When I set up an NFS server today, I’m deploying technology that’s been optimised by millions of people across four decades. It’s lean. It’s mean. It just works.

🧠 Simple ≈ Reliable

Look at the resource requirements for Ceph or Longhorn — they want gigabytes of RAM per daemon, constant background sync processes, and a steep learning curve just to get a basic cluster running.

NFS? It’s basically a filesystem export over the network. Configure an export, mount it on the client, and it behaves like local storage. No plugins to manage beyond what your OS already ships with. No consensus algorithms to tune. No "quorum issues" keeping you awake at night.

Complexity has a cost — and you pay it every time something breaks.

🔄 Replicated NFS — Better Than You Think

People often say "NFS isn't replicated" — and they're half-right. NFS itself is a protocol for accessing files, not replicating them. But pair it with something like rsync, drbd, or your filesystem's built-in replication (btrfs send/receive, ZFS send, or even GlusterFS underneath), and you get a robust replicated storage layer.

My setup is humble but effective:

  • Two Debian servers with mirrored exports
  • lsyncd continuously syncs changes from primary to secondary
  • A simple virtual IP or DNS swap handles failover
  • Both export the same filesystem via NFSv4 with Kerberos authentication

It’s not "enterprise distributed" — but it’s redundant, it’s fast enough for my workloads, and I understand every part of it.

🐑 NFS + Kubernetes — Yes, It Works

Here’s where people usually push back: "But Kubernetes needs fancy storage classes!" Not necessarily. The NFS CSI Driver gives you exactly what you need: dynamic provisioning, ReadWriteMany volumes, and persistent storage that survives pod restarts.

apiVersion: storage.k8s.io/v1 kind: StorageClass metadata: name: nfs-shared provisioner: nfs.csi.k8s.io parameters: server: nfs.example.internal share: /srv/k8s-shared reclaimPolicy: Retain volumeBindingMode: Immediate 

It’s not glamorous. It won’t make headlines. But it works. Every single time.

The Honest Trade-offs

Let’s not pretend NFS is perfect:

Feature NFS MinIO Ceph
Protocol File (POSIX) Object (S3) Block/Object/File
Resource Footprint Tiny Light–Medium Heavy
Learning Curve Gentle Gentle Steep
Built-in Replication ❌ Layer it yourself ✅ Built-in ✅ Built-in
Consistency Model Close-to-open tunable Strong tunable Strong
Age & Stability 40+ years ~10 years ~20 years

NFS won’t replace Ceph at 100+ nodes. MinIO is still my first choice when I want S3 buckets. But for the 90% of cases where you just need shared storage that behaves like a filesystem? NFS is hard to beat.

Closing Thoughts

There’s a certain satisfaction in going lower in the stack. It’s the same feeling as reaching for a simple shell script instead of a bloated framework, or writing a Go binary that’s a few megabytes instead of a container image that’s a gigabyte.

Newer isn’t always better. Sometimes the most modern choice you can make is to trust something that’s already stood the test of time.

What’s your storage stack? Do you reach for the battle-tested classics, or do you prefer the modern distributed options? What’s the one thing you wish you’d known before picking your storage layer? Let’s talk in the comments — I’d love to hear what’s working for you in the real world.