Senior Software Developer, Rust

We’re introducing Rust where correctness, performance, and reliability truly matter.

Narvar is Growing! Narvar is a multi-language platform, and we’re intentional about where we apply Rust. We’re looking for senior engineers to help us bring Rust into the backbone of the system — the parts that must be fast, safe, and correct under real-world scale.

This role is for engineers who want agency: people who enjoy identifying the right problems, choosing the right tools, and owning systems end-to-end. You won’t be handed a narrow ticket queue. You’ll help decide what gets built and how it should be built.

Day-to-day

Design and build high-correctness Rust services that sit on critical platform paths

Introduce Rust into areas where safety, determinism, and performance are essential

Own systems from architecture → implementation → rollout → operations

Make real decisions around concurrency, async boundaries, data integrity, and failure modes

Work across service boundaries in a polyglot environment (Rust alongside other stacks)

Collaborate with product, design, and frontend engineers to build systems that are technically sound and product-aware

Improve reliability, observability, and system behavior through design, not just patching

Mentor other engineers and raise the bar on system quality and ownership

What We’re Looking For

We care more about judgment and ownership than credentials.

You’re likely a strong fit if you:

Have built and operated distributed systems in production

Have deep hands-on Rust experience (not just experiments or side projects)

Understand where Rust shines — and where it doesn’t

Are comfortable reasoning about concurrency, async systems, and correctness guarantees

Have experience designing APIs and data contracts that evolve safely over time

Have worked with relational and/or NoSQL databases at scale

Have deployed and operated services in AWS or GCP (We are a GCP Shop though!)

Take initiative naturally and are comfortable operating with ambiguity

Communicate clearly and make tradeoffs explicit

Bonus Points

These aren’t hard requirements, but strong indicators:

You’ve worked in startup or high-ownership environments

You’ve owned systems in production, including on-call responsibility

You’re comfortable moving across the stack when needed (backend-first, full-stack aware)

You’ve influenced architecture by earning trust, not by mandate

You use modern tooling (including AI-assisted workflows) to increase leverage, not outsource thinking

(Note: we care about outcome and judgment, not how flashy your tools are.)

Why Rust at Narvar?

Because some parts of the system deserve stronger guarantees.

We use Rust where:

Bugs are expensive

Latency and throughput matter

Safety and correctness are non-negotiable

You’ll help define where Rust belongs, not just write Rust in isolation.

Why Narvar (From an Engineer’s Perspective)?

Real scale, real customers, real impacts

Startup-level ownership with platform-leve