Why we are hiring this role

The edge is becoming the primary site of data creation — across phones, laptops, vehicles, robots, ground stations, and satellites. The databases that exist today were designed for centralized environments. They assume stable networks, abundant resources, and a single point of coordination. That model breaks at the edge.

DefraDB is our peer-to-peer document database designed from the ground up for edge-native, local-first, and distributed environments. It uses CRDTs for conflict-free replication, supports peer-to-peer synchronization, and ships with native cryptographic primitives for data privacy and governance. Our Go implementation is in production today.

Now we're building defradb.rs — a Rust implementation of DefraDB, purpose-built for the deployment environments beyond cloud-edge where Go can't follow. Phones, vehicles, embedded devices, WASM runtimes, satellites — anywhere that demands zero-cost abstractions, predictable latency, no GC pauses, and tight control over memory and binary size. The Go version is the reference. The Rust version is how we take DefraDB everywhere else.

We need engineers who build databases in Rust — not engineers who build web services that talk to them. If your Rust experience is REST APIs and microservices, this role is not the right fit.

Why this role matters

As a Database Engine Engineer (Rust), you'll be one of the foundational engineers on defradb.rs — building a Rust-native database engine for the edge environments that the Go version can't reach.

You'll make the core architectural decisions that define how this engine works: storage layout, query execution, memory management, replication, and concurrency. Every design choice you make will directly shape the performance ceiling, correctness guarantees, and deployment reach of the system. This is early-stage, high-leverage work — the kind where your fingerprints are on the architecture for years to come.

This role sits at the intersection of database internals, systems programming in Rust, and edge infrastructure. Working closely with our CTO, co-founders, and the existing DefraDB team, you'll help define what a Rust-native, edge-first database looks like in practice.

Responsibilities

• Architect and implement core database engine components in Rust — storage engine, query planner, execution engine, and indexing.
• Design memory-safe, zero-copy data paths that minimize allocation and maximize throughput on constrained hardware.
• Implement CRDT-based replication and peer-to-peer synchronization protocols in Rust.
• Build and optimize indexing structures (B-trees, LSM trees, inverted indexes) with Rust's ownership model in mind.
• Design concurrency and async I/O strategies using Rust's type system to eliminate data races at compile time.
• Profile and optimize for edge deployment targets — low memory footprints, predictable latency, minimal binary size.
• Explore WASM compilation targets for browser and embedded runtime deployment.
• Contribute to the design of a safe, ergonomic Rust API surface for defradb.rs.
• Collaborate with the Go-based DefraDB team to ensure protocol compatibility and feature parity where needed.

Requirements for the role

• Strong proficiency in Rust — not just syntax, but deep familiarity with ownership, lifetimes, trait systems, async runtimes (tokio/async-std), and unsafe Rust where justified.
• Direct experience building database internals, storage engines, query processors, or distributed systems infrastructure in Rust, C, or C++ — not building applications on top of them.
• Strong understanding of data structures and algorithms used in database systems (B-trees, LSM trees, hash indexes, skip lists, CRDTs).
• Experience designing systems for constrained environments — embedded targets, WASM, low-memory devices, or latency-sensitive workloads.
• Familiarity with Rust ecosystem tooling for systems work — serde, bytes/buf patterns, custom allocators, no_std where applicable.
• Experience with replication protocols, consistency models, or conflict resolution in distributed systems.
• Familiarity with query language design, parsing (nom, pest, or similar), or query optimization.
• Contributions to open-source Rust projects, especially in databases, storage, networking, or infrastructure (link your work).
• 5+ years building systems-level software, with meaningful time spent on database or storage engine internals.
• A first-principles mindset — you care about building foundational systems that will last decades.

Why Join Source

This is a rare opportunity to build a Rust-native database engine — informed by a production Go implementation, but purpose-built for the constrained, latency-sensitive, resource-limited environments where Rust is the only serious option.

defradb.rs is deep systems work in one of the most demanding domains in software engineering, targeting the edge environments beyond the cloud. You'll join a small, world-class team defining how data works in decentralized, privacy-preserving, edge-first environments — and you'll do it in the language best suited for the job.

If you've been waiting for the right Rust database project to go deep on, this is that moment.

• Work with a great team building the future of edge-native data infrastructure
• Keep company with leaders in edge AI/software
• Flexible work arrangement and hours
• Unlimited days off
• Great healthcare benefits
• Technology spending budget
• Competitive compensation, including equity