Kubernetes skills
employers want

Kubernetes automates running containers across many machines. Its documentation describes it as a portable, extensible platform for managing containerised workloads and services through declarative configuration.¹ Core skills include the architecture (control plane, nodes, kubelet); workloads (pods, deployments, StatefulSets, DaemonSets, Jobs); services and ingress; ConfigMaps and secrets; resource requests and limits; liveness, readiness and startup probes; horizontal autoscaling; persistent volumes; namespaces; RBAC and network policies; Helm or Kustomize for packaging; and troubleshooting with kubectl, logs and events.

Kubernetes is a step beyond containers: Stack Overflow's 2025 survey found 28.5% of developers using Kubernetes and 71.1% using Docker,² and the CNCF's annual surveys track cloud-native adoption across organisations.³ Kubernetes expertise sits at the heart of platform and SRE roles. AmbitionBox lists site reliability engineers in India at a typical ₹14.8–16.4 lakh⁴ and platform engineers at ₹16–17.7 lakh, up 15% in two years.⁵

Developers using Kubernetes (Stack Overflow 2025)

28.5%

Developers using Docker (Stack Overflow 2025)

71.1%

Typical SRE pay in India (AmbitionBox)

₹14.8–16.4 lakh

Typical platform engineer pay in India (AmbitionBox)

₹16–17.7 lakh

Table: How Kubernetes skills are assessed (editorial summary)

Table: Diagnosing and fixing a Kubernetes reliability issue (illustrative)

Table: How Kubernetes developed (editorial summary)

• An app deployed with deployment, service and ingress
• Requests, limits and probes set
• An autoscaler configured
• RBAC and a network policy
• A troubleshooting write-up
• A verified Kubernetes certificate

Show reliability impact: "Tuned requests, limits and probes; added HPA and disruption budgets; eliminated evening pod restarts and stabilised latency for payments service."

"What happens when you apply a deployment?"

The API server stores desired state; controllers create a ReplicaSet and pods; the scheduler places them; kubelets run them.

"Pod is in CrashLoopBackOff — what do you do?"

Check logs (including previous), describe events, config, image, probes and resources.

"Readiness vs liveness probe?"

Readiness controls traffic; liveness restarts unhealthy containers.

"How do you expose an app?"

A service for stable networking, plus ingress or a load balancer for external traffic.

"How do you secure a cluster?"

RBAC least privilege, network policies, pod security standards, secrets management and image scanning.

• "Managed or self-hosted clusters?" — environment.
• "How are deployments done — GitOps?" — maturity.
• "How many clusters and namespaces?" — scale.
• "Who's on call for the platform?" — responsibilities.

Table: Kubernetes-related roles and typical pay in India (AmbitionBox, October 2026; indicative)

Table: Common Kubernetes tools (editorial guidance)

• DevOps engineer — deploys to Kubernetes.
• Kubernetes / platform engineer — runs clusters.
• SRE — reliability at scale.
• Platform lead — internal developer platform.
• Head of infrastructure — strategy.

1. Week 1: Concepts — Architecture and core objects on a local cluster.
2. Week 2: Deploy — An app with deployment, service, ingress, config.
3. Week 3: Harden — Probes, limits, HPA, RBAC, network policy.
4. Week 4: Prove it — Break and fix; take the Kubernetes Fundamentals Certification.

Related: Docker, Site Reliability Engineering and CI/CD and DevOps. Guides: Docker, SRE and CI/CD.

• Deployments — via GitOps or pipelines.
• Troubleshooting — pods and networking.
• Capacity — node pools and limits.
• Upgrades — cluster versions.
• Security — policies and scanning.
• Support — helping app teams.

"StatefulSet vs Deployment?"

StatefulSets give stable identities and storage for stateful apps like databases.

"What's a namespace?"

A logical partition in a cluster for organising and isolating resources.

Table: A first-90-days plan (editorial guidance)

Learn how clusters and deployments work in your organisation. Fix basic hygiene — requests, limits and probes — across key services. Then deliver a security or autoscaling improvement with clear results.

AI and machine learning workloads increasingly run on Kubernetes, bringing GPU scheduling, large images and bursty batch jobs. Platform teams are adapting autoscaling and cost controls for them. AI assistants also help write manifests and diagnose errors, but they can suggest outdated APIs or insecure settings. Engineers who understand core concepts can use AI to move faster safely.

Install kind or minikube and deploy a small app with a database. Write manifests by hand, then convert to Helm. Break things deliberately: wrong image tag, missing ConfigMap, failing probe, insufficient memory. Use kubectl describe, logs and get events to diagnose. Add an ingress, an autoscaler and a network policy. Document each exercise. Hands-on troubleshooting stories are what interviewers want to hear.

"Every app needs Kubernetes." Simple apps often run better on managed services.

"Kubernetes makes apps reliable automatically." Without probes, limits and good design, it can make problems worse.

"You must manage the control plane." Most teams use managed services.

Understanding scheduling helps you design and debug clusters. When you create a pod, the scheduler looks for a node with enough unreserved CPU and memory to meet the pod's resource requests. That's why requests matter so much: without them, the scheduler places pods blindly and nodes can become overloaded. Limits, by contrast, cap what a container can use at runtime; a container exceeding its memory limit is killed, which appears as an OOMKilled event.

You can influence placement in several ways. Node selectors and node affinity send pods to nodes with particular labels, such as GPU nodes. Taints on nodes repel pods unless the pods have matching tolerations, which is useful for dedicating nodes to specific workloads. Pod anti-affinity spreads replicas across nodes or zones so one failure doesn't take down every copy. Topology spread constraints do similar work more flexibly.

Autoscaling works at two levels. The horizontal pod autoscaler adds or removes pod replicas based on metrics such as CPU or request rate. The cluster autoscaler, or managed equivalents, adds or removes nodes when pods can't be scheduled or nodes sit idle. These work together only if requests are realistic, so measuring actual usage and tuning requests is one of the most valuable things a Kubernetes engineer can do.

When pods stay pending, kubectl describe pod usually explains why: insufficient CPU or memory, no node matching affinity rules, or unbound persistent volumes. Reading these events quickly is a core interview skill. Practise by creating pods with impossible requests or mismatched selectors in a local cluster and fixing them.

Start with RBAC: give people and service accounts only the permissions they need, scoped to namespaces where possible, and avoid cluster-admin for daily work. Apply pod security standards to block privileged containers and host access. Use network policies to restrict which pods can talk to each other. Store secrets in an external secret manager or encrypted at rest, and scan images before deployment. Keep clusters and node images updated, and audit API activity.

• No requests or limits.
• Liveness probes that kill healthy pods.
• Cluster-admin for everyone.
• Secrets in plain manifests.
• Skipping container fundamentals.

Kubernetes concepts come from its official documentation; usage from Stack Overflow's 2025 survey and the CNCF's annual survey; and India pay from AmbitionBox (read October 2026; small sample for Kubernetes engineers). The troubleshooting example, practice guidance and history are editorial. Science of Apps publishes the free test linked here. Last reviewed October 2026.

• Pod — the smallest deployable unit, running containers.
• Deployment — manages replicated pods and updates.
• Service — stable networking for pods.
• Ingress — routes external HTTP traffic.
• HPA — horizontal pod autoscaler.