Rust Engineer

A different kind of software company. A different kind of software engineer.

We build software that solves problems that matter. The kind of problems where the wrong answer means lives lost, missions failed, or opportunities missed. Our platforms process petabytes of data, coordinate responses across organizations, and help humans make better decisions when seconds count.

We're looking for Rust engineers who want to build systems that work when it matters most.

What you'll build

You'll write Rust code that runs in the most demanding environments we can imagine:

• Distributed systems that maintain consistency across continents while handling millions of operations per second
• Real-time data pipelines that ingest, transform, and analyze streams from thousands of heterogeneous sources with millisecond latency requirements
• High-performance compute engines that execute complex analytical queries across datasets too large to fit in memory
• Zero-downtime infrastructure that supports mission-critical operations where system failures have real consequences
• Secure by design systems where memory safety, type safety, and correctness aren't optional—they're requirements

You won't be building CRUD apps. You won't be adding features to a SaaS product. You'll be solving fundamental computer science problems and shipping production systems that operate at scale.

What we're looking for

You have deep systems programming experience:

• You think in terms of memory layouts, cache lines, and instruction pipelines
• You understand concurrency primitives, lock-free algorithms, and the hardware memory model
• You know when to use unsafe Rust and, more importantly, when not to
• You can debug a deadlock, optimize a hot path, or track down a memory leak

You write Rust like you mean it:

• You leverage the type system to eliminate entire classes of bugs at compile time
• You write idiomatic, zero-cost abstractions that don't compromise on performance
• You understand ownership, lifetimes, and borrowing deeply enough to design clean APIs
• You contribute to the Rust ecosystem or maintain production Rust codebases

You care about correctness:

• You write tests that actually test something
• You think about edge cases, error paths, and failure modes
• You understand that "it works on my machine" isn't good enough
• You design systems that fail gracefully and recover automatically

You work on hard problems:

• You're not satisfied with the easy solution when a better one exists
• You dig into RFCs, papers, and source code to understand how things really work
• You can explain complex technical concepts to both engineers and non-engineers
• You're intellectually curious and constantly learning

What you'll work with

Our stack is Rust-first for systems that demand performance, safety, and reliability:

• Rust for core platform services, data processing engines, and performance-critical components
• Tokio and async/await for building scalable concurrent systems
• Apache Arrow, DataFusion, and Parquet for analytical workloads
• Kubernetes, Envoy, and gRPC for cloud-native distributed systems
• PostgreSQL, S3, and distributed consensus systems for state management

You'll work alongside engineers who have built distributed databases, contributed to major open source projects, written compilers, and optimized kernels. You'll learn from people who care deeply about doing things right.