R/reports/platform

This is an AI-infrastructure and platform-engineering market, not an ML-modeling one. The dominant buyer is the frontier-AI build-out: Anthropic, Deepgram, Cursor, Baseten, Crusoe, Cohere, Decagon, Harvey all hiring people to run GPU/accelerator fleets, serve inference, and provision compute. The single most repeated requirement across the entire set is operating Kubernetes at a scale where defaults break, defined as code with Terraform, on AWS (with GCP/Azure close behind). If you learn one thing deeply, make it that triad.

Concrete takeaways for navigating this market:

• The fastest path to "qualified" for the most postings is Kubernetes + Terraform + a cloud + a systems language (Go/Python/Rust). That combination alone unlocks the Cursor, Deepgram, Crusoe, Decagon, Databricks, ClickHouse, Harvey, Airtable, and Cribl roles.
• The highest-paying differentiator is GPU-cluster networking and distributed-training/inference plumbing: InfiniBand/RoCE/RDMA, NCCL, gang/topology-aware scheduling, Slurm, EFA. These appear almost exclusively at the AI-infra companies and gate the $320K-$485K Anthropic band. Rarely held, frequently asked — this is where leverage lives.
• TypeScript/Node backend is a real but separate lane (Hex, Cribl). Don't chase both; the systems-language infra lane is broader and higher-paid here.
• Bare metal and datacenter physical-layer skills (PXE/MAAS provisioning, spine-leaf, BGP, OTDR/fiber, server lifecycle, secure boot/TPM) are a rising, under-supplied niche driven by AI companies leaving pure-cloud. Anthropic, Deepgram, Baseten, Crusoe all want it.
• Cost/FinOps and multi-cloud "works identically across providers" abstractions recur as senior signals — framed as a tension to manage, not a checkbox.
• Most postings are senior/staff (5-12+ YOE). They reward ownership of a system through orders-of-magnitude growth and clear failure semantics, not feature counts. "AI-first workflow" comfort is explicitly required at Deepgram and Abnormal.

Must have

• Kubernetes, Terraform, Docker
• AWS, GCP, Azure
• Python, Go, Rust
• PostgreSQL, MySQL, Redis
• Prometheus, Grafana, Datadog
• Linux

Nice to have

• TypeScript/Node.js, C/C++, Java, Scala
• Temporal, Argo Workflows/ArgoCD, Airflow, Step Functions, BullMQ
• Slurm, Ray, Kueue, Volcano
• Cilium, Calico, eBPF, Istio/Envoy/Linkerd
• NVIDIA Triton, TensorRT, ONNX Runtime, vLLM
• InfiniBand, RDMA/RoCE, EFA, NCCL, DPDK, SR-IOV
• ScyllaDB/Cassandra, DynamoDB, Spanner, CockroachDB, TiDB, DuckDB, OpenSearch/Elasticsearch, Weaviate
• GraphQL, WebSockets, WebRTC/RTP
• Pulumi, Ansible, Helm, Kustomize, Spinnaker/Flux
• gVisor, Firecracker, Kata, V8 isolates, QEMU/KVM, Cloud Hypervisor
• Debezium (CDC), Kafka, JAX/PyTorch, CUDA

Kubernetes and orchestration

• Cluster operation at scale - scheduler internals, custom scheduling plugins, gang scheduling, topology-aware placement, preemption; control-plane scaling (apiserver, etcd, controller-manager) past default limits.
• Operators and controllers - CRDs, controller-runtime/client-go patterns, admission control, autoscaling (Karpenter, HPA/VPA), self-healing reconciliation loops.
• Multi-tenant cluster design - namespaces, RBAC and least-privilege IAM, pod security standards, node/container hardening, image provenance.

Cloud and infrastructure-as-code

• IaC discipline - reusable Terraform modules, GitOps, policy-as-code, drift reduction, reproducible/auditable deploys across environments.
• Multi-cloud and hybrid - portable abstractions across AWS/GCP/Azure and on-prem, data residency, multi-region deploys, geographic routing, failover.
• Cost and FinOps - attribution/tagging, waste identification, burstable/elastic capacity, capacity planning and forecasting, cost-vs-reliability tradeoffs.

Distributed systems and reliability

• Production reliability - SLOs/error budgets, incident response, postmortems, on-call health, runbooks, clear failure semantics.
• State and workflow - durable workflow orchestration, long-running task checkpointing/recovery/resumption, state machines, multi-stage pipelines.
• Scaling through growth - sharding, partitioning, decomposition, autoscaling, load balancing, 100x growth without rewrites.

