Senior System Engineer

We are looking for a Senior Systems Engineer – Go & Rust to build performance-critical services and infrastructure-facing components across multiple platform initiatives within Digital Cloud Infrastructure Engineering.

The role will support initiatives including an Internal Developer Platform, cloud infrastructure, automation, Kubernetes management, and deployment orchestration. You will work on low-latency service-to-service communication using gRPC, develop performance-sensitive services in Go and Rust, and contribute to infrastructure automation.

The ideal candidate will have strong production experience with Go, Rust, gRPC, Protocol Buffers, and Kubernetes, along with a strong understanding of performance at the operating system and network layers.

• Design and implement gRPC services for low-latency, internal service-to-service communication.

• Define, evolve, and maintain Protocol Buffer schemas while ensuring backward-compatible API versioning.

• Build performance-sensitive components in Go and Rust, including data pipelines, proxies, long-running agents, and infrastructure services.

• Develop infrastructure automation integrations for internal platform tooling.

• Support Kubernetes cluster management, Git Ops synchronization, and deployment orchestration for internal developer platforms.

• Containerize applications and develop Kubernetes deployment manifests and Helm charts.

• Profile and optimize services for latency, memory consumption, throughput, and overall system performance.

• Design and implement concurrent systems using Go concurrency patterns such as go routines, channels, and context cancellation.

• Develop asynchronous Rust services using appropriate runtime frameworks such as Tokio.

• Collaborate with platform, infrastructure, backend, and Dev Ops engineers across multiple concurrent initiatives.

• Troubleshoot complex production issues across application, network, and infrastructure layers.

• Contribute to system architecture, technical design decisions, and engineering best practices.

• 6+ years of professional software/systems engineering experience.

• Strong production experience with Go (Golang).

• Hands-on working experience with Rust, including:

• Ownership and borrowing

• Lifetimes

• Error handling

• Async programming

• Tokio or another async runtime

• Strong hands-on experience with gRPC and Protocol Buffers.

• Experience designing service definitions, streaming RPCs, interceptors, and backward-compatible APIs.

• Strong understanding of Kubernetes, including:

• Deployments

• Services

• Config Maps

• Secrets

• Readiness probes

• Liveness probes

• Strong understanding of containerized application deployment.

• Ability to reason about system performance at the OS, networking, and application layers.

• Strong understanding of concurrency, distributed systems, and service-to-service communication.

• Experience working with Linux-based production environments.

• Experience with service mesh technologies such as Istio or Linkerd.

• Experience with distributed tracing and observability using Open Telemetry.

• Experience building CI/CD pipelines for multi-language projects.

• Hands-on experience with Git Ops tools such as Argo CD or Flux.

• Experience with Helm and Kubernetes automation.

• Basic PostgreSQL administration experience.

• Experience working on internal developer platforms or infrastructure automation.

• Experience with performance profiling and benchmarking tools.

• Strong systems engineering fundamentals and a performance-oriented mindset.

• Ability to work across application, infrastructure, networking, and operating system layers.

• Strong ownership of technically complex services.

• Comfortable working across multiple concurrent platform and infrastructure initiatives.

• Ability to design systems that are reliable, scalable, observable, and efficient.

• Strong problem-solving and debugging skills.

• Excellent collaboration skills across engineering and platform teams.