StackLift
All terms

Glossary

Kubernetes

An open-source system that runs, scales and heals containerized applications across a group of machines.

Kubernetes is an open-source platform that automates how containerized applications are deployed, scaled and kept running across a cluster of machines. You describe the state you want, such as three copies of a service, and Kubernetes works continuously to make reality match, restarting failed containers and spreading load.

Kubernetes began at Google and is now maintained by the Cloud Native Computing Foundation. It is often shortened to K8s. All major clouds offer managed versions, so you rarely have to run the control plane yourself.

It is powerful and has a real learning curve. For a single small application, a simpler managed platform is often the better fit.

Start in 60 seconds

Put this to work on your project.

Get an AI-assisted, architect-reviewed scope, cost range, and timeline. Free, no login.

The complete guide

Kubernetes: the complete guide

Updated November 18, 2026 ยท Published by , Founder, StackLift AI. Written with AI assistance; how we make content.

Short answer

Kubernetes is an open-source container orchestration platform. You declare the desired state of your applications, and Kubernetes deploys the containers across a cluster, scales them with demand, restarts failures and handles networking and rolling updates. It suits many services at scale, but it adds operational complexity that small applications may not need.

What is Kubernetes?

Containers package an application with everything it needs to run. Running a few of them on one machine is easy. Running hundreds across many machines, keeping them healthy, routing traffic to them and updating them without downtime is the problem Kubernetes solves. People often write it as K8s: the 8 stands for the eight letters between the K and the s.

Technically, Kubernetes is a scheduler plus a set of control loops. You describe what should be running, such as "three copies of this service, each with this much memory". Kubernetes places those copies on available machines and keeps checking that reality still matches your description. If a machine fails, it moves the work elsewhere.

It started inside Google, was released as open source and is now governed by a vendor-neutral foundation. That is why every major cloud offers a managed version and why the same manifests work in many places.

Why does Kubernetes matter for a software project?

Kubernetes changes how an application is deployed and operated, not how it is written. It gives teams a shared, declarative way to release, scale and heal services, so deployment knowledge lives in files under version control instead of in one engineer's head.

  • Repeatable releases: the same manifests deploy to staging and production.
  • Self-healing: failed containers restart and unhealthy ones stop receiving traffic.
  • Elastic capacity: workloads scale up and down with demand.
  • Portability: the same platform runs on any major cloud or on your own hardware.
  • A common surface for tooling: monitoring, security scanning and deployment tools all speak Kubernetes.

The price is a new layer to learn, secure and pay for. Whether it is worth it depends on how many services you run, how often they change and how much traffic varies.

What are the core Kubernetes concepts?

Kubernetes building blocks
ConceptWhat it isEveryday analogy
ClusterA set of machines managed togetherA warehouse with many shelves
NodeOne machine in the cluster that runs workloadsOne shelf
PodThe smallest deployable unit: one or more containers that run togetherA box on a shelf
DeploymentA rule that keeps a set number of identical pods running and rolls out updatesA standing order for three boxes
ServiceA stable network address in front of a changing set of podsA front desk that forwards visitors
IngressRules that route outside traffic to servicesThe building's main entrance
ConfigMap and SecretSettings and sensitive values kept outside the imageA settings folder and a safe
NamespaceA named partition inside a clusterA department floor

Most day-to-day work touches only a few of these: deployments, services, ingress and configuration. The rest exist for special cases such as stateful databases, scheduled jobs and per-node agents.

How does Kubernetes work?

A control plane decides what should happen and worker nodes do the work. You send desired state to the control plane, usually as YAML manifests. Controllers compare desired state with actual state and act on the difference, over and over.

  1. You build a container image and push it to a registry.
  2. You write a manifest that names the image, the number of copies and the resources each needs.
  3. You apply the manifest. The control plane stores it as the desired state.
  4. The scheduler picks nodes with enough free capacity and starts the pods there.
  5. Health checks watch each pod. A failing pod is restarted, and a pod that is not ready gets no traffic.
  6. A service gives the pods one stable address, and ingress routes outside requests to it.
  7. To update, you change the image version. Kubernetes starts new pods and retires old ones in steps.

