Kubernetes / Container: market

Vacancy

an open job that cleared the quality gate and lists at least two technologies

Observed candidate

a candidate whose stack contains this technology; an aggregate — not a single record leaves the perimeter

Matchable candidate

not counted yet

Window

jobs open at the moment the snapshot was built

Junior — typical entry: DevOps Middle with K8s exposure → Junior K8s Engineer (focus deep K8s, narrower scope). Junior → Middle jump — after the first production-scale K8s deployment + one written custom Operator. Middle → Senior — multi-cluster ownership + service mesh production setup + production-scale ops experience (nodes). Senior → Kubernetes Architect — org-wide K8s strategy + multi-cluster federation + cloud-native architecture decisions. Career flow: DevOps Middle (2-3 years) → Junior K8s (1-2 years) → Middle (2-3 years) → Senior → either Kubernetes Architect, K8s Operator developer (Go programming deep), or a move into native cloud K8s — AWS EKS / GCP GKE / Azure AKS teams.

Top 5: kubernetes, devops, cloud, ci/cd, aws. Kubernetes deep mastery: API server / scheduler / controller-manager / kubelet / etcd architecture, RBAC mastery (Roles / ClusterRoles / RoleBindings + ServiceAccount tokens), Network Policies (NetworkPolicy + Cilium CiliumNetworkPolicy), Pod Security Standards (replacing PSP since 1.25), Resource Quotas + LimitRanges, HPA / VPA / Karpenter (modern autoscaler — replaces Cluster Autoscaler in AWS context), Deployment / StatefulSet / DaemonSet / Job / CronJob patterns. Custom CRDs + Operators: Operator SDK / Kubebuilder (Go) or KOPF (Python). Designing CRDs + writing controllers + handling reconciliation loops. Helm mastery: chart authoring (templates / values.yaml hierarchies / hooks / sub-charts / dependencies), OCI registry distribution, library charts. Kustomize: overlay-based config management, alternative / complement to Helm. GitOps: ArgoCD (dominates 2026 — ApplicationSets for multi-cluster, sync waves, sync hooks, project hierarchies) or FluxCD (lightweight + Helm-native). Service mesh: Istio (most features — VirtualService / DestinationRule / EnvoyFilter mastery), Linkerd (simplest + lightweight — Rust-based control plane), Cilium (rising 2026 — eBPF-based, replaces kube-proxy + provides service mesh + Network Policies in the kernel + Hubble observability). Networking: CNI plugins deep (Calico / Cilium / Weave / Flannel — pick one deeply), Gateway API (modern replacement for Ingress — GA 2024 — HTTPRoute / Gateway / GatewayClass), Ingress controllers (NGINX Ingress / Traefik / Contour / Istio Gateway). Storage: CSI drivers mastery, OpenEBS / Longhorn / Rook/Ceph (self-hosted) + cloud CSI (EBS / Persistent Disk / Azure Disk). Observability: Prometheus Operator (kube-prometheus-stack) mastery, Grafana Loki, OpenTelemetry Collector, Jaeger / Tempo for distributed tracing. Security: OPA Gatekeeper or Kyverno (policy enforcement — Kyverno simpler, rising 2026), Falco (runtime security), Trivy + Snyk Container + Grype (image scanning), Sigstore + cosign (supply chain — image signing + verification), External Secrets Operator / Sealed Secrets / Vault integration. Workflow / orchestration: Argo Workflows mastery (DAG / step / suspended / event-driven), Argo Events, Tekton Pipelines, Knative (serverless on K8s). GPU workloads (rising 2026 for AI / ML): NVIDIA GPU Operator, MIG (Multi-Instance GPU) for GPU sharing, Kueue for job queuing, Volcano (batch scheduler). Multi-cluster: Karmada (multi-cluster orchestration), OpenChoreo, Cluster API (provisioning K8s clusters via K8s), service mesh multi-cluster (Istio ambient mesh — 2024+ multi-cluster). Languages: Go primary (K8s ecosystem). Python secondary (KOPF Operators + custom scripts).