GPU and ML systems infrastructure

• Accelerator fleets - GPU/TPU/Trainium lifecycle, driver/runtime management, health/diagnostics, MTBI, stranded-capacity reduction.
• High-performance interconnect - InfiniBand, RoCE/RDMA, EFA, NCCL/RCCL, spine-leaf fabric, collective-communication benchmarking (AllReduce/AllGather).
• Distributed training - data/tensor/pipeline parallelism, FSDP/ZeRO, distributed checkpointing, throughput/stability on multi-node clusters.
• Inference serving - request routing, continuous batching, KV/prompt caching, quantization, capacity-aware deployment scheduling, multi-accelerator serving.

Networking

• Routing and traffic - BGP/OSPF/IS-IS, anycast, VPC/Transit Gateway/peering, CDN/WAF edge, rate limiting, DDoS mitigation, load balancing.
• Protocol performance - TCP/IP, DNS, TLS, HTTP/2/3, WebSocket/WebRTC/RTP tuning for latency-sensitive media.
• Software-defined networking - CNI (Cilium/Calico), eBPF/XDP, DPDK, SR-IOV, service mesh/mTLS, SmartNIC/DPU offload.

Storage and databases

• OLTP at scale - relational schema design, query optimization, migrations, indexing, connection/replication topology, backups.
• Distributed storage - sharding, change data capture, cache invalidation, globally distributed SQL, object/block/file systems, VFS/Linux filesystems.
• Data movement - backfill, large-scale migration, streaming pipelines, consistency/correctness under load.

Low-level systems and bare metal

• Linux internals - kernel tuning, cgroups, namespaces, eBPF, IPC/shared memory, concurrency, threading, performance profiling.
• Server lifecycle - PXE/MAAS provisioning, firmware, OS image builds across thousands of hosts, secure boot/TPM/attestation, decommissioning.
• Secure execution - sandboxing (gVisor/Firecracker/Kata/WASM), virtualization (QEMU/KVM, VFIO/IOMMU passthrough), isolation and fail-safe design.

Observability and delivery

• Telemetry - metrics/logging/tracing (OpenTelemetry, Prometheus/Grafana/Datadog), drift/regression detection, query attribution, capacity forecasting.
• Progressive delivery - CI/CD pipelines, canary/blue-green, traffic shifting, automated rollback, A/B model rollouts, soak testing.

The 20% that covers 80% of postings
Kubernetes operation, Terraform/IaC, one major cloud, and one systems language appear in nearly every infra posting here. Learn these to a real operating depth (you can debug a control plane and write a controller, not just kubectl apply) before touching anything exotic.

• Kubernetes (internals, not just usage)
• Terraform
• AWS (GCP/Azure transfer)
• Go and/or Python (Rust rising fast)

Go deep here, stay broad there
Go deep on Kubernetes-at-scale and the GPU-infra plumbing — that is where the senior bar and the top pay band sit. Stay broadly aware of the specific managed databases, mesh implementations, and observability stacks; they are interchangeable and learnable on the job.

• Deep: K8s scheduler/control-plane scaling, RDMA/InfiniBand/NCCL, distributed training/inference
• Broad: Istio vs Linkerd, Prometheus vs Datadog, Spanner vs CockroachDB vs TiDB

Table-stakes vs differentiators
Table-stakes: Kubernetes, Terraform, a cloud, Linux, CI/CD, SLO/on-call literacy — expected everywhere, they get you to "not rejected," not "hired." Genuine differentiators: GPU-cluster networking, gang/topology-aware scheduling, control-plane scaling past defaults, secure sandboxing, bare-metal provisioning. These are frequently required and rarely held.

Interchangeable vs non-negotiable
Pick one from each interchangeable cluster; do not collect them. The non-negotiables repeat verbatim across companies.

• Interchangeable: GCP/Azure (if you have AWS); Calico/Cilium; Istio/Envoy/Linkerd; Pulumi/Terraform; Prometheus/Datadog; Postgres/MySQL
• Non-negotiable: Kubernetes, Terraform, Linux, a systems language

Rising vs fading
Rising: Rust as a systems language (named alongside Go/Python at Anthropic, Crusoe, Discord, LangChain, Cohere); bare-metal/datacenter build-out; durable workflow engines (Temporal recurs); agent-execution infra (sandboxing, state, tool auth). Fading relative to demand: pure cloud-only skill sets with no bare-metal or GPU exposure, and TypeScript-only backend profiles outside the few Node shops.

