Senior Rust Engineer

## Senior Rust Engineer Department: Engineering Location: Remote Type: Full-Time (EST Hours) ## About the Role We're looking for a Senior Rust Engineer who will be a core contributor to our platform's backend systems. This isn't a "write some endpoints" role — this is a high-impact position where you'll design, build, and evolve the critical Rust services that power our unified API platform serving enterprise customers. You'll work deep in the stack across our core API server, background job processing, caching layers, and the systems that connect thousands of third-party integrations. Our platform is built on a ~1M line Rust codebase organized as a Cargo workspace, running on the latest Rust edition (2024). The systems are async-first, performance-critical, and built for reliability at scale. We need someone who has shipped production Rust, who understands ownership and lifetimes beyond the textbook, and who knows how to build systems that are both fast and maintainable. If you love writing correct, performant code, have strong opinions about API design and error handling, and want to work on infrastructure that thousands of developers depend on, we want to talk to you. ## What You'll Own - Core API server — building and evolving our Axum-based REST API with type-safe routing, extractors, and a layered middleware stack (authentication, rate limiting, tracing, metrics, timeouts, CORS) - Background job processing — designing and maintaining our PostgreSQL-backed job queue and Redis Streams event processing system with worker pools, retry logic, and dead letter handling - Multi-tier caching architecture — working across our three-layer cache system: in-memory (Moka), shared, and distributed (Redis), with TTL-based eviction and size-based limits tuned for different data access patterns - Database layer — writing and optimizing SeaORM queries against PostgreSQL 17, authoring migrations, and maintaining 59+ table schemas that power a complex multi-tenant system - Authentication and authorization — building OAuth2 server and client flows (oxide-auth, oauth2), JWT handling, RBAC enforcement, and secure session management - Cryptography and security — implementing encryption at rest (ChaCha20Poly1305), password hashing (Argon2), HMAC-based message authentication, and secure secret management with the Secrecy crate - Observability and instrumentation — structured logging with tracing, distributed tracing via OpenTelemetry/OTLP, and Prometheus metrics with autometrics for function-level performance visibility - Third-party integration engine — building the connectors, request pipelines, and dynamic configuration (Handlebars/Tera templates) that let our platform talk to hundreds of external APIs reliably - Procedural macros and internal tooling — maintaining and extending our custom derive macros (syn, quote, proc-macro2) for error handling, code generation, and reducing boilerplate across the workspace - Payment and billing systems — Stripe integration via async-stripe for checkout, billing, products, and webhook handling ## What We're Looking For ### Must-Haves - 5+ years of professional Rust experience, with at least 2 years building and operating production systems handling real traffic - Deep async Rust expertise — you're fluent with Tokio, futures, pinning, async traits, and stream processing. You understand executor internals and know how to debug async issues - Web service development — strong experience with Axum, Actix, or similar Rust web frameworks. You've built real APIs with middleware, extractors, typed routing, and proper error responses - Database proficiency — hands-on experience with SeaORM, Diesel, or SQLx against PostgreSQL. You can write efficient queries, design migrations, and reason about connection pooling and transaction isolation - Systems design thinking — you can architect multi-service systems with clean boundaries, design cache invalidation strategies, and reason about consistency vs. availability tradeoffs - Error handling mastery — you write structured, recoverable error types using thiserror/anyhow, implement proper error chains, and understand when to propagate vs. handle. You've built custom error hierarchies for large codebases - Testing discipline — you write meaningful unit and integration tests using tools like testcontainers, wiremock, rstest, and cargo-nextest. You know how to test async code and mock external dependencies - Performance awareness — you understand zero-cost abstractions, monomorphization costs, allocation patterns, and how to profile and optimize Rust code in production - Strong fundamentals — you're comfortable with trait design, generics with complex bounds, lifetime annotations, interior mutability patterns (Arc/Mutex/RwLock), and the type system as a design tool - Bias for shipping — you write clean, idiomatic Rust without over-engineering. You know when a simple Vec beats a custom data structure, and when clone() is the right call over fighting the borrow checker ### Strong Preferences - Experience with Redis (caching, streams, pub/sub, consumer groups) - Experience writing procedural macros (syn, quote, proc-macro2) - Experience with OAuth2/OIDC flows and token management - Familiarity with OpenTelemetry, Prometheus, and distributed tracing - Experience with Stripe or similar payment platform integrations - Experience with multi-tenant SaaS architectures - Contributions to open-source Rust projects ## Who You Are - You take ownership. When you see a poorly performing query, a missing test, or a confusing API boundary, you fix it. You don't wait for a ticket. - You move fast. You understand that velocity matters. You ship well-tested code with confidence because you've built the type system and test suite to catch problems before production — not because you skip reviews. - You care about correctness. You leverage Rust's type system to make invalid states unrepresentable. You use newtypes, enums, and trait bounds to encode invariants at compile time. - You're pragmatic. You know when to reach for a macro and when