What is Kubernetes and what problems does it solve?

Question

IT Interview Practice · Accepted Answer

**Kubernetes** (often abbreviated **K8s**) is an open-source **container orchestration** platform. It automates deploying, scaling, networking, and healing containerized applications across a cluster of machines, so you describe the *desired state* and Kubernetes continuously works to make reality match it.

## The problem: running containers at scale is hard

```text
You have containers (from Docker), but in production you must also answer:
  → On WHICH machine does each container run? (scheduling)
  → What if a container crashes? (self-healing / restarts)
  → What if a whole node dies? (reschedule elsewhere)
  → How do 50 replicas find and talk to each other? (service discovery)
  → How do I roll out a new version with zero downtime? (rolling updates)
  → How do I scale from 3 to 30 replicas on a traffic spike? (autoscaling)
Doing all this by hand across many servers does not scale.
```

## The solution: declarative orchestration

You submit a **manifest** describing what you want, and the cluster's **control loops** drive the system toward it:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3            # "I want 3 copies running, always"
  selector:
    matchLabels: { app: web }
  template:
    metadata:
      labels: { app: web }
    spec:
      containers:
        - name: web
          image: nginx:1.27
          ports:
            - containerPort: 80
```

```bash
kubectl apply -f web.yaml     # declare desired state
kubectl get pods              # Kubernetes has created & scheduled 3 Pods
```

If a Pod dies, Kubernetes notices the gap (2 running vs 3 desired) and creates a replacement automatically.

## What Kubernetes gives you

```text
✓ SCHEDULING       — places Pods on nodes based on resources & constraints
✓ SELF-HEALING     — restarts failed containers, replaces dead Pods/nodes
✓ SERVICE DISCOVERY— stable virtual IPs & DNS names for groups of Pods
✓ LOAD BALANCING   — spreads traffic across healthy replicas
✓ ROLLING UPDATES  — ship new versions with no downtime, roll back on failure
✓ SCALING          — manual or automatic (Horizontal Pod Autoscaler)
✓ CONFIG & SECRETS — inject configuration without rebuilding images
✓ STORAGE ORCHESTRATION — attach persistent volumes to workloads
```

## Declarative vs imperative

```text
IMPERATIVE  → "run this command, then that command" (you manage each step)
DECLARATIVE → "here is the end state I want" (Kubernetes reconciles to it)
The declarative, reconciliation-loop model is Kubernetes' core idea.
```

## Why it matters

Kubernetes has become the de facto standard for running containerized workloads in production, so understanding what it is and what problems it solves is foundational, broadly-applicable knowledge. Containers (from tools like Docker) solve packaging, but they don't answer the operational questions that arise at scale: which machine each container runs on, what happens when a container or an entire node fails, how dozens of replicas discover and talk to each other, how to roll out a new version without downtime, and how to scale up and down with demand. Kubernetes addresses all of these through a **declarative, reconciliation-based** model: you describe the desired state in a manifest, and the cluster's control loops continuously drive the actual state toward it — creating, scheduling, restarting, and replacing Pods as needed. This gives you **self-healing** (crashed containers and dead nodes are recovered automatically), **service discovery and load balancing** (stable virtual IPs and DNS in front of groups of Pods), **rolling updates and rollbacks** (zero-downtime deploys), **scaling** (manual or automatic), and **config, secret, and storage orchestration**. Because Kubernetes underpins how a large share of the industry deploys and operates software — across every major cloud and on-premises — grasping its purpose and the declarative model at its heart is essential context for modern infrastructure work, and the mental foundation on which every other Kubernetes concept builds.

The problem: running containers at scale is hard

The solution: declarative orchestration

What Kubernetes gives you

Declarative vs imperative

Why it matters

Related questions