Rust Developer

R Systems; United States; On-site; USD 130,000 - 165,000; Full time

Job summary

R Systems is seeking a skilled Rust backend engineer to design, build, and operate production-grade Rust services end-to-end. You will own cloud GraphQL features, implement async-graphql schemas, and manage SQL migrations against PostgreSQL, while ensuring robust, backward-compatible API surfaces.

You will work on async, concurrent Rust systems with Tokio, and collaborate across gRPC/Protobuf boundaries, contributing to shared crates and media/transport capabilities as needed.

Qualifications

• Proficient in production Rust, ownership, borrowing, lifetimes, and a strong type system.
• Strong async Rust experience with tasks, channels, streams, and concurrency reasoning.
• Experience designing/operating backend services and APIs (HTTP/GraphQL/gRPC).
• Production experience with PostgreSQL and raw SQL, including schema design and migrations.
• Solid grasp of auth fundamentals (OAuth2/JWT) and access control (RBAC).
• Comfort with Docker, CI/CD, and cloud infrastructure in a large codebase.

Responsibilities

• Design, build, and ship Rust services end-to-end—from Postgres schemas to GraphQL and gRPC APIs.
• Own cloud GraphQL features: async-graphql schemas, resolvers, and related migrations.
• Build async, concurrent systems with Tokio and ensure production observability.
• Work across gRPC/Protobuf boundaries (Tonic/Prost) and maintain backward compatibility.
• Contribute to shared crates and extend media/transport/streaming capabilities as needed.
• Collaborate on cross-language FFI and keep changes narrow and well-tested.

Skills

Rust production

Async Rust (Tokio)

Backend services & APIs

PostgreSQL & SQL

OAuth2 / JWT / RBAC

CLI & cloud-native workflows

Job description

What you'll doDesign, build, and ship production Rust services end-to-end — from Postgres schema and migrations up through GraphQL and gRPC APIs — for tens of thousands of users, with care for backwards compatibility and gated rollout of behavior changes.

About the Role

Own features in our cloud GraphQL API: async-graphql schema and resolvers, sqlx queries and migrations (raw, compile-checked SQL — no ORM), relationship-based authorization (Ory Keto), search (Meilisearch), and messaging (NATS/JetStream).

What you'll do

• Design, build, and ship production Rust services end-to-end — from Postgres schema and migrations up through GraphQL and gRPC APIs — for tens of thousands of users, with care for backwards compatibility and gated rollout of behavior changes.
• Own features in our cloud GraphQL API: async-graphql schema and resolvers, sqlx queries and migrations (raw, compile-checked SQL — no ORM), relationship-based authorization (Ory Keto), search (Meilisearch), and messaging (NATS/JetStream).
• Build and evolve async, concurrent systems with Tokio — services, background workers, and streaming APIs — that stay correct under load and observable in production.
• Work across gRPC / Protobuf service boundaries (Tonic/Prost), treating published surfaces as backwards-compatibility contracts.
• Contribute to shared foundational crates with wide blast radius, keeping changes narrow and well-tested.
• Extend Strada's peer-to-peer architecture — iroh/QUIC transport, WebRTC signaling, TURN, NAT traversal — where media transfers directly between machines.
• Depending on your interests and the team's needs, go deep on the GStreamer media pipeline (custom elements, pro codecs, low-latency streaming) or the cloud and data plane (API, storage, search, auth).
• Instrument everything (OpenTelemetry, Datadog, Prometheus) and take part in CI/CD on AWS EKS (Terraform/Terragrunt, GitHub Actions).

What you bring

Must-have (core, non-negotiable)

• Strong production Rust — ownership, borrowing and lifetimes, traits, error handling, and a type system used well.
• Solid async Rust (Tokio or equivalent): tasks, channels, streams, cancellation, and reasoning clearly about concurrency correctness.
• Experience designing and operating backend services and their APIs (HTTP / GraphQL / gRPC).
• Production experience with relational databases and SQL (PostgreSQL preferred), including schema design and migrations — comfortable with raw SQL, not just an ORM.
• A solid grasp of auth fundamentals — OAuth2 / JWT, and RBAC or relationship-based access control.
• At home in a command-line, cloud-native workflow (Docker, CI/CD, some cloud infrastructure exposure), collaborating and reviewing code in a sizable codebase.

Where you could make a big impact

These are areas you can own and go deep on — any one is a way to have outsized impact, and a couple can be a specialty in their own right.

• Real-time and networking systems — WebRTC (SDP/ICE/TURN), QUIC, NAT traversal, or libraries like iroh.
• Media and streaming — GStreamer, professional video codecs (ProRes, RED R3D, Blackmagic RAW), AVFoundation / VideoToolbox, low-latency pipelines.
• Systems-level / OS work — daemons and background services (launchd / Windows services), Unix domain sockets and named pipes, virtual filesystems (NFS / FSKit / WinFsp), caching, and content addressing.

Nice to have / bonus

• gRPC / Protobuf on the Rust stack (Tonic/Prost), with schema-evolution and backwards-compat discipline.
• async-graphql or other production GraphQL server experience.
• sqlx specifically (compile-time-checked queries, offline mode) and Postgres performance tuning.
• Ory (Keto/Oathkeeper) or other Zanzibar-style authorization; Auth0.
• Cross-language FFI (swift-bridge, Rust Swift/TS bindings) — handy, since our clients embed Rust.
• Nix/devenv reproducible environments and just-based task runners.
• Observability tooling (OpenTelemetry, Datadog, Prometheus/Grafana/Tempo).
• A background in film, video, or post-production, or other professional media workflows.