Decision tree for container orchestration 2026: 1) Kubernetes — industry standard since 2018, dominates production container orchestration (>80% enterprise). Use case: anything beyond the simplest containerised apps + multi-cloud portability + huge ecosystem. Trade-offs: high complexity (steep learning curve + ops burden), but the market has no alternative. 2) AWS ECS (Elastic Container Service) — AWS-native, simpler than K8s. Use case: AWS-only + small team + want managed simplicity. Two flavours: ECS on EC2 (you manage nodes) or ECS Fargate (fully managed, no nodes). Fargate — best for small workloads, expensive at scale. Trade-offs: vendor lock to AWS, no multi-cloud, smaller ecosystem. 3) Docker Swarm — Docker's K8s alternative. Status 2026: dead. Docker Inc focuses on Docker Desktop + Compose. Use only for legacy maintenance. Use case: HashiCorp shop (already using Vault / Consul / Terraform) + want simpler than K8s + multi-platform (containers + VMs + Java apps + standalone binaries). Trade-offs: smaller ecosystem (though integrates with Consul mesh), less community + jobs. Niche choice. 5) Serverless (Lambda / Cloud Functions / Azure Functions) — runs functions without managing containers. Use case: event-driven workloads, sporadic traffic, simple API endpoints. Trade-offs: vendor lock, cold-start latency, 15-minute execution limits, harder debugging. 6) Cloud Run / Knative — serverless containers (best of both). Use case: containerised apps + want serverless scaling (scale-to-zero) without K8s ops burden. GCP Cloud Run — the best implementation. 7) Modern PaaS: Render, Railway, Fly.io, Heroku — fully managed deployment without infra. Use case: startups + small teams + small workloads. Default 2026 recommendations: Large enterprise + multi-cloud + future-proof → Kubernetes. AWS-only + small team → ECS Fargate (or K8s via EKS if growing). Event-driven sporadic → Serverless functions. Containerised + want serverless → Cloud Run / Knative. HashiCorp shop → Nomad. A Senior K8s Engineer must know when K8s is the wrong choice.

Reference production K8s stack 2026: 1) Cluster provisioning — managed (EKS / GKE / AKS) or Cluster API + Cluster API providers (vsphere / AWS / GCP / Azure) for self-managed. 2) CNI (Container Network Interface) — Cilium (rising — eBPF-based, replaces kube-proxy) or Calico (mature) or Flannel (simple). Cilium recommended 2026 — bonus: Hubble observability + Network Policies enforcement in the kernel. 3) Ingress / Gateway — Gateway API (modern, GA 2024 — HTTPRoute / Gateway) with implementations Cilium Gateway / Istio Gateway / Envoy Gateway / Kong Gateway. Legacy: NGINX Ingress Controller / Traefik / Contour. 4) Service mesh (optional but recommended for production): Istio (most features — ambient mesh 2024+ avoids sidecar overhead) or Linkerd (simpler) or Cilium Service Mesh (eBPF-based — no sidecars at all). 5) GitOps — ArgoCD (dominates — ApplicationSets for multi-tenancy, sync waves, hooks) or FluxCD. 6) Helm + Kustomize — manifest management. Helm for distributed packages, Kustomize for overlay-based per-env config. 7) Secrets management — External Secrets Operator (rising — pulls from Vault / AWS Secrets Manager / GCP Secret Manager / Azure Key Vault) or Sealed Secrets (for GitOps-friendly encrypted secrets). 8) Policy enforcement — Kyverno (simpler than OPA Gatekeeper, rising 2026) or OPA Gatekeeper. Enforce: required labels / image registries / resource limits / security contexts. 9) Observability — metrics: Prometheus Operator (kube-prometheus-stack) + Grafana + VictoriaMetrics / Mimir for long-term storage. 10) Observability — logs: Loki + Fluent Bit / Vector (Vector rising — Rust-based, faster). 11) Observability — traces: OpenTelemetry Collector + Jaeger or Tempo (Grafana stack). 12) Runtime security: Falco (CNCF — eBPF-based runtime threat detection) + Cilium Tetragon (eBPF security observability — newer alternative). 13) Image security: Trivy (scanning) + Sigstore cosign (signing) + admission controller verifying signatures. 14) Storage: CSI drivers — cloud-native (EBS / Persistent Disk / Azure Disk) or OpenEBS / Longhorn / Rook/Ceph for self-hosted. 15) Backup / DR: Velero (CNCF — backs up K8s resources + persistent volumes, restores to a different cluster). Optional add-ons 2026: KEDA (event-driven autoscaling), Argo Workflows (batch / pipelines), Knative (serverless on K8s), NVIDIA GPU Operator (for AI / ML workloads). A Senior K8s Engineer picks + maintains this entire stack — 15+ components.

