Senior Staff Software Engineer

Responsibilities:

• Rust: Async I/O with tokio, io_uring buffer rings, and zero-copy.
• Java: Existing Apache Ozone codebase contributes upstream fixes and maintains the stable contract between Java metadata services and the Rust data plane.
• Go: Kubernetes operator built on controller-runtime, CRDs, reconcilers for StatefulSets/Deployments/PVs, init container orchestration, status conditions, and event reporting.
• Kubernetes: Persistent volumes and storage classes, pod topology and anti-affinity, Istio ambient mesh for mTLS, NetworkPolicies, node maintenance flows, rolling upgrades, and ResourceQuotas.
• Distributed Systems: Erasure coding (RS-3-2 RS-6-3 RS-10-4), Ratis consensus, container replication, block deletion at scale, scrubber and reconciliation, online/offline EC reconstruction.

What You'll Actually Do as a Builder:

• Own end-to-end implementation of major features from design spec through merged code to production validation.
• Contribute upstream to Apache Ozone for shared components.
• Build the Kubernetes-native test suite, S3 conformance, EC fault injection via pod eviction, decommission and maintenance mode flows, and bit rot detection.

As a Force Multiplier:

• Mentor engineers across the Rust, Go, and Java parts of the stack. The team has deep individual expertise but needs someone who can connect the dots between layers.
• Run rigorous technical reviews. We don't approve PRs that pass tests but skip invariant verification. We don't ship features without articulated failure modes. You will set this bar.
• Make and document architectural decisions. Not every choice has a "right" answer; what matters is that the rationale survives the engineer who made it.
• Push back on scope creep, hidden complexity, and "let's add it just in case" thinking. Three similar lines of code beat a premature abstraction.

Requirements:

• 8+ years building production distributed systems, with at least 3 years at the staff level (or equivalent). You've owned systems through architecture, implementation, on-call, and customer escalations.
• Deep expertise in at least two of Rust, Go, and Java. You don't need to be world-class in all three on day one, but you've shipped non-trivial code in multiple languages and aren't religious about which language solves a given problem.
• Strong storage or distributed systems background. You understand consensus protocols (Raft, Paxos), erasure coding tradeoffs (latency vs. durability vs. storage overhead), the cost of fsync, and why "exactly once" is a lie.
• Production Kubernetes experience. You've written operators, debugged controller reconciliation loops, traced networking issues across CNI/Istio, and understood the gap between "kubectl apply succeeded" and "the system actually works. "
• Track record of technical leadership. Design specs you've authored that others built from, architectural decisions that survived contact with reality, and PR feedback that measurably improved code.
• Comfort with ambiguity. You make progress when the spec isn't clear, upstream behavior is undocumented, and the team disagrees on the approach.

Strongly Preferred:

• Apache Ozone or HDFS experience: Direct contribution to either project or operations experience at scale (PB+). If you've debugged a Ratis pipeline issue or chased down a container replication anomaly, we want to talk.
• S3 protocol experience: You've implemented an S3-compatible server, written a SigV4 signer/verifier from scratch, or operated S3-compatible storage in production at scale.
• Performance engineering: Profiling with perf/dhat/flamegraphs, understanding memory allocator behavior, or experience with io_uring, RDMA, or other modern I/O frameworks.
• Open source contributions: Apache projects, Rust ecosystem crates (tokio, hyper, tonic), Kubernetes (kubebuilder, controller-runtime), or storage systems (RocksDB, Ceph, MinIO).
• Multi-cloud / Kubernetes distribution experience: You've shipped software for EKS, GKE, AKS, OpenShift, and on-prem K8s without special-casing each one.

You may also have:

• Erasure coding internals: ISA-L, Jerasure, or equivalent. You know what a Reed-Solomon generator matrix looks like and why CPU vectorization matters for stripe reconstruction throughput.
• Network protocol design: You've designed a wire protocol that survived real workloads. You know the difference between "gRPC streaming" and "actually achieving low latency over gRPC streaming. "
• Istio/service mesh expertise: You've debugged mTLS handshake failures, written EnvoyFilters, and understand the cost of an L7 proxy hop in the data path.