Skip to content
Blog

Nomad vs Kubernetes: Workload Model Differences

Nomad's single scheduler and job spec versus Kubernetes's controller hierarchy of Deployments, ReplicaSets, and Pods — how the two workload models shape everything else.

Published on • November 14, 2026

AI Assistant

Nomad and Kubernetes both reconcile desired state against reality, but they draw the boundary completely differently: Nomad puts one scheduler in charge of a flat job hierarchy, Kubernetes spreads the work across a layered tower of controllers. Almost every operational difference you’ll ever argue about descends from that one choice.

Flat scheduler vs layered control plane

Nomad’s control plane is small: servers hold jobs and allocations in a Raft-backed state store, and the scheduler matches allocations to nodes. The workload hierarchy is job → group → task — three levels, one file, one scheduler making placement decisions. There is no second system watching the first.

Kubernetes splits the same responsibility across a delegation chain. You write a Deployment; the Deployment controller creates and owns a ReplicaSet; the ReplicaSet creates and owns Pods; the scheduler places Pods; kubelet runs the containers. Each layer is an independent controller with its own reconciliation loop, watching its own resource type.

That layering is the source of Kubernetes’s superpowers — you can intervene at any level (scale a ReplicaSet directly, pin a Pod, drain a node) and every layer re-reconciles — but it’s also three abstractions to learn before kubectl describe pod makes sense. The Deployment/ReplicaSet split exists so you can do rolling updates with revision history; Nomad instead versions the job spec itself and rolls allocations forward, which gets you similar behavior with fewer objects.

Jobs vs controllers: two flavors of “keep it running”

Both systems are declarative, but the unit of intent differs.

In Nomad, you submit a job and the scheduler places allocations (group instances). Failure handling is scheduler-driven: an allocation dies, Nomad notices, reschedules it on a healthy node according to the job’s restart and update policies. For finite work there are first-class job types — batch (run and exit), sysbatch (node-local periodic), parameterized (triggered with input) — so “run 5,000 transcode tasks and stop” is native, not bolted on.

In Kubernetes, long-running state lives in workloads: Deployments (stateless), StatefulSets (ordered, stable identity), DaemonSets (one per node), Jobs/CronJobs (finite). The Pod is the atomic unit — but a Pod alone gets you nothing: no self-healing, no rollout, no scaling. All of that comes from attaching a controller above it. Kubernetes’s model is more kinds of intent, each with specialized semantics; Nomad’s is one kind of intent (a job) parameterized by type and restart policy.

The practical consequence: Nomad expresses batch and parameterized pipelines directly, while Kubernetes expresses them as Job resources with backoff limits and completions — workable, but batch was clearly not the design center. Conversely, Kubernetes expresses things Nomad has no native concept of: canary traffic splits via an external controller, PodDisruptionBudgets, or graceful node-drain semantics per workload class.

Task drivers vs CRI and runtimes

This is where the workload models diverge most sharply.

Nomad talks to task drivers — pluggable adapters (docker, exec, java, qemu, raw_exec, podman) compiled into the client agent. A job picks a driver and the driver executes it. That’s why Nomad can run a JVM jar or a raw binary with no container involved: there’s no container runtime in the path.

Kubernetes runs containers through the CRI (container runtime interface — containerd or CRI-O). Everything scheduled is a Pod of containers; there is no first-class “run this host binary” workload. You can do it (an exec-style sidecar, or a custom runtime), but you’re fighting the abstraction — and every non-container workaround becomes an image with an entrypoint, which is Nomad’s point exactly.

Trade-off: Nomad gains workload breadth but loses standardization. Drivers behave differently (image handling, logging, signals), and portability across drivers is your problem. Kubernetes gains one uniform execution contract — images, logs, kubectl exec, resource accounting all behave identically — at the cost of the container-everything assumption.

Networking: Consul vs Services and CNI

Nomad’s network story is deliberately outsourced. Task groups get ports allocated by the client; service registration, discovery, health checks, and mesh mTLS come from Consul (Nomad’s template block and service stanza integrate it), while IPAM and pod networking are handled by CNI plugins wired into the task group’s network stanza. You assemble a platform from three products.

Kubernetes bakes it in: every Pod gets an IP from the CNI plugin, Services provide stable virtual IPs with kube-proxy/eBPF load balancing, Ingress or Gateway API handles north-south traffic, and NetworkPolicies gate east-west. Service discovery is DNS (svc.namespace.svc.cluster.local) with no external system required. A mesh (Istio, Linkerd) is optional on top.

So: Kubernetes = one integrated networking model, more to learn, less to assemble; Nomad = smaller core, but “what does service discovery look like?” is answered by your Consul deployment, and every team answers it slightly differently.

State and extension: HCL jobs vs the CRD ecosystem

Nomad state is HCL job files you submit through the API — version them in git, nomad job run, done. The extension surface is the driver and plugin interfaces plus the Consul/Vault ecosystem. There is no way for a third party to add a new resource type to the API.

Kubernetes state is API objects, and the API is open: CRDs let anyone define new resource types, and controllers (often written with kubebuilder/operator-sdk) reconcile them. This is why the ecosystem explodes — operators for PostgreSQL, cert-manager, Argo CD, Crossplane — and why “everything is a YAML file” is both the platform’s strength and its most-quoted complaint. The API surface grows with every operator you install, and so does your upgrade coordination.

What this means for ops and extension

DimensionNomadKubernetes
Control planeOne binary, own Raft storeAPI server + etcd + controllers
Workload hierarchyjob → group → taskDeployment → ReplicaSet → Pod
PlacementSingle scheduler passScheduler + controller per layer
ExecutionTask drivers (containers and binaries)CRI — containers only
NetworkingAssembled: Consul + CNIIntegrated: Services + CNI + Ingress
ExtensionDrivers, plugins, Consul/VaultCRDs + operators everywhere
Finite workbatch / sysbatch / parameterizedJobs / CronJobs
YAML/HCL volumeOne job fileMany objects per app

For ops, the flat model means fewer moving parts to reason about and a smaller failure surface — but also fewer escape hatches when you need semantics the job spec doesn’t have. The layered model means you can express nearly anything and extend the API itself — at the cost of coordinating a growing tower of controllers through every upgrade. Pick based on whether your extension needs are real or hypothetical: teams whose workload list fits Nomad’s job types get a simpler platform; teams that anticipate custom resources, policy engines, and third-party operators should take Kubernetes’s complexity up front, because retrofitting it later is far more expensive.

Further reading