What's unique to this domain
The accelerator-economics problem set does not exist in generic backend work: deploys competing with live inference for the same chips, burstable training clusters, GPU interconnect topology, hardware health/MTBI, power/cooling for GPU-dense racks, dark-fiber backbones. This is the moat skill — it transfers poorly from web-scale CRUD and is exactly what the AI companies pay most for.

What transfers across role types
One investment in distributed-systems reliability + Kubernetes + IaC unlocks SRE, platform, storage, inference, and compute-infra roles simultaneously. The same résumé reads for Cursor Infrastructure, Deepgram SRE, Databricks Compute, and Decagon Core Infra.

Company-stage signals

• Frontier-AI / hyperscale (Anthropic): hyperscale operation (100+ clusters, 10K+ nodes), accelerator depth, multi-quarter cross-team leadership; pays $320K-$485K.
• Growth/unicorn AI-infra (Deepgram, Crusoe, Baseten, Cohere, Cursor): hands-on bare-metal + GPU + greenfield "build the program from zero."
• Mature/scaling SaaS (Databricks, Airtable, ClickHouse, Discord, Cribl): scale through growth, multi-tenant governance, operational excellence, lower-but-solid bands.
• Regulated/enterprise (Abnormal Fed, ClickHouse Gov): FedRAMP/SOC2/airgapped, US citizenship/PR, AWS GovCloud.

Lead with scale and ownership of a named system
The decision driver across these postings is evidence you owned a foundational system through real scale, with numbers. Put the scale and the reliability outcome on the line, not the tool list.

• Strong: "Owned Kubernetes platform across 70 clusters; led CNI migration cutting IP-rule management toil 60%."
• Weak: "Worked with Kubernetes and Terraform."

The combo that's an immediate yes
Kubernetes-at-scale + GPU/accelerator workloads + IaC. That intersection is what Anthropic, Deepgram, Crusoe, and Baseten are explicitly hunting and few candidates have.

• "Operated multi-node GPU clusters (InfiniBand/RoCE, NCCL); integrated Slurm with Kubernetes for gang-scheduled training, raising fleet utilization X%."

The "wow, that's deep" signal
Going one level below the API: scheduler internals, control-plane scaling past defaults, eBPF/kernel, or distributed checkpointing. This separates staff from senior.

• "Extended kube-scheduler with topology-aware plugins to place collective workloads across thousands of accelerators; scaled etcd/apiserver to keep p99 admission latency flat through 10x node growth."

Projects eng managers are desperate to find

• Zero-to-cluster automation: take bare metal from unprovisioned to production via PXE/IaC. Line: "Built zero-touch provisioning taking new GPU racks to scheduled capacity in under an hour."
• Capacity-aware deployment under contention: deploys sharing hardware with live traffic. Line: "Built capacity-aware rollout orchestrator cutting merge-to-prod from hours to minutes without disrupting serving."
• Self-healing fleet: detect/isolate/remediate bad hardware. Line: "Automated node health/repair raising fleet MTBI and eliminating manual draining."
• Query attribution/guardrails: instrument DB queries by service, block bad patterns pre-prod. Line: "Instrumented every query by service; gated problematic patterns in CI, cutting DB incidents X%."

What reads junior
Tool name-dropping with no scale, scope, or outcome; "used"/"helped with" phrasing; operating infra rather than building the systems that operate it.

• Junior: "Used Terraform to deploy services on AWS and monitored with Grafana."
• Senior (same work): "Owned the Terraform module library and SLO framework other teams self-serve from, cutting new-service provisioning from days to minutes across 40+ services."

Red flags that make recruiters pass

• Manual-ops framing where the postings explicitly want automation: "Manually scaled clusters and resized nodes during incidents." (They say "build autoscalers, not runbooks.")
• Breadth with no depth: a flat list of 20 tools and no system owned end-to-end.
• For AI-infra roles: zero GPU/accelerator, bare-metal, or low-latency exposure anywhere on the résumé.

Worth a differentiating deep dive
Pick one and go a level deeper than peers: GPU interconnect/NCCL tuning, K8s control-plane scaling, secure sandboxing (Firecracker/gVisor), or CDC-driven cache invalidation. A single genuinely deep area outperforms broad shallow coverage at the senior/staff bar.

Open observation
Several companies (Deepgram, Abnormal) now screen explicitly for using AI tools in your own workflow, and most disclose AI-assisted résumé screening. Make infra impact legible in plain, keyword-true language, and a line on AI-accelerated engineering (agentic workflows, AI-assisted tooling you built) is a small but real positive signal in this specific set.