Senior Software Engineer

Senior Software Engineer Kubernetes Platform (Golang)

Location: Noida (on-site)
Experience: 5+ years
Team: Platform Engineering Tuner for K8s

Role Overview

CloudKeeper is building a Kubernetes optimization platform that keeps clusters running lean automatically — right-sizing workloads and managing nodes without manual intervention. Two capabilities sit at its core:

• A recommender that analyses historical workload usage and applies corrected requests / limits automatically.
• Automated node management — provisioning, consolidation, and bin-packing for efficient cluster utilisation.

This is a hands-on Go controller-author role: CRDs, controllers, admission / mutating webhooks, informer and reconcile loops, and a time-series layer for percentile-based sizing.

You'll work in a small engineering team building distributed systems that integrate deeply with the Kubernetes control plane. The work rewards someone who is genuinely curious about how Kubernetes behaves under the hood and who writes production-grade Go.

Responsibilities

Workload & Node Optimization

• Build the workload right-sizing recommender — pull historical usage from the metrics pipeline (metrics-server / Prometheus) and compute corrected requests / limits using percentile / histogram methods.
• Implement safe automatic application of those corrections to live workloads — staged rollout, guardrails, and rollback so a running workload is never destabilised.
• Build node-side optimization — provisioning, consolidation, and bin-packing — for efficient cluster utilisation.

Kubernetes Platform Engineering

• Design and build controllers, operators, and CRDs in Go using controller-runtime / client-go — informer caches, reconcile loops, the object lifecycle.
• Integrate deeply with the Kubernetes API to observe and act on cluster state at scale.
• Build the backend services and APIs (REST; gRPC where an agent / control-plane split calls for it) that the platform runs on.

Architecture & Scale

• Design for multi-cluster operation at scale.
• Hold platform services to a high bar for reliability, performance, and security — especially because the platform acts on live customer clusters.
• Participate in architecture and feature design as the platform grows.

Required Skills

• Strong, production Go — you've shipped and operated real services in it.
• Deep understanding of Kubernetes internals — the controller / reconcile model, the API machinery, and the object lifecycle, not just kubectl usage.
• Hands-on experience building operators / controllers / CRDs (controller-runtime, Kubebuilder, or Operator SDK).
• Comfort with metrics / time-series data — ingesting and reasoning about historical resource usage (percentiles, histograms).
• Strong debugging and performance-optimization instincts.

Preferred Skills

• gRPC and API design for distributed / agent-based systems.
• Familiarity with VPA, Karpenter, cluster-autoscaler, or the kube-scheduler internals — a real bonus if you've read their source.
• Hands-on experience with admission / mutating webhooks and their failure modes.
• Resource scheduling, autoscaling, bin-packing, or workload-placement systems.
• Interest in the cost / efficiency side — requests/limits economics, bin-packing efficiency, node cost. This is a cost-optimization product at heart.
• Multi-cluster / multi-cloud Kubernetes.
• Cloud-native security practices.
• IaC (Terraform) and CI/CD for platform tooling.

What We Look For

• Controller-author instincts — at home in the reconcile / informer world, not just consuming the API.
• Safety and correctness when acting on live workloads — thinks in blast radius, staged rollout, and rollback before features.
• A bias for building things that run reliably without babysitting.
• Curiosity about how Kubernetes actually works under the hood.
• Comfort in a small, fast-moving team where the platform itself is still being built.
• Willingness to work on-site at our Noida office.

Technology Stack

• Languages: Go
• Platform: Kubernetes — controller-runtime, client-go, CRDs, admission webhooks
• APIs: REST; gRPC where warranted
• Optimization: VPA-style right-sizing, Karpenter-based node management
• Data: time-series / metrics (metrics-server, Prometheus)
• Cloud: AWS (initial focus)

Qualifications

• B.Tech / B.E / MCA in Computer Science, IT, or a related field.
• 5+ years building backend or infrastructure software.
• Strong experience with Kubernetes-based platforms or cloud-native systems.