Because the loop never stops, you do not give commands like "start this container". You state an outcome and let the platform converge to it. That idea, declarative configuration, is the core of Kubernetes.

What is Kubernetes used for? Real-world examples

Typical workloads
WorkloadWhy Kubernetes fits
Many microservicesEach service deploys, scales and rolls back on its own
Spiky web traffic, such as a retail saleAutoscaling adds capacity for the peak and removes it after
Batch and scheduled jobsJobs and CronJobs run to completion and clean up
AI inference servicesPods can request specific hardware and scale with request volume
Multi-tenant SaaSNamespaces and quotas separate teams or customers
Internal developer platformsOne shared platform with consistent deployment tooling

A fintech platform with a dozen services, a logistics system that scales during peak shipping periods and a SaaS product that serves many customers on shared infrastructure are all typical fits. A single marketing site or a small internal tool usually is not.

Kubernetes vs. simpler options: which should you use?

Where each option fits
OptionBest whenTrade-off
Platform as a serviceOne or a few apps, small teamLess control, platform limits
ServerlessEvent-driven or spiky workloads, little ops capacityRuntime limits, cold starts, vendor ties
Managed container serviceA handful of containers on one cloudCloud-specific, fewer features than Kubernetes
Docker Compose on a serverPrototypes and small internal toolsNo automatic healing or scaling across machines
Managed KubernetesMany services, several teams, portability needsMore concepts and more to secure

See serverless vs. containers for the wider comparison. A good rule: start with the simplest platform that meets today's needs, and move to Kubernetes when the number of services or teams makes the simpler option the bottleneck.

Kubernetes is also not the same as Docker. Docker builds and runs individual containers. Kubernetes coordinates many containers across many machines, and it can run containers built with Docker or other tools.

What does running Kubernetes well require?

Standing up a cluster is the easy part. Keeping it healthy is a continuing job. Use a managed offering from your cloud, such as Amazon EKS, Azure AKS or Google GKE, so the control plane is operated for you, but remember that you still own what runs on it.

  • Resource requests and limits on every workload, so one service cannot starve others.
  • Health and readiness probes that reflect real application health.
  • Centralized logs, metrics and traces, so failures can be diagnosed (observability).
  • A deployment pipeline that applies manifests from version control (CI/CD).
  • Cluster upgrades on a schedule, since versions go out of support.
  • A cost review, because idle capacity is easy to forget.
  • Backups and a tested recovery plan for anything stateful.

Defining clusters and manifests as code, see infrastructure as code, keeps environments consistent and changes reviewable.

Managed Kubernetes or self-managed: how do you choose?

Most teams should use a managed service. The provider runs the control plane, patches it and keeps it available, which removes the hardest operational work. Self-managing a cluster makes sense mainly when you must run on your own hardware, in a restricted network or with unusual requirements.

Operating models compared
ModelYou runChoose it when
Managed service (EKS, AKS, GKE)Worker capacity, workloads, access and security settingsYou use a major cloud and want the least operations work
Managed with serverless nodesWorkloads only, with capacity added on demandTraffic is uneven and you want less node management
Self-managed on cloud machinesControl plane, nodes, upgrades and recoveryYou need control that managed services do not offer
On-premises or edgeEverything, including hardwareData location, latency or regulation requires it

Whichever you pick, keep manifests portable. Avoid depending on a feature of one provider unless the benefit is clear, so you can still move if your needs change.

How does Kubernetes scale applications and AI workloads?

Kubernetes scales in two directions. Horizontal scaling adds or removes pod copies as load changes, based on signals such as processor use or request rate. Cluster scaling adds or removes machines when pods cannot be placed or machines sit idle. Together they let capacity follow demand without a person watching a dashboard.

