Container Orchestration Beyond Kubernetes

Kubernetes is the industry standard for container orchestration. It is also complex, resource-heavy, and overkill for many workloads. If you are running a handful of services for a small-to-medium product, the operational overhead of Kubernetes — etcd clusters, control plane management, YAML sprawl, networking plugins, RBAC configuration — may cost more in engineering time than it saves.

Here are container orchestration options for teams that need to run containers reliably without the full Kubernetes overhead.

When Kubernetes Is Overkill

Kubernetes makes sense when you have:

• Dozens to hundreds of microservices
• A dedicated platform or SRE team
• Complex scaling requirements (auto-scaling based on custom metrics)
• Multi-cloud or hybrid deployment needs
• Compliance requirements that mandate specific orchestration features

If you have 3-15 services, a small team, and deploy to one or two environments, simpler tools will likely serve you better.

Docker Compose (with Swarm Mode)

Docker Compose is what most developers already use for local development. What many do not realize is that Docker includes Swarm mode for production orchestration using the same Compose files.

How Swarm Works

Docker Swarm turns a group of Docker hosts into a single virtual host. You deploy services using docker stack deploy with your existing docker-compose.yml file. Swarm handles:

• Service distribution across nodes
• Rolling updates
• Health checks and restart policies
• Load balancing between service replicas
• Secrets and config management

Strengths

• Near-zero learning curve: If you know Docker Compose, you know 90% of Swarm
• Built into Docker: No additional software to install
• Simple networking: Overlay networks work out of the box
• Small footprint: Runs on modest hardware

Limitations

• Docker has officially shifted focus away from Swarm in favor of Kubernetes
• Smaller community and fewer integrations than Kubernetes
• Limited auto-scaling capabilities
• No built-in service mesh

Best for: Small teams already using Docker Compose that need basic production orchestration with minimal learning curve.

HashiCorp Nomad

Nomad is HashiCorp's workload orchestrator. It handles containers, VMs, binaries, and Java applications with a single tool. Unlike Kubernetes, which is containers-only, Nomad orchestrates anything.

Strengths

• Simple architecture: Single binary, no external dependencies. A Nomad cluster needs only Nomad — no etcd, no separate API server, no kubelet.
• Multi-workload: Run Docker containers, raw binaries, Java JARs, QEMU VMs, and more in the same cluster.
• Gradual adoption: Start with a single-node Nomad deployment and scale up as needed. No minimum cluster size.
• HashiCorp ecosystem: Integrates natively with Consul (service discovery), Vault (secrets), and Terraform (infrastructure).
• HCL configuration: HashiCorp Configuration Language is cleaner than YAML for many developers.

Example Job Spec

job "webapp" {
  datacenters = ["dc1"]
  type = "service"

  group "web" {
    count = 3

    network {
      port "http" { to = 8080 }
    }

    task "server" {
      driver = "docker"
      config {
        image = "myapp:latest"
        ports = ["http"]
      }
      resources {
        cpu    = 500
        memory = 256
      }
    }
  }
}

Limitations

• Smaller ecosystem than Kubernetes — fewer third-party integrations
• Service mesh requires Consul Connect (separate tool)
• BSL license (not fully open source since 2023)
• Fewer managed hosting options

Best for: Teams that run mixed workloads (not just containers) or want simpler orchestration with the flexibility to grow.

Kamal (by 37signals)

Kamal (formerly MRSK) is the deployment tool built by the team behind Basecamp and HEY. It deploys containerized applications to bare servers using SSH — no orchestrator needed.

How It Works

Kamal builds your Docker image, pushes it to a registry, then SSHs into your servers and runs the containers directly. It handles zero-downtime deployments using Traefik as a reverse proxy, switching traffic from old containers to new ones automatically.

Strengths

• Bare metal simplicity: Deploy to any Linux server with SSH access. No cluster to manage.
• Zero-downtime deployments: Traefik-based routing handles blue-green deployments automatically.
• Familiar model: If you have deployed with Capistrano, the mental model is similar.
• Cost-effective: Run on cheap VPS instances ($5–20/month) without managed Kubernetes overhead.
• Kamal 2: Released in 2025, Kamal 2 added proxy mode (replacing Traefik with kamal-proxy), faster boots, and simplified multi-app deployments on shared hosts.
• Configuration: Simple YAML configuration in config/deploy.yml.

Limitations

• No auto-scaling — you manage server count manually
• No built-in service discovery for microservices
• Limited health checking compared to orchestrators
• Best suited for monolithic or simple multi-service architectures

Best for: Teams deploying web applications to VPS/bare-metal servers who want simple, reliable deployments without an orchestrator.

Docker Compose with Managed Hosting

Several platforms now offer managed container hosting using Docker Compose files directly:

Railway

Railway deploys applications from Git repositories with automatic container building. It handles scaling, networking, and persistence without requiring any orchestration knowledge.

Pricing: Pay-as-you-go based on resource usage. Hobby plan at $5/month. Pro plan at $20/month with team features.

Fly.io

Fly.io runs your containers on their global edge network. Deploy with a simple fly deploy command. According to the platform, it handles load balancing, TLS, and auto-scaling across regions.

Pricing: Free tier with limited resources. Pay-as-you-go from $0.0035/hr per shared CPU. Launch plan at $29/month for production workloads.

Render

Render deploys Docker containers with automatic scaling, managed databases, and built-in CI/CD. According to the company, it aims to be the simplicity of Heroku with modern infrastructure.

Pricing: Free tier for static sites. Service plans from $7/month.

Coolify

Coolify is an open-source, self-hosted alternative to platforms like Heroku, Netlify, and Vercel. It deploys applications, databases, and services to your own servers with a polished web UI. In 2026, Coolify v4 added multi-server support, one-click service templates, and improved Docker Compose integration.

Pricing: Free and open source. Optional cloud-hosted version from $5/month.

Comparison

Decision Guide

Choose Docker Swarm if:

• You already use Docker Compose and want the simplest path to production
• Your team is small and does not want to learn new tools
• You need basic orchestration without external dependencies

Choose Nomad if:

• You run mixed workloads (containers + binaries + VMs)
• You use or plan to use other HashiCorp tools (Consul, Vault, Terraform)
• You want simpler orchestration that can grow to large scale

Choose Kamal if:

• You deploy a web application (monolith or simple multi-service)
• You want to use cheap VPS servers without managed Kubernetes
• You value simplicity and deploy via SSH

Choose managed hosting if:

• You do not want to manage infrastructure at all
• Your application fits within the platform's constraints
• You prefer pay-per-use pricing over fixed infrastructure costs

Choose Coolify if:

• You want a Heroku-like experience on your own servers
• You prefer a web UI for deployment management
• You need to deploy both applications and databases from one interface

Choose Kubernetes if:

• You have 50+ services and a platform team to support them
• You need advanced features (custom operators, service mesh, multi-cluster)
• Your organization has standardized on Kubernetes

The Bottom Line

Kubernetes is not the only option, and for many teams it is not the best option. Docker Swarm gives you orchestration with near-zero learning curve. Nomad offers flexibility and simplicity with room to grow. Kamal provides dead-simple deploys to bare servers. Managed platforms eliminate infrastructure entirely. Match the tool to your actual requirements, not to what the largest tech companies use.

Frequently Asked Questions