Senior Rust Developer

Job Summary

The Senior Rust Developer architects and maintains low-latency backend microservices using asynchronous frameworks (Tokio, Axum, Rocket). This engineer profiles and benchmarks bottlenecks across execution paths and database interactions, enforces idiomatic Rust patterns, integrates FFI/Wasm components, containerizes microservices with Docker/Kubernetes, and conducts technical code reviews across platform squads.

Key Roles & Operational Responsibilities

1. High-Performance Architecture & Microservices

• Systems Design: Architect, build, and maintain secure, highly concurrent, and deterministic systems microservices operating in low-latency environments.
• Framework Execution: Build scalable API schemas and distributed microservices using asynchronous web frameworks (Axum, Rocket, or Warp) powered by Tokio or async-std.
• Database & Interoperability: Integrate Rust services with relational and NoSQL databases, using Serde for high-speed data serialization and FFI/WebAssembly (Wasm) for cross-platform execution.

2. Performance Profiling & Code Health

• Bottleneck Optimization: Profile, benchmark, and optimize critical path execution, database query patterns, and memory footprints to eliminate latency.
• Memory & Lifetime Management: Enforce safe multi-threading practices, lifetime tracking, and smart pointer management (Rc, Arc, RefCell) with a zero-leak mindset.
• Code Standards: Maintain a pristine, idiomatic Rust codebase utilizing strong typing, zero-cost abstractions, and comprehensive unit/integration test suites via cargo.

3. Technical Leadership & Cross-Functional Alignment

• Squad Collaboration: Partner closely with Frontend and Platform Engineering teams to define high-performance API boundaries and cloud topologies (Docker, Kubernetes, AWS/GCP).
• Mentorship & Reviews: Lead technical code reviews, serve as an internal domain expert on Rust language features, and champion systems engineering best practices.

Foundational Capabilities & Prerequisites

Required Technical Profile & Experience

• Rust Production Baseline: Minimum of 3+ years of professional experience writing production-scale Rust, accompanied by 6+ years of general software engineering experience (e.g., C/C++, Go, or Java systems).
• Async & Concurrency Mastery: Deep practical knowledge of asynchronous programming in Rust using Tokio, async-std, or Actix, including thread-safe concurrency.
• Memory Management: Strong experience with lifetime tracking, memory optimization, and smart pointers (Rc, Arc, RefCell).
• Web Frameworks & Microservices: Proven track record building microservices with Axum, Warp, or Rocket, coupled with relational and NoSQL storage engines.
• Tooling & Cloud Tops: Practical experience with Serde, FFI, Wasm, Docker containerization, and orchestration within Kubernetes or public cloud environments (AWS/GCP).
• Time Zone Alignment: Must be based in a time zone within CET (±3 hours).
• Communication Command: Fluent written and spoken English with the confidence to lead technical discussions across remote squads.

Desired Skills

• Experience with zero-copy data architectural patterns or embedded Rust systems.
• Background in High-Frequency Trading (HFT) environments, networking protocols (gRPC, WebSockets), or blockchain/cryptographic ledgers.
• Active open-source Rust community involvement or authoring custom crates.
• Familiarity with profiling tools (gdb, valgrind, perf) and cargo utilities (cargo-expand, cargo-audit).

What Proxify Offers

• Predictable Earnings: Reliable, on-time monthly payments with flexible withdrawal options and fixed monthly compensation for matched positions.
• Work-Life Balance: Guaranteed 8-hour working days with client projects, avoiding unexpected overtime.
• Paid Time Off: Up to 24 flex days off per year without loss of pay for full-time matches.
• Seamless Process: One-time screening and contracting process unlocking multiple long-term opportunities with global companies without repeated assessments.

Skills Required:

• Computer / Software / It / Data