All posts
InfrastructureKubernetesDevOps

Kubernetes or Not? Right-Sizing Infrastructure for a Small Product Team

November 16, 2026 9 min read

Kubernetes has become the default answer to "where should our app run?" Job postings list it. Conference talks assume it. Cloud providers put it front and center. So when a small team starts a new product, there's a strong pull to set up a cluster on day one. It feels like the grown-up choice.

Sometimes it is. More often, for a team of a handful of engineers shipping one product, Kubernetes solves problems you don't have yet and creates a few you didn't have before. This post covers what Kubernetes actually gives you, what it costs a small team, the simpler options in between, and how to tell when it's time to move.

What Kubernetes actually gives you

It's worth being fair first. Kubernetes is popular because it's genuinely good at a hard set of problems:

  • Scheduling. You describe what should run, and it decides which machines run it, packing workloads onto nodes.
  • Self-healing. Crashed containers restart. Workloads on a failed node get moved elsewhere.
  • Rolling deploys and rollbacks. New versions roll out gradually, gated on health checks.
  • Service discovery and networking. Services find each other by name, without hard-coded addresses.
  • Declarative config. The desired state of the whole system lives in files you can review and version.
  • A huge ecosystem. Nearly every infrastructure tool ships a Helm chart or an operator.

Notice the pattern. Kubernetes shines when you have many services, many teams, and many machines, and you need one consistent way to run all of them. A small team with one web app, one background worker, and a database usually has none of those.

What it costs a small team

The money is rarely the problem. Managed control planes from the major clouds usually carry a modest fee compared with the nodes underneath. The real cost is attention.

A production cluster is a platform, and platforms need care:

  • Upgrades on someone else's schedule. Kubernetes versions have limited support windows. Managed services will push you to upgrade, or charge extra to stay behind, and API deprecations can break your manifests and charts along the way.
  • The add-ons you didn't know you needed. An ingress controller, certificate management, DNS automation, a secrets solution, autoscalers, a metrics stack, log shipping. Each one is another component to configure, upgrade, and debug.
  • New failure modes. Pods stuck in pending, image pull errors, DNS problems inside the cluster, memory limits that kill your process under load. Debugging these takes real Kubernetes knowledge, often at 2 a.m.
  • Security surface. RBAC, network policies, service accounts, pod security settings. The defaults aren't always what you'd want, and misconfiguration is easy.
  • YAML gravity. Manifests, Helm values, and templating layers pile up. Before long, shipping a small change means understanding three files and a templating language.

On a large engineering org, a platform team absorbs this. On a small team, it lands on the same people who are supposed to be building the product. If one engineer becomes "the Kubernetes person", that's a real share of your capacity spent on plumbing users never see. It's also a single point of failure when that person is on holiday.

The options in between

Kubernetes isn't the only step up from "a script on a server". There's a ladder, and most small products are well served by one of the lower rungs.

OptionExamplesYou manageGood fit when
Platform-as-a-serviceRender, Fly.io, Heroku-style platforms, Vercel for frontendsYour code and configStandard web app, worker, and managed database
Managed containersGoogle Cloud Run, AWS ECS on Fargate, Azure Container AppsContainer images and scaling rulesYou want containers and cloud integrations without managing nodes
A VM or two with Docker ComposeAny cloud VMOS patching, backups, the deploy scriptSteady traffic, tight budget, simple topology
Managed KubernetesEKS, GKE, AKSWorkloads, add-ons, upgrades, node poolsMany services, several teams, or portability needs
Self-managed Kuberneteskubeadm, or lightweight distributions like k3sEverythingOn-prem or edge requirements, with in-house expertise

Each step up buys flexibility and control. Each step up also moves more operational work onto your team. The right rung is the lowest one that meets your real requirements.

Don't underrate the boring VM

For many early products, one well-sized virtual machine running Docker Compose is a perfectly respectable production setup. It's cheap, easy to reason about, and every engineer on the team can debug it. Pair it with a managed database so the hard, stateful part is someone else's job:

# docker-compose.yml: web app, background worker, and a TLS-terminating proxy.
# DATABASE_URL in .env points at a managed Postgres instance, not a local container.
services:
  web:
    image: ghcr.io/example/app:${APP_VERSION}
    env_file: .env
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/healthz"]
      interval: 15s
      retries: 3

  worker:
    image: ghcr.io/example/app:${APP_VERSION}
    command: ["node", "worker.js"]
    env_file: .env
    restart: unless-stopped

  caddy:
    image: caddy:2
    ports: ["80:80", "443:443"]
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
    restart: unless-stopped