Yes, 26% of Kubernetes Engineer jobs are full-remote or hybrid. K8s work is cloud-based standard. Outsourcers — almost always remote on US projects. Russian — hybrid or remote after probation. International tech companies — full-remote standard. Cloud-native companies (Aiven / Isovalent (Cilium) / Tigera / SUSE Rancher / Rafay) — full-remote premium. Big Tech K8s teams — hybrid standard. Relocant hubs: Poland / Germany / Canada / Serbia / Georgia / UAE. English for international K8s remote — must (CNCF community is English-speaking, KubeCon conferences in English).

Senior Kubernetes Engineer — implements + maintains K8s clusters + custom Operators. Day-to-day: writing Helm charts, debugging cluster issues, on-call rotation, performance tuning, Operator development. Programming-heavy (Go mastery for Operators). Kubernetes Architect — designs K8s strategy + multi-cluster federation + service mesh architecture + cloud-native architecture decisions. Day-to-day: ADRs writing for K8s decisions, design reviews, multi-cluster federation strategy (Karmada / OpenChoreo), service mesh choice + topology, security policy framework design, capacity planning. Less programming. Career path: Senior K8s Engineer (4-6 years) → K8s Architect → Principal K8s Architect / Cloud Native Architect. K8s Operator Developer (alternative path — programming-deep specialisation) — writes custom K8s Operators in Go. Day-to-day: Go programming + CRD design + controller-runtime + testing. Often works at product companies where K8s is the primary platform (e.g. Kubernetes-native databases — Cockroach / Yugabyte / SingleStore K8s operators, K8s-native monitoring — Datadog / Dynatrace K8s integrations). Career choice: Engineer hands-on day-to-day, Architect strategy + multi-team, Operator Developer programming-deep + product engineering.

Roadmap: 1) DevOps base solid — Linux + Docker mastery + Git + one cloud basics. 2) Kubernetes fundamentals — official Kubernetes Documentation (kubernetes.io/docs — must read full Concepts section), "Kubernetes in Action" Lukša (canonical first book), "Kubernetes Patterns" Ibryam / Roß. 3) Hands-on K8s — set up own cluster: kind (Kubernetes in Docker — for local dev), k3s (lightweight, for edge / IoT / Raspberry Pi), minikube (single-node) or cloud-managed (EKS / GKE / AKS — Free Tier eligible). Deploy real apps. 4) CKA certification (Certified Kubernetes Administrator) — must for K8s Engineer roles. Practical exam (2 hours hands-on). Resources: Killer.sh (best practice exam — included with CKA purchase), KodeKloud CKA course. 5) CKAD certification (Certified Kubernetes Application Developer) — for the developer side. 6) CKS certification (Certified Kubernetes Security Specialist) — premium specialty. 7) Helm mastery — chart authoring (templates / values / hooks / dependencies / library charts). Set up a chart repository. 8) GitOps with ArgoCD — Application + ApplicationSets + Projects + sync hooks. Set up ArgoCD on own cluster + deploy real app GitOps-style. 9) Service mesh basics — install Istio or Linkerd on own cluster, configure traffic routing + observability. 10) Custom CRDs + Operators — Go programming Backend Middle level + Operator SDK / Kubebuilder. Write a simple Operator (e.g. backup-controller for StatefulSets). 11) Observability stack — install kube-prometheus-stack + Grafana + Loki + Tempo, configure custom metrics + dashboards + alerting. 12) Security stack — install Falco + OPA Gatekeeper or Kyverno, write security policies. 13) Advanced pet project: production-grade K8s setup with all 15 stack components on own cluster — document as GitHub portfolio. 14) Contribute to open source — find good-first-issue in Kubernetes / Helm / ArgoCD / Cilium repos. CNCF community is welcoming for new contributors. RU courses: Slurm DevOps + K8s, Otus "Kubernetes Educator", Karpov.Courses K8s Track, KubeOps School. International (EN): KubeCon talks YouTube (free — must watch top 50 talks), Learnk8s (intensive courses), KodeKloud Cloud-Native Learning Path, CNCF Curriculum (free). Must-read books: "Kubernetes Up & Running" Burns / Beda / Hightower (3rd edition — the authors invented K8s), "Programming Kubernetes" Hausenblas / Stefan Schimanski (for Operator development). DevOps Middle → K8s Junior — 4-8 months.

