Rust Developer Resume
Skills & ATS Keywords

The foundation. Name the edition outright (Rust 2021) and show you write idiomatic Rust: ownership and the borrow checker as a daily tool not a punishment, lifetimes annotated only where the compiler asks, traits and generics on the public API, error handling through Result with anyhow on the binary edge and thiserror inside libraries, pattern matching as control flow, and macros (declarative and procedural) when the duplication earned the cost. The way you talk about &mut, Box, Rc, and Arc reads as the line between someone who has shipped Rust and someone who survived the Rustlings repo once.

Rust 2021, ownership, borrow checker, lifetimes, traits, generics, Result, anyhow, thiserror, pattern matching, macros

Where a lot of the senior signal sits on a Rust resume. tokio is the runtime on the vast majority of production Rust; async-std turns up on smaller services; the differentiator is which patterns you actually shipped, futures composition with pinning where the compiler asked for it, Send plus Sync bounds you can defend out loud, structured concurrency, async traits without falling into dyn-soup, and channels (mpsc for fan-in, broadcast for pub-sub, watch for state). The line between a Junior async Rust file and a Senior one is whether you can talk about cancellation, back-pressure, and why the spawn count matters.

tokio, async-std, futures, pinning, Send/Sync bounds, structured concurrency, async traits, mpsc/broadcast/watch channels

The contract the rest of the org talks to. axum on greenfield service work (tower underneath, hyper one layer down), actix-web on the existing footprint, warp and rocket where the team picked them on purpose, tonic for gRPC on internal service-to-service traffic. OpenAPI via utoipa on public surface; async-graphql when the team committed to a GraphQL gateway. Naming the framework alone is table stakes; naming the tower middleware you wrote is the senior signal.

axum, actix-web, warp, rocket, tower, hyper, tonic for gRPC, OpenAPI via utoipa, GraphQL via async-graphql

Where the Rust file earns its premium. Zero-cost abstractions you can defend (the generic monomorphized over the box-dyn version, and why), SIMD via std::simd or packed_simd on the hot-path math, unsafe with documented safety invariants and the soundness reasoning that justifies it, FFI through bindgen or cbindgen to C and C++ neighbors, no_std and embedded-hal on the firmware-adjacent slice. criterion benchmarks held in CI, cargo-flamegraph and perf on the profile, allocator swaps (jemalloc, mimalloc) when the RSS curve asked for it.

zero-cost abstractions, SIMD, unsafe with soundness, FFI, no_std, embedded-hal, criterion, flamegraph, perf

How your service holds and queries state. sqlx with compile-time-checked queries against PostgreSQL is the modern default on async Rust services; sea-orm where the team wanted an active record style; diesel on the synchronous-or-was-already-here footprint. deadpool for the pool, redis-rs on the cache side, rdkafka for Kafka producers and consumers, lapin for RabbitMQ. serde everywhere data crosses a boundary; prost for protobuf next to tonic.

sqlx, sea-orm, diesel, PostgreSQL, redis-rs, deadpool, rdkafka, lapin, serde, prost

Show the file you actually use. cargo is the table-stakes entry; cargo-make and workspaces on real multi-crate repos; clippy and rustfmt on every PR (denied in CI, not just warned). cargo audit and cargo deny on the supply-chain gate, miri on the unsafe-touching modules, fuzzing via cargo-fuzz or AFL on the parser surface, property tests via proptest where the math earned the cost. Naming clippy alone reads junior; naming the lints you allow on purpose reads senior.

cargo, cargo-make, workspaces, clippy, rustfmt, cargo audit, cargo deny, miri, fuzzing (cargo-fuzz, AFL), proptest

How the Rust binary actually runs in production. Docker with cargo-chef on the multi-stage build, scratch or distroless on the final layer (the Rust binary earns the static-link payoff that other languages cannot pull off). AWS Lambda through cargo-lambda on event-driven serverless work, Cloudflare Workers for the edge slice. wasm-bindgen plus wasm-pack on browser modules, WASI for server-side WebAssembly. OpenTelemetry-Rust plus tracing on the observability layer; a Senior file names the span names, not just the crate.

Docker (cargo-chef multi-stage), scratch images, AWS Lambda (cargo-lambda), Cloudflare Workers, wasm-bindgen, WASI, OpenTelemetry-Rust, tracing

The lines that lift a Rust file at Senior bands. Hexagonal architecture mapped onto crate boundaries (ports as traits, adapters as binary-side modules), newtype plus type-state to push invariants into the compiler, builder pattern on the public API surface, sans-IO on the parser and protocol crates so the test story stays sane, actor model and message-passing on stateful services, idiomatic crate splits (lib, bins, integration tests in tests/) that keep compile times honest. A Staff file talks about the workspace shape and which crates have to compile in under 30 seconds.

hexagonal architecture, newtype, type-state, builder pattern, sans-IO, actor model, message-passing, idiomatic crate splits