Skip to main content
GullySystem
A practical guide

Docker Compose on one server or Kubernetes for a small team

Ganesh HSStrategy and Technology, GullySystem
Practical advice · 4 min read

In this guide 6 sections
The short answer

For a handful of services and a team under ten, Docker Compose on one well-kept server is usually enough. Kubernetes pays off when you need rolling updates without downtime, scaling across machines or several teams deploying independently. Move when Compose causes visible pain, not before.

What each one asks of the team

Compose is one YAML file. You write services, networks and volumes, run docker compose up, and the stack starts. A developer who knows Docker can read the whole setup in ten minutes.

Kubernetes is a cluster with its own vocabulary. Deployments, Services, Ingress, ConfigMaps, Secrets, namespaces and persistent volume claims all have to be learned. Someone must also own upgrades of the control plane, node pools and the ingress controller.

Managed clusters from the big providers remove the control plane chore. They do not remove the learning. A team of four spends real weeks before the first deploy feels routine.

Deploys, rolling updates and rollbacks

On Compose, a deploy pulls the new image and recreates the container. There is a gap of a few seconds while it restarts. Many internal tools and small products can live with that. A checkout page cannot.

Kubernetes starts the new pods, waits for their readiness probe to pass, and only then retires the old ones. A failed probe stops the rollout. The command kubectl rollout undo returns to the previous revision in moments.

You can get close on Compose with a reverse proxy such as Traefik or Caddy in front, plus two copies of a service and a scripted swap. It works. It is also homemade, and somebody has to maintain the script.

  • Compose: brief restart gap per deploy
  • Kubernetes: readiness probes gate each step
  • Compose rollback: redeploy the older image tag
  • Kubernetes rollback: one undo command

Scaling and who gets the night page

Compose scales a service by running more containers on the same machine. When the machine is full, you buy a bigger one. That is simple and has a ceiling.

Kubernetes spreads pods across nodes and replaces a failed node’s workload on its own. It can add pods when load rises. The price is more moving parts that can themselves fail at three in the morning.

Ask who carries the pager. If it is one developer who also ships features, a single server they fully understand is safer than a cluster they half understand. Fewer parts means fewer alerts.

Signs that one server has stopped being enough

Watch for repeating pain, not one bad week. A single server is also a single point of failure, so a kernel panic or a full disk takes everything down at once.

Count the incidents that traced back to the host. Count the deploys you postponed because of the restart gap. When those pile up, the cost of moving starts to look small.

Before a full jump, consider the middle path. Docker Swarm, Nomad or a managed container service such as AWS ECS or Google Cloud Run give rolling updates without the whole Kubernetes surface.

  • Deploys postponed to avoid downtime
  • Memory or disk limits hit on the host
  • Customers asking for a stated uptime target
  • A second team needing separate release cycles
  • A host failure that stopped the business

A plan for staying on Compose well

If you stay, do it properly. Keep the compose file and environment templates in git. Take volume backups off the machine and restore one to check it. Add health checks to every service and restart policies that make sense.

Script the server build with Ansible or Terraform so a replacement can be created from nothing. That removes the single-server fear far more cheaply than a cluster does.

Write down the triggers that would send you to Kubernetes, then review them each quarter. This week, list your three most recent outages and mark which ones a cluster would have prevented.

Compose or Kubernetes scorecard

A one-page scorecard with two columns, Stay on Compose and Move to orchestration. Rows cover deploy gap tolerance, number of services, number of deploying teams, host failure impact, pager owner, backup restore date and monthly hours spent on server upkeep. Each row has a tick box and a note. A footer line records the review date and the trigger that would force a move.

Open a blank worksheet to print

Questions owners ask

Is Docker Compose fine for production?

Yes, for modest workloads when you accept a short restart on deploy and a single host as a failure point. Add off-machine backups, health checks and a scripted server build to make it dependable.

How many services before Kubernetes makes sense?

Count matters less than behaviour. A dozen steady services can sit happily on Compose. Two services that need zero-downtime releases and multi-node failover may justify a cluster.

Can we start with Compose and move to Kubernetes later?

Yes. Containers built for Compose run in Kubernetes with little change. The work is in writing manifests, probes and secrets handling, so keep configuration in environment variables from the start.

What is a lighter alternative to Kubernetes?

Managed container services such as AWS ECS or Google Cloud Run handle rolling updates and scaling for you. Docker Swarm and Nomad are self-run options with a smaller learning curve.

Browse all guidesBack to top ↑
Next step

Have a specific situation to work through?

This article covers the general case. Tell us what you’re actually dealing with and we’ll respond directly.

Share Your Requirements