About Corvex

Corvex, Inc. (Nasdaq: MOVE) builds and operates GPU cloud infrastructure at the scale modern AI demands. We run dense accelerated-compute clusters on bare metal, stitched together with high-performance Ethernet and InfiniBand fabrics, and we deliver them to customers as reliable, secure, high-throughput platforms. We are scaling rapidly across new data center sites, and the Cloud Platform team builds the software layer that turns racks of GPU hardware into a product customers can actually consume.

The role

We are hiring a Principal Kubernetes Platform Engineer to set the technical direction for the Kubernetes layer of our cloud platform: the cluster lifecycle, fleet management, GPU-aware scheduling, and multi-tenant primitives that sit on top of our bare-metal capacity and turn it into the orchestration product our customers build on. This is a hands-on principal IC role: you own the hardest architectural decisions on the platform, and you write the code and set the standards, not just the diagrams.

This is not a day-to-day operations or on-call firefighting position. You will partner closely with our SRE team, who own production incident response and BAU operations, and with our Infrastructure Engineers, who own bare-metal provisioning and the control plane underneath Kubernetes. Your mandate is to design and build the Kubernetes platform itself: cluster provisioning and upgrades as code, the GPU operator and scheduling stack, tenant isolation, and the declarative tooling that lets us run a growing fleet without growing headcount linearly.

This role is critical for the architecture of our greenfield v2 neocloud platform: a Kubernetes native public cloud platform. You will own the recommendation and the call on the management-plane layer (we're currently in POC across different vendors) and the build-vs-buy decision that goes with it, with our Cloud Platform Architect pressure-testing it. You will drive integration across the other domains and define how clusters are templated, multi-tenanted, and handed to customers. As the most senior engineer on the Kubernetes platform, you set the standards the rest of the team builds to and are the technical authority others escalate to.

What you’ll own

• Cluster lifecycle as code. Design and operate the full lifecycle of our Kubernetes fleet: provisioning, versioning, upgrades, and decommissioning all driven declaratively (Cluster API or equivalent), so that standing up or upgrading a cluster is a reviewed change, not a manual runbook.

• Technical direction and standards. Own the patterns and standards the rest of the team builds to, and raise the technical bar through design review, mentorship, and pairing.

• The v2 platform management plane. Own the architecture of the greenfield neocloud platform: management-plane selection, build-vs-buy decisions, harden the chosen stack, define cluster templates and blueprints, and establish the patterns that let us deliver clusters as a repeatable product.

• GPU-aware scheduling. Own the GPU operator and accelerator stack on Kubernetes: device plugins, MIG and time-slicing strategy, topology-aware scheduling, and the integration points that keep NCCL/RCCL collectives and RDMA workloads performant on B300 and MI455X nodes. Our stance is whole-GPU per tenant. MIG and time-slicing are used only inside a single trusted tenant, never as a boundary between tenants.

• Multi-tenancy and isolation. Design the tenancy model: namespace and virtual-cluster isolation, RBAC, resource quotas, and network policy letting multiple customers safely share or carve up GPU capacity across clusters.

• Confidential-compute-ready platform (growth area): Design the tenancy and scheduling so it fits our confidential-compute roadmap: whole-GPU per tenant, Confidential Containers on Kubernetes, and TDX with GPU passthrough. Deep CC background is a plus, not a requirement.

• GitOps and platform tooling. Build the declarative delivery layer (ArgoCD/Flux, Helm, etc) and the self-service primitives like a tenant-facing lifecycle API and Terraform provider for push-button cluster create and upgrade, that turn tribal platform knowledge into reviewed, version-controlled, AI-consumable workflows.

• Platform reliability by design. Build observability, guardrails, and progressive-rollout mechanisms into the platform from the start, with GPU-health signals like XID and DCGM feeding automated cordon, drain, and remediate, so reliability is built into the system rather than something the on-call rotation defends.

What we’re looking for

Required

• 10+ years in infrastructure, platform, or production engineering, with deep, hands-on Kubernetes experience operating clusters at significant scale (not just deploying workloads onto someone else’s cluster).

• Demonstrated ownership of Kubernetes cluster lifecycle: provisioning, upgrades, and fleet management. Ideally managed declaratively with Cluster API, kubeadm, or a comparable approach.

• Strong command of the Kubernetes internals that matter for a platform: the scheduler, admission control, CRDs and operators, RBAC, and resource management.

• Fluency with GitOps and infrastructure-as-code (ArgoCD or Flux, Helm, Terraform, openTofu) and a build-it-as-code-first instinct.

• Proficiency in Go or Python for building controllers, operators, or platform tooling, not just glue scripting.

• A platform-builder mindset: you design systems and abstractions for other engineers and customers to consume, and you care about the seams between layers.

• A track record of setting technical direction on complex platforms and bringing other engineers along, through architecture, design review, and mentorship, without relying on positional authority.

Strongly preferred

• Hands-on experience running GPU workloads on Kubernetes: the NVIDIA GPU Operator and the AMD ROCm equivalent, device plugins, MIG, time-slicing, and topology-aware or gang scheduling. for distributed training and inference.

• Experience with high-performance networking inside Kubernetes: RDMA/RoCE, GPUDirect RDMA, SR-IOV, and CNI, in partnership with a dedicated network team.

• Familiarity with DPU/SmartNIC offload in the data path (BlueField-3), and what it changes for the Kubernetes networking and isolation model.

• Experience with multi-cluster or virtual-cluster management planes: vCluster, Rafay, Spectro Cloud, Cluster API providers, or similar.

• Exposure to InfiniBand fabrics (NDR, UFM) and dense GPU server platforms (B200/B300/MI455X).

• Background in a neocloud, hyperscaler, or service-provider environment where the platform itself is the product.

How we work

We are a lean, senior team that scales capacity faster than headcount by treating automation and AI leverage as first-class infrastructure. We build the platform as code, review changes like software, and convert hard-won operational knowledge into formats both humans and coding agents can act on. We draw a clear line between building the platform and running it day-to-day: this role lives on the build side, working alongside SRE and Infrastructure peers rather than carrying the pager for routine operations. We value engineers who reduce future toil, document as they go, and make sharp, well-reasoned decisions over consensus-seeking.

AI as a force multiplier

AI-augmented operations are core to how we run, not an afterthought. We use Claude Code for platform and SRE workflows, MCP servers connected to Jira, NetBox, and Checkmk, and CLAUDE.md / AGENTS.md conventions to make our systems legible to coding agents. We expect this role to build platform tooling and abstractions with that leverage in mind — designing Kubernetes workflows, operators, and runbooks that agents can reason about and execute, so the fleet can grow without the operational load growing with it.

What success looks like

• First 30 days. You understand our current Kubernetes footprint, and the boundaries between platform, infrastructure, and SRE. You’ve formed an early point of view on the management-plane direction and shipped your first reviewed change to cluster tooling.

• First 90 days. You have driven the v2 management-plane decision to a clear, defensible recommendation, own the cluster-lifecycle architecture end to end, and have established the platform standards and review practices the team builds to.

• First 12 months. The v2 platform architecture you set is in production: standing up, upgrading, and multi-tenanting GPU clusters is a repeatable, declarative, low-touch operation, and the GPU scheduling and isolation model is solid enough that customers and internal teams build on it without thinking about the plumbing. The platform scales to new sites without a proportional increase in operational load, and the team’s technical bar has risen measurably through your influence.