270 active open Kubernetes Engineer positions — premium specialisation inside DevOps. Geography: Russia / Poland / remote. Time to close a Senior K8s Engineer role — 4-10 weeks (faster than SRE, but requires deep specialisation).

A Senior Kubernetes Engineer owns the full K8s ecosystem cycle + production-scale operations + technical leadership. Kubernetes mastery deep: production-scale (nodes), all controllers + API objects + admission controllers + scheduler plugins. Custom CRDs + Operators mastery: Go programming Backend Senior level + Operator SDK / Kubebuilder + controller-runtime + handling reconciliation loops + leader election + custom resource versioning + conversion webhooks. Helm mastery: chart authoring (templates / values hierarchies / hooks / sub-charts / library charts), OCI registry distribution, chart testing (helm-unittest + chart-testing). GitOps mastery: ArgoCD ApplicationSets for multi-cluster + sync waves + hooks + projects + RBAC + secrets management integration. Service mesh deep: Istio or Cilium service mesh — production setup, multi-cluster mesh, mTLS, traffic management, observability. Networking deep: CNI plugin internals (Cilium eBPF model or Calico BGP model), Gateway API mastery (HTTPRoute / Gateway / GatewayClass), Network Policies enforcement design. Security mastery: Pod Security Standards + RBAC mastery (least-privilege design), OPA Gatekeeper / Kyverno policy framework, runtime security (Falco / Cilium Tetragon), supply chain security (Sigstore + cosign + admission webhooks verifying signatures). Storage: CSI driver internals + custom CSI development if needed. Observability mastery: Prometheus Operator advanced (CRDs ServiceMonitor / PodMonitor / Probe + recording rules + federation), Grafana advanced, OpenTelemetry Collector advanced, distributed tracing across mesh. Multi-cluster mastery: Cluster API for provisioning, Karmada / OpenChoreo for federation, service mesh multi-cluster (Istio ambient mesh), DR strategies multi-cluster. GPU workloads (rising 2026 for AI / ML): NVIDIA GPU Operator advanced, MIG configuration, Kueue for job queuing, Volcano batch scheduler. System design for K8s platforms: design a multi-cluster K8s platform on whiteboard at 10,000+ node scale + multi-tenancy + multi-region. Performance optimisation: cluster benchmarking (kube-bench for CIS / kube-burner for performance), control plane tuning, etcd tuning. Programming: Go primary mastery (for Operators + custom tooling). Python secondary. Soft: ADRs writing for K8s decisions, technical writing (chart documentation + operator design docs), code review for Helm charts + Operator code, mentoring Middle K8s engineers, KubeCon presentations bonus. English for Senior+ MUST — CNCF community / docs / conferences are in English. Optional bonus: open-source contributions to Kubernetes core / Helm / ArgoCD / Cilium / Istio — sharply increase market value for Big Tech K8s teams hiring.