volumes:
  caddy_data:

Caddy fetches and renews HTTPS certificates on its own, which removes one of the more annoying chores.

Be clear about what you give up. If the VM dies, the app is down until you bring up another one. Deploys cause a brief blip unless you put in extra work. You own OS patching. And Compose restarts containers that exit, but it won't restart one just because its health check is failing. That's one of the things an orchestrator does for you.

For a product that's still finding its users, those are often acceptable trade-offs. The important thing is to accept them on purpose, not by accident. When downtime starts to matter, a second VM behind a load balancer, or a move to managed containers, is the natural next step.

Signals that Kubernetes is worth it

Consider Kubernetes seriously when several of these are true, not just one:

  • You run many services, the number keeps growing, and they have different scaling needs.
  • Several teams deploy independently and need a shared, consistent platform with guardrails.
  • Customers want to self-host your product. If enterprise buyers run Kubernetes and expect a Helm chart, you'll need to build and test on it anyway.
  • You have mixed workloads (long-running services, scheduled batch jobs, GPU jobs) that benefit from sharing a pool of machines.
  • Portability is a hard requirement, across clouds or into on-prem data centers.
  • Someone on the team has run Kubernetes in production and is willing to own it.

That last point matters more than it looks. A cluster run by people who've done it before is a very different thing from a cluster built by following a tutorial.

Signals you should wait

  • You can count your deployable services on one hand.
  • There's one team and one deploy pipeline.
  • Your traffic fits comfortably on a few machines.
  • Nobody on the team has operated a cluster in production.
  • You're still working out what the product is. Before product-market fit, every hour spent on infrastructure is an hour not spent learning from users.
  • The main argument is "we'll need it when we scale". Scaling problems are good problems to have, and they're rarely the ones you predicted.

A note on AI workloads

AI products complicate the picture a little. GPU inference is where Kubernetes often comes up, because it can schedule GPU nodes, pack models onto them, and scale workers based on queue depth. That's real. But GPU drivers, device scheduling, and node autoscaling add another layer of complexity on top of an already complex system.

For a small team, it's usually simpler to call a hosted model API, use a managed or serverless GPU inference platform, or run a single dedicated GPU machine behind a job queue. Move to orchestrated GPU clusters when steady volume makes the utilization maths clearly worth it, and when someone wants to own it.

Make the decision reversible

The good news is that you don't have to get this right forever. If you build with a few habits from the start, moving to Kubernetes later is a contained project rather than a rewrite:

  1. Containerize everything. A Dockerfile per service works on every rung of the ladder.
  2. Keep services stateless. State goes in a managed database, object storage, or a queue, not on local disk.
  3. Configure through environment variables. No config baked into images, no machine-specific paths.
  4. Expose health checks. Separate "the process is alive" from "ready to serve traffic". Every platform uses some version of this distinction.
  5. Log to stdout. Let the platform collect logs instead of writing files to disk.
  6. Define infrastructure as code. Even for a single VM, Terraform or a similar tool beats clicking through a console.
  7. Shut down gracefully. Handle termination signals, finish in-flight requests, and stop taking new work.

Teams that follow these habits can move between a PaaS, managed containers, and Kubernetes with modest effort. Teams that skip them find every platform move painful, including the move to Kubernetes.

A decision path

  1. List your real requirements: services, teams, traffic shape, compliance, customer self-hosting. Today's, not imagined future ones.
  2. Start on the lowest rung that meets them. For most small products, that's a PaaS or managed containers.
  3. Adopt the portable habits above so the choice stays reversible.
  4. Write down your triggers for moving up: a specific number of services, a second team, a self-hosting customer, sustained GPU load.
  5. Revisit the decision on a schedule, say once or twice a year, instead of re-arguing it every sprint.

The short version

Kubernetes is excellent infrastructure for organizations with many services, many teams, and people whose job is to run it. For a small product team, it usually adds operational weight before it adds value. Pick the simplest platform that meets today's real requirements, build in the habits that keep you portable, and decide in advance what would make you move. Then spend the time you saved on the product.


Trying to work out the right infrastructure for your product's current stage? Get in touch — we help teams design and build systems that fit the job.