AI services use the same mechanics. An inference service for a hosted or open-weight model can run as a deployment that requests specific hardware, and it can scale with request volume. Model files are large and slow to load, so plan for start-up time and keep a minimum number of warm copies for latency-sensitive features.

What are the security basics for Kubernetes?

  • Give each workload the least access it needs, with role-based access control and separate service accounts.
  • Keep secrets out of images and source code. Use a secrets manager or encrypted secrets.
  • Scan images for known vulnerabilities and use trusted base images.
  • Restrict traffic between pods with network policies, so a compromised pod cannot reach everything.
  • Run containers as a non-root user and drop capabilities they do not need.
  • Keep the cluster and its components patched.
  • Audit who changed what, and keep logs outside the cluster.

Security is shared. The cloud provider secures the managed control plane. Your team secures images, configuration, access and what the applications do.

What mistakes do teams make with Kubernetes?

  • Adopting it for an application that fits a single server or a platform service.
  • Splitting a small app into many services only to justify the cluster.
  • Skipping resource limits, then chasing noisy-neighbor problems.
  • Treating the cluster as hand-edited, instead of applying manifests from version control.
  • Running databases in the cluster without a backup and recovery plan.
  • Having no one responsible for upgrades, cost and security.

Signals that it is working are easy to name: releases are routine, rollbacks are quick, an engineer can explain how a failure was handled, and cost matches demand. If deployments feel more fragile than before, the platform is adding burden.

When is Kubernetes the wrong choice?

Kubernetes is the wrong choice when the problem it solves is not yours. A single web application, a prototype, a small team with no platform experience or a workload that fits serverless usually does better on something simpler.

You can move later. Containerizing an app and keeping its configuration in the environment makes a later move to Kubernetes much easier. A monolith in one container can be a perfectly good starting point.

What does Kubernetes mean for cost and timeline, and how does StackLift approach it?

Cost comes from cloud capacity, the managed control plane, tooling, and above all the engineering time to build and run the platform. The number of services, environments, compliance needs and traffic patterns all move the effort. See cloud and DevOps cost for how those drivers are scoped.

StackLift chooses a runtime by need, not by trend. CI/CD, observability, security review and rollback are part of the plan from sprint one, whichever platform the architecture calls for. A senior architect reviews the choice before it becomes a commitment. The free estimate scopes the work in about five minutes.

Questions people ask

What does K8s mean?

K8s is shorthand for Kubernetes. The 8 replaces the eight letters between the K and the s.

Is Kubernetes the same as Docker?

No. Docker builds and runs containers. Kubernetes orchestrates many containers across a cluster. They are used together, but they do different jobs.

Do I need Kubernetes to use containers?

No. Containers run fine on one server, in a managed container service or on a platform service. Kubernetes becomes useful when you run many containers and need scaling, self-healing and rolling updates.

Is Kubernetes hard to learn?

The basics take a short time. Running it well in production, including security, networking, upgrades and cost control, takes longer. Managed services remove some of the operations work.

What is a Kubernetes manifest?

A file, usually YAML, that describes the desired state of an object such as a deployment or service. You apply it, and Kubernetes works to make reality match it.

Can Kubernetes do zero-downtime deploys?

Yes. Rolling updates replace pods gradually, and readiness checks keep traffic away from pods that are not ready. Pair it with blue-green or canary releases for extra control.

What is the difference between Kubernetes and serverless?

With Kubernetes you manage containers and the cluster they run on. With serverless the provider runs your code on demand and you manage no servers. Serverless is simpler to operate for many workloads, and Kubernetes gives more control.

Should a startup use Kubernetes?

Usually not at the start. Most early products run well on a platform service or a managed container service. Move when the number of services or teams makes the simpler option a bottleneck.

Sources

Sources and further reading

The standards, rules, research and official documentation this page draws on.