Rust: Markt

Stelle

eine offene Stelle, die das Qualitäts-Gate passiert hat und mindestens zwei Technologien nennt

Beobachteter Kandidat

ein Kandidat, dessen Stack diese Technologie enthält; ein Aggregat — kein einziger Datensatz verlässt den Perimeter

Matchbarer Kandidat

noch nicht gezählt

Fenster

Stellen, die zum Zeitpunkt der Erstellung des Snapshots offen waren

Junior-Stellen für Rust gibt es FAST KEINE — der Markt erwartet Erfahrung auf Systemebene in einer anderen Sprache (C++/Go/Java) + ein fertiges Rust-Pet-Projekt. Der Sprung Junior → Middle — Beherrschung von Ownership/Borrow Checker + asynchrones Tokio + Lifetimes in der Tiefe. Ein Senior verantwortet die Architektur des Rust-Service. Karriereweg: C++/Go Senior → Rust Middle in 6-12 Monaten → Senior → Tech Lead in einem Rust-Unternehmen / Systems Architect.

Top 5: rust, python, c++, kubernetes, go. Rust Edition 2021 (Pflicht) oder 2024 (modern). Tokio — dominierende Async-Runtime (90%+ der Rust-Backends). Web: Axum (modern, Tokio-nativ, wachsend 2024–2026) oder Actix-web (ausgereift, Performance-Spitzenreiter, aber komplexer). SQLx (async + SQL-Prüfung zur Kompilierzeit — dominiert modern) oder SeaORM (asynchrones ORM). PostgreSQL. Redis (redis-rs). gRPC über tonic. Kafka über rdkafka. Cargo (Pflicht — Build-System + Paketmanager). Testing: cargo test + cargo-nextest (schneller) + cargo-tarpaulin (Coverage). Crate tracing + OpenTelemetry Rust SDK. Docker + Kubernetes. Kenntnis von Ownership/Borrow Checker + Lifetimes + Grundlagen von async/await — Pflicht für Senior. Profiling über cargo-flamegraph oder perf.

Rust gewinnt: (1) Speichersicherheit ohne GC + Zero-Cost-Abstraktionen — die beste Kombination für performance- und sicherheitskritische Systeme. (2) Tools auf Systemebene (CLI-Tools, Datenbanken, Betriebssystem-Tools — Linkerd, Stalwart, SurrealDB). (3) Blockchain (Solana, Substrate, Move) — gut bezahlte Nische. (4) Embedded/IoT mit no_std (Firmware). Go: Cloud-native + k8s, schnellere Kompilierung, einfachere Einstellung. C++: Legacy, Game Engines, Ultra-Performance im HFT (Mikrosekunden). Rust ersetzt C++ in neuen Systemprojekten. Strategie: zuerst Go für eine Cloud-native-Karriere (Marktgröße), dann Rust für die gut bezahlte Nische. C++ → Rust — ein natürlicher Übergang (~3-6 Monate).

Axum — modernes Tokio-natives Framework (von den Maintainern von tokio-rs), dominiert 2024–2026. Middleware auf Basis von Tower, hervorragende Typsicherheit über Extractors, integriert das gesamte Tokio-Ökosystem. Wachsender Trend. Actix-web — Performance-Spitzenreiter in Benchmarks (TechEmpower), ausgereiftes Ökosystem seit 2017. Einfluss des Aktorenmodells. Höhere Komplexität durch Aktoren. Rocket — deklarativ im Stil von Spring. Nachteile: nicht Tokio-nativ (eigene Runtime), langsamere Verbreitung. Strategie: zuerst Axum (modern + dominiert Tokio 2024–2026), Actix-web für Legacy + performancekritische Fälle, Rocket nur, wenn der deklarative Stil passt.

Ja, 53% der Rust-Stellen sind vollständig remote oder hybrid. Die Rust-Community ist sehr remote-freundlich. JetBrains SPb (RustRover) — überwiegend Büro. Internationale Rust-Firmen — vollständig remote: Cloudflare, Discord, 1Password, Figma, Linkerd, Rust-Teams von AWS, Vercel. Relokations-Hubs: Berlin, Amsterdam, Zürich (Rust-freundliches Europa), Dubai, Lissabon, Serbien. Englisch — Pflicht für internationale Remote-Arbeit mit einem Aufschlag von +30-50% (riesiger Rust-Remote-Markt in den USA + EU).

