Rust: market

Vacancy

an open job that cleared the quality gate and lists at least two technologies

Observed candidate

a candidate whose stack contains this technology; an aggregate — not a single record leaves the perimeter

Matchable candidate

not counted yet

Window

jobs open at the moment the snapshot was built

Junior Rust jobs are ALMOST NONE — the market expects systems-level experience in another language (C++/Go/Java) + a ready Rust pet. Junior → Middle jump — ownership/borrow checker mastery + async Tokio + lifetimes deep. Senior owns Rust service architecture. Career flow: C++/Go Senior → Rust Middle in 6-12 months → Senior → Tech Lead at a Rust shop / Systems Architect.

Top 5: rust, python, kubernetes, c++, linux. Rust edition 2021 (must) or 2024 (modern). Tokio — async runtime dominator (90%+ of Rust backends). Web: Axum (modern, Tokio-native, growing 2024–2026) or Actix-web (mature, performance leader, but higher complexity). SQLx (async + compile-time SQL checks — modern dominator) or SeaORM (async ORM). PostgreSQL. Redis (redis-rs). gRPC via tonic. Kafka via rdkafka. Cargo (must — build system + package manager). Testing: cargo test + cargo-nextest (faster) + cargo-tarpaulin (coverage). tracing crate + OpenTelemetry Rust SDK. Docker + Kubernetes. Knowledge of ownership/borrow checker + lifetimes + async/await fundamentals — Senior must. Profiling via cargo-flamegraph or perf.

Rust wins: (1) memory safety without GC + zero-cost abstractions — the best combination for performance-critical + safety-critical. (2) System-level tooling (CLI tools, databases, OS tooling — Linkerd, Stalwart, SurrealDB). (3) Blockchain (Solana, Substrate, Move) — premium niche. (4) Embedded/IoT with no_std (firmware). Go: cloud-native + k8s, faster compile, easier hiring. C++: legacy, game engines, ultra-performance HFT (microseconds). Rust is replacing C++ in new system projects. Strategy: Go first for a cloud-native career (market size), then Rust for the premium niche. C++ → Rust — a natural transition (~3-6 months).

Axum — modern Tokio-native framework (from tokio-rs maintainers), dominates 2024–2026. Tower-based middleware, excellent type safety via extractors, integrates the whole Tokio ecosystem. Growing trend. Actix-web — performance leader in benchmarks (TechEmpower), mature ecosystem since 2017. Actor-model influence. Higher complexity due to actors. Rocket — Spring-like declarative. Downsides: not Tokio-native (own runtime), slower adoption. Strategy: Axum first (modern + Tokio dominator 2024–2026), Actix-web for legacy + performance-critical, Rocket only if the declarative style suits.

Yes, 63% of Rust jobs are full-remote or hybrid. The Rust community is very remote-friendly. JetBrains SPb (RustRover) — mostly office. International Rust shops — full-remote: Cloudflare, Discord, 1Password, Figma, Linkerd, AWS Rust teams, Vercel. Relocant hubs: Berlin, Amsterdam, Zürich (Rust-friendly EU), Dubai, Lisbon, Serbia. English — must for international remote with a premium +30-50% (huge Rust remote market in the US + EU).

Rust Backend — server-side development: REST/gRPC API, business logic, DB, async I/O. Stack: Tokio + Axum + SQLx + PostgreSQL. Rust Blockchain — smart contracts on Solana (Anchor framework), Substrate-based chains (Polkadot, Kusama). Different paradigm: deterministic execution, gas optimisation, security mindset. See /research/blockchain. Rust Embedded — IoT/firmware on no_std (without the standard library), microcontrollers. Stack: embedded-hal + RTIC framework. Niche, separate career. Career switch Rust Backend → Blockchain in 6-12 months. Rust Backend → Embedded requires re-learning systems mindset (no heap allocation).

Backend Middle+ experience assumed (Go/Java/C++/Python). Roadmap: 1) Rust syntax — "The Rust Programming Language" (official Rust book — free), "Programming Rust" Blandy/Orendorff. 2) Ownership + borrow checker + lifetimes — the hardest part, will take 2-3 months of practice. "Rust by Example", Rustlings exercises. 3) Async Rust — "Asynchronous Programming in Rust" + Tokio Tutorial. 4) Cargo + package management. 5) SQLx — async DB access + compile-time SQL checks. 6) Axum — official tutorial + one pet (REST API with auth + SQLx + PostgreSQL + Docker). 7) gRPC via tonic. 8) tracing + observability. 9) End-to-end pet project: Axum REST API + SQLx + PostgreSQL + Redis + Kafka producer + Docker + GitHub Actions. Courses: Karpov.Courses, OTUS "Rust Developer", Rust Bootcamp (Letsgetrusty YouTube — best free), Zero to Production in Rust (Pollak) — must-read book. Backend Middle (Go/Java/C++) → Rust Middle — 6-12 months due to a crucial ownership shift in thinking.

97 active open Rust Backend positions — niche, but the fastest-growing segment. Geography: Russia / remote / Germany. Sources: hh.ru, Habr Career, getmatch, Djinni, LinkedIn (huge international Rust segment), Telegram, This Week in Rust newsletter, filtra.io Rust jobs, Reddit r/rust, JetBrains.com/Careers. The real market is broader than the sample thanks to huge international remote (Cloudflare/Discord/AWS). Time to close a Senior Rust role — 6-12 weeks (longer than Go due to specificity).

A Senior Rust Backend owns the full cycle + systems mindset. Rust core: ownership/borrow checker mastery, lifetimes (including HRTB), advanced traits (associated types, trait objects vs generics, sealed traits), unsafe Rust + UCG rules, error handling patterns (thiserror/anyhow/snafu). Async Rust: deep Tokio internals (executor model, work-stealing scheduler), pin/unpin for self-referential futures, AsyncRead/AsyncWrite traits, cancellation safety. Architecture: services on Axum + tower middleware, gRPC microservices via tonic, event sourcing via Kafka. Performance: profiling via cargo-flamegraph/perf, no-allocation hot paths, async fairness. PostgreSQL: advanced SQL, SQLx compile-time checks, connection pool tuning. Cargo: workspaces, custom build scripts, conditional compilation via features. Testing: cargo-nextest, property-based via proptest. DevOps: Docker multi-stage builds (Rust binaries often 5-20MB), Kubernetes basics. Soft: code review, mentoring (Rust learning curve is steep). English for Senior+ MUST — the Rust community is predominantly English-speaking.