Rust: mercado

Vacante

un empleo abierto que superó el filtro de calidad y menciona al menos dos tecnologías

Candidato observado

un candidato cuyo stack contiene esta tecnología; es un agregado: ni un solo registro sale del perímetro

Candidato emparejable

aún no contabilizado

Ventana

empleos abiertos en el momento en que se generó el snapshot

Vacantes Junior de Rust CASI NO HAY: el mercado espera experiencia a nivel de sistemas en otro lenguaje (C++/Go/Java) + un proyecto personal en Rust listo. El salto de Junior a Middle: dominio de ownership/borrow checker + async con Tokio + lifetimes a fondo. Un Senior es responsable de la arquitectura del servicio en Rust. Trayectoria: C++/Go Senior → Rust Middle en 6-12 meses → Senior → Tech Lead en una empresa de Rust / Systems Architect.

Principales 5: rust, python, kubernetes, c++, linux. Rust edición 2021 (obligatorio) o 2024 (moderno). Tokio, dominante en async runtime (90%+ de los backends de Rust). Web: Axum (moderno, nativo de Tokio, en auge 2024–2026) o Actix-web (maduro, líder en rendimiento, pero mayor complejidad). SQLx (async + comprobaciones de SQL en tiempo de compilación, dominante moderno) o SeaORM (ORM async). PostgreSQL. Redis (redis-rs). gRPC vía tonic. Kafka vía rdkafka. Cargo (obligatorio, build system + gestor de paquetes). Testing: cargo test + cargo-nextest (más rápido) + cargo-tarpaulin (cobertura). crate tracing + OpenTelemetry Rust SDK. Docker + Kubernetes. Conocimiento de ownership/borrow checker + lifetimes + fundamentos de async/await, obligatorio para Senior. Profiling vía cargo-flamegraph o perf.

Rust gana en: (1) seguridad de memoria sin GC + abstracciones de coste cero: la mejor combinación para lo crítico en rendimiento + seguridad. (2) herramientas a nivel de sistema (herramientas CLI, bases de datos, herramientas de SO: Linkerd, Stalwart, SurrealDB). (3) blockchain (Solana, Substrate, Move): nicho premium. (4) embedded/IoT con no_std (firmware). Go: cloud-native + k8s, compilación más rápida, contratación más fácil. C++: legacy, motores de juegos, HFT de ultrarrendimiento (microsegundos). Rust está sustituyendo a C++ en los nuevos proyectos de sistemas. Estrategia: primero Go para una carrera cloud-native (tamaño del mercado), luego Rust para el nicho premium. C++ → Rust: una transición natural (~3-6 meses).

Axum: framework moderno nativo de Tokio (de los mantenedores de tokio-rs), domina en 2024–2026. Middleware basado en Tower, excelente seguridad de tipos mediante extractores, integra todo el ecosistema Tokio. Tendencia al alza. Actix-web: líder de rendimiento en benchmarks (TechEmpower), ecosistema maduro desde 2017. Influencia del modelo de actores. Mayor complejidad por los actores. Rocket: declarativo al estilo Spring. Inconvenientes: no es nativo de Tokio (runtime propio), adopción más lenta. Estrategia: primero Axum (moderno + dominador de Tokio en 2024–2026), Actix-web para código heredado + casos críticos de rendimiento, Rocket solo si te encaja el estilo declarativo.

Sí, el 57% de los empleos de Rust son full-remote o híbridos. La comunidad Rust es muy remote-friendly. JetBrains SPb (RustRover) — mayormente oficina. Las Rust shops internacionales — full-remote: Cloudflare, Discord, 1Password, Figma, Linkerd, los equipos de Rust de AWS, Vercel. Hubs de relocación: Berlín, Ámsterdam, Zúrich (UE Rust-friendly), Dubái, Lisboa, Serbia. Inglés — obligatorio para el remoto internacional con una prima +30-50% (enorme mercado remoto de Rust en EE. UU. + UE).

Rust Backend: desarrollo del lado del servidor: API REST/gRPC, lógica de negocio, BD, E/S asíncrona. Stack: Tokio + Axum + SQLx + PostgreSQL. Rust Blockchain: smart contracts en Solana (framework Anchor), cadenas basadas en Substrate (Polkadot, Kusama). Otro paradigma: ejecución determinista, optimización del gas, mentalidad de seguridad. Ver /research/blockchain. Rust Embedded: IoT/firmware en no_std (sin la librería estándar), microcontroladores. Stack: embedded-hal + framework RTIC. De nicho, una carrera aparte. El cambio de Rust Backend a Blockchain lleva 6-12 meses. De Rust Backend a Embedded exige reaprender la mentalidad de sistemas (sin asignación en el heap).

Se supone experiencia Backend Middle+ (Go/Java/C++/Python). Hoja de ruta: 1) Sintaxis de Rust: "The Rust Programming Language" (el libro oficial de Rust, gratuito), "Programming Rust" de Blandy/Orendorff. 2) Ownership + borrow checker + lifetimes: la parte más difícil, te llevará 2-3 meses de práctica. "Rust by Example", ejercicios de Rustlings. 3) Rust asíncrono: "Asynchronous Programming in Rust" + el tutorial de Tokio. 4) Cargo + gestión de paquetes. 5) SQLx: acceso asíncrono a la base de datos + comprobación de SQL en tiempo de compilación. 6) Axum: el tutorial oficial + un proyecto personal (API REST con auth + SQLx + PostgreSQL + Docker). 7) gRPC con tonic. 8) tracing + observabilidad. 9) Proyecto personal de extremo a extremo: API REST en Axum + SQLx + PostgreSQL + Redis + productor de Kafka + Docker + GitHub Actions. Cursos: Karpov.Courses, OTUS "Rust Developer", Rust Bootcamp (Letsgetrusty en YouTube, lo mejor gratuito), Zero to Production in Rust (Pollak): libro de lectura obligatoria. Backend Middle (Go/Java/C++) → Rust Middle: 6-12 meses por el cambio clave de mentalidad que exige el ownership.

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

Un Senior Rust Backend es responsable del ciclo completo + tiene mentalidad de sistemas. Núcleo de Rust: dominio del ownership/borrow checker, lifetimes (incluidos los HRTB), traits avanzados (associated types, trait objects frente a genéricos, sealed traits), unsafe Rust + reglas de la UCG, patrones de manejo de errores (thiserror/anyhow/snafu). Rust asíncrono: funcionamiento interno de Tokio a fondo (modelo de ejecutor, scheduler work-stealing), pin/unpin para futures autorreferenciales, traits AsyncRead/AsyncWrite, cancellation safety. Arquitectura: servicios sobre Axum + middleware de tower, microservicios gRPC con tonic, event sourcing con Kafka. Rendimiento: profiling con cargo-flamegraph/perf, rutas críticas sin asignaciones, equidad en async. PostgreSQL: SQL avanzado, comprobaciones en tiempo de compilación con SQLx, ajuste del connection pool. Cargo: workspaces, build scripts personalizados, compilación condicional con features. Pruebas: cargo-nextest, pruebas basadas en propiedades con proptest. DevOps: builds multietapa de Docker (los binarios de Rust suelen pesar 5-20MB), nociones de Kubernetes. Soft: code review, mentoría (la curva de aprendizaje de Rust es empinada). Inglés para Senior+ IMPRESCINDIBLE: la comunidad de Rust es mayoritariamente angloparlante.