Rust Backend — serverseitige Entwicklung: REST/gRPC API, Geschäftslogik, DB, asynchrone I/O. Stack: Tokio + Axum + SQLx + PostgreSQL. Rust Blockchain — Smart Contracts auf Solana (Framework Anchor), Chains auf Basis von Substrate (Polkadot, Kusama). Ein anderes Paradigma: deterministische Ausführung, Gas-Optimierung, Sicherheitsdenken. Siehe /research/blockchain. Rust Embedded — IoT/Firmware mit no_std (ohne Standardbibliothek), Mikrocontroller. Stack: embedded-hal + Framework RTIC. Eine Nische, eine eigene Karriere. Der Wechsel von Rust Backend → Blockchain gelingt in 6-12 Monaten. Rust Backend → Embedded erfordert ein Umlernen auf systemnahes Denken (keine Heap-Allokation).

Backend-Erfahrung ab Middle+ vorausgesetzt (Go/Java/C++/Python). Roadmap: 1) Rust-Syntax — „The Rust Programming Language“ (offizielles Rust-Buch — kostenlos), „Programming Rust“ Blandy/Orendorff. 2) Ownership + Borrow Checker + Lifetimes — der schwierigste Teil, braucht 2-3 Monate Praxis. „Rust by Example“, Übungen mit Rustlings. 3) Async Rust — „Asynchronous Programming in Rust“ + Tokio Tutorial. 4) Cargo + Paketverwaltung. 5) SQLx — asynchroner Datenbankzugriff + SQL-Prüfungen zur Kompilierzeit. 6) Axum — offizielles Tutorial + ein Pet-Projekt (REST-API mit Auth + SQLx + PostgreSQL + Docker). 7) gRPC über tonic. 8) tracing + Observability. 9) Durchgängiges Pet-Projekt: Axum-REST-API + SQLx + PostgreSQL + Redis + Kafka-Producer + Docker + GitHub Actions. Kurse: Karpov.Courses, OTUS „Rust Developer“, Rust Bootcamp (Letsgetrusty auf YouTube — das beste kostenlose Angebot), Zero to Production in Rust (Pollak) — Pflichtlektüre. Backend Middle (Go/Java/C++) → Rust Middle — 6-12 Monate wegen eines entscheidenden Umdenkens beim Ownership.

111 active open Rust Backend positions — niche, but the fastest-growing segment. Geography: the US, Russia, the UK. 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).

Ein Senior Rust Backend verantwortet den gesamten Zyklus + systemisches Denken. Rust-Kern: Beherrschung von Ownership und Borrow Checker, Lifetimes (einschließlich HRTB), fortgeschrittene Traits (Associated Types, Trait Objects vs. Generics, Sealed Traits), unsafe Rust + UCG-Regeln, Muster der Fehlerbehandlung (thiserror/anyhow/snafu). Async Rust: tiefe Kenntnis der Tokio-Interna (Executor-Modell, Work-Stealing-Scheduler), pin/unpin für selbstreferenzielle Futures, Traits AsyncRead/AsyncWrite, Cancellation Safety. Architektur: Dienste auf Axum + tower-Middleware, gRPC-Microservices über tonic, Event Sourcing über Kafka. Performance: Profiling über cargo-flamegraph/perf, Hot Paths ohne Allokationen, Async-Fairness. PostgreSQL: fortgeschrittenes SQL, Prüfungen zur Kompilierzeit mit SQLx, Tuning des Connection Pools. Cargo: Workspaces, eigene Build-Skripte, bedingte Kompilierung über Features. Testing: cargo-nextest, eigenschaftsbasiert über proptest. DevOps: Docker-Multi-Stage-Builds (Rust-Binärdateien oft 5-20 MB), Kubernetes-Grundlagen. Soft Skills: Code Review, Mentoring (die Lernkurve von Rust ist steil). Englisch ab Senior+ PFLICHT — die Rust-Community ist überwiegend englischsprachig.