Kubernetes vs. Docker Swarm vs. Nomad: A Pragmatic Orchestration Guide for 2021

Let’s be honest: Resume-Driven Development is destroying infrastructure budgets. I recently consulted for a startup in Oslo that was burning through 30,000 NOK a month on a managed Kubernetes control plane to host exactly three Node.js microservices. That is not engineering; that is negligence.

As we head into late 2021, the container orchestration war has settled into a cold truce. Kubernetes won the popularity contest, but for many teams, it is an over-engineered behemoth that introduces more problems than it solves. Docker Swarm refuses to die because it is undeniably simple. HashiCorp's Nomad is the silent professional in the corner.

In this analysis, we are stripping away the marketing fluff. We will look at the operational reality of these three tools, focusing on latency sensitivity, the recent Kubernetes v1.22 API breaks, and why the underlying hardware (specifically NVMe VPS) matters more than the YAML you write.

1. Kubernetes (v1.22): The Enterprise Standard

If you are reading this in August 2021, you are likely panicking about the v1.22 release. The removal of extensions/v1beta1 and networking.k8s.io/v1beta1 is breaking legacy manifests everywhere. It is a necessary pain for stability, but it highlights the primary cost of K8s: Maintenance Overhead.

Kubernetes is not just a tool; it is an ecosystem. You don't just deploy K8s; you deploy Helm, Prometheus, Grafana, Cert-Manager, and an Ingress Controller.

The Hidden Cost: Etcd Latency

Kubernetes stores its state in etcd. This key-value store uses the Raft consensus algorithm, which is incredibly sensitive to disk write latency (fsync). If your underlying storage is slow, your entire cluster becomes unstable. I have seen leaders lose elections simply because of "noisy neighbors" on cheap shared hosting.

To run a stable K8s cluster on a VPS, you need guaranteed IOPS. This is where we draw a line in the sand at CoolVDS. We use local NVMe storage because network-attached block storage often adds just enough latency to cause etcd timeouts under load.

Configuration Check: If you are running etcd on Linux, you should check your disk priority:

# Check I/O priority for etcd
ionice -c2 -n0 -p $(pgrep etcd)

# Ensure you are using an I/O scheduler that supports low latency (e.g., none or mq-deadline for NVMe)
cat /sys/block/vda/queue/scheduler
[none] mq-deadline kyber

Pro Tip: Never run a production K8s control plane on a server with less than 2 vCPUs. The API server needs CPU cycles to serialize JSON responses. If you are targeting the Norwegian market, keeping that control plane in an Oslo-adjacent datacenter reduces latency for your `kubectl` commands and CI/CD pipelines.

2. Docker Swarm: The "Dead" Tech That Still Works

Every year pundits say Docker Swarm is dead. Yet, in 2021, it remains the fastest way to go from "I have a Docker container" to "I have a cluster."

Swarm is embedded in the Docker engine. There is no extra binary to install. For a team of five developers serving a Norwegian e-commerce site, Swarm is often superior to Kubernetes. It lacks the rich ecosystem of CRDs (Custom Resource Definitions), but it has a learning curve of roughly 15 minutes.

Simplicity in Config

Compare a Swarm stack to a K8s manifest. Here is a production-ready Swarm definition for a Redis service:

version: "3.8"
services:
  redis:
    image: redis:6.2-alpine
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
      restart_policy:
        condition: on-failure
    volumes:
      - redis_data:/data
    networks:
      - backend

networks:
  backend:
    driver: overlay

The downside? Networking. Swarm's overlay network can be buggy at scale (1000+ nodes), and finding debugging tools for it is harder than for K8s. However, if you are running 5 to 50 nodes, the TCO (Total Cost of Ownership) is significantly lower.

3. HashiCorp Nomad: The Unix Philosophy

Nomad is the middle ground. It is a single binary. It schedules applications. That is it. It doesn't care if those applications are Docker containers, Java JARs, or static binaries.

With the release of Nomad 1.1 recently, we got CSI (Container Storage Interface) improvements, making stateful workloads much viable. Nomad is favored by teams who want the resilience of an orchestrator without the complexity of Kubernetes networking.

The Performance Advantage

Nomad is exceptionally lightweight. You can run a Nomad client on a CoolVDS instance with 1GB RAM and still have plenty of room for your application. Kubernetes (K3s/K0s excluded) struggles to breathe on anything less than 4GB once you install monitoring.

Infrastructure Matters: The Privacy & Hardware Angle

Regardless of which orchestrator you choose, the software is only as reliable as the kernel it runs on. In 2021, we are dealing with two major external pressures:

1. Schrems II & GDPR: Since the 2020 ruling, relying on US-owned hyper-scalers (AWS/GCP/Azure) has become a legal headache for European companies. Hosting on a Norwegian or European provider like CoolVDS simplifies your data compliance posture significantly.
2. Hardware Isolation: Container orchestrators assume they have the kernel to themselves. In a shared hosting environment (OpenVZ/LXC), you often hit ulimit restrictions or neighbor CPU steal.

We built CoolVDS on KVM virtualization. This provides a hard hardware abstraction. Your Docker engine or Kubelet gets a dedicated kernel, dedicated RAM, and direct access to NVMe instructions. This prevents the "noisy neighbor" effect that causes sporadic 502 errors in your ingress controller.

Benchmark: Sequential Read Performance

We ran a quick fio test comparing standard cloud block storage vs. CoolVDS local NVMe. This metric directly impacts how fast your Docker images unpack and how fast your databases respond.

Conclusion: Choose Based on Pain, Not Hype

If you are building a complex microservices architecture with strict segregation duties and a team of 20 DevOps engineers, use Kubernetes. Just make sure you update your manifests for v1.22.

If you are a lean team wanting to deploy a redundant web cluster in Norway without hiring a consultant, use Docker Swarm.

If you have mixed workloads (Docker + Java + Binaries) and love Terraform, use Nomad.

And if you want those clusters to actually perform, put them on metal that respects your need for speed. Orchestrators add latency; don't let your hosting provider add more.

Ready to test your cluster's resilience? Deploy a high-performance KVM instance on CoolVDS in Oslo. You bring the YAML; we bring the IOPS.