Job Ready

Rust hiring is smaller than Java or Python hiring, but the people reading Rust resumes are almost always engineers, and they are looking for one thing: proof that you have shipped Rust past the point where the borrow checker stops being the hard part. "Rust, Ownership, Borrowing" says you finished a tutorial. What reads as evidence is a crate other people can install, a service with tests that run in CI, and a number that shows why Rust was worth it — latency, memory, throughput.

Rust jobs split into a few tracks, and each one reads a resume for different keywords. Put the ones for your target track in the skills line and in at least one project bullet:

• Name the ecosystem, not just the language. tokio, serde, axum, sqlx, clap and criterion are the crates hiring managers expect to see. List only what you have actually used.
• Every bullet: action verb, what was built, the crates in parentheses, and a number — requests per second, memory, binary size, time saved, downloads.
• Say why Rust. One bullet that compares before and after ("replaced a Python job, runtime 40 min to 90 s") answers the question every reviewer has: do you know what Rust is for?
• Mirror the posting. If it says "async Rust services", use those words, not "Rust web programming". An ATS matches strings, not synonyms.
• Link crates.io and GitHub at the top. For Rust roles a published crate is one of the strongest signals you can send.

Then check it against a real posting instead of guessing: paste both into the ATS resume checker. It scores keyword coverage against that specific job, flags formatting that breaks parsers, and shows which lines a reviewer’s eye actually lands on.

Run the resume through this list before every application. Each item is something an ATS or a reviewer checks in the first pass, before a single repository is opened.

• Plain, single-column formatting — no tables, text boxes or icons. Parsers frequently drop content inside them.
• A skills line grouped by category (Languages · Async and web · Data · Testing and tooling · Cloud and DevOps), with Rust first if it is the job.
• At least one bullet that shows depth, not syntax: a concurrency fix, an allocation or latency improvement, an unsafe block you removed or justified, a borrow-checker redesign.
• Testing named explicitly — unit and integration tests, cargo test in CI, property tests (proptest) or fuzzing (cargo-fuzz) if you have used them.
• Tooling named: cargo clippy, rustfmt, criterion benchmarks. Rust teams treat a clippy-clean codebase as the baseline.
• Three linked projects, each with a README and a one-command build. A project that does not compile on the reviewer’s machine is a project they skip.
• The certificate with its verification ID, once, under Certifications.
• One page under five years of experience. No photo, no graphics an ATS parser was not built to read.

Rust reviewers read a portfolio the way they read a pull request: does it compile cleanly, are the ownership decisions sensible, is there a test for the hard part, and did you measure anything? One finished, production-shaped project beats five abandoned ones. Each project below maps to a large slice of real Rust postings and to specific modules of this handbook.

1. 1
   An axum + sqlx service with tests and Docker

   Pick a domain with real rules — a URL shortener with rate limits, a booking API with no double-booking, a job queue with retries. tokio and axum for HTTP, serde for JSON, sqlx against PostgreSQL with migrations and compile-time-checked queries, a custom error type that maps to proper status codes (never a panic on bad input), shared state in an Arc, and graceful shutdown. Unit tests for the rules, integration tests against a real Postgres, a multi-stage Dockerfile producing a small image, docker compose up for the app and database, and a GitHub Actions workflow running fmt, clippy and tests. Then load-test it and write down one thing you fixed. Shows: Modules 06, 10 and 12.

2. 2
   A CLI tool published on crates.io

   Something you would actually use: a log filter, a CSV or JSON transformer, a file deduplicator, a Markdown link checker. clap for arguments, buffered I/O that streams large files instead of loading them whole, clear error messages (anyhow with context in the binary, a proper error enum in the library part), useful exit codes, and tests that run the binary on sample files. Publish it with cargo publish, a README with install instructions (cargo install your-tool), and release binaries built in CI. A crate strangers can install is the most credible thing a junior Rust developer can point at. Shows: Modules 05, 06, 09 and 12.

3. 3
   A concurrent or systems project with benchmarks

   A multi-threaded file indexer, a key-value store with a write-ahead log, a TCP load balancer, a lock-free queue, or a parallel image or text processor. Use threads and channels or rayon for CPU work, tokio for network work, and put the design reasoning in the README: why this ownership shape, why this lock, why no lock. Measure with criterion benchmarks and a flamegraph, include the numbers and a paragraph on what you tried that did not help. If you use unsafe, keep it small, write a // SAFETY: comment on each block and run the tests under Miri. This is the project that separates "can write Rust" from "understands why Rust". Shows: Modules 10, 13 and the senior questions in 15.

Rust jobs are fewer than Java or Python jobs, but they are growing, they pay well, and competition per role is lower than it looks because few applicants can show real Rust work. The demand sits in a handful of places. Cloud and infrastructure companies write proxies, load balancers, storage engines, virtualisation and container tooling in Rust for memory safety without garbage-collector pauses. Developer tools and databases — build systems, language tooling, observability agents, query engines — use it for speed. Blockchain and fintech infrastructure use it for nodes, smart-contract runtimes and low-latency trading systems. Security-sensitive teams in browsers, operating systems and networking adopt it to remove whole classes of memory bugs. Embedded and automotive teams use it on microcontrollers, and WebAssembly work — edge computing, plugins, performance-heavy web apps — leans on Rust more than any other language.

Many of these roles are titled "Systems Engineer", "Backend Engineer" or "Infrastructure Engineer" with Rust in the requirements rather than the title, so search by skill as well as by title. Read a posting’s tool list as the interview syllabus and map it back to the module that covers it:

• Read the verbs. "Maintain" and "extend" mean an existing codebase, often large and async, so reading unfamiliar code and compiler errors (Module 11) is the real job. "Design", "own" and "lead" mean the senior questions in Module 15.
• Watch for the second language. "Rust and C++" means interop and a migration; "Rust and Go" usually means a platform team with both; "Rust and TypeScript" often means WebAssembly or a desktop app. The second language tells you what the team is moving from or towards.
• "Rust experience preferred" is an opening. Many teams hire strong C++, Go or Java engineers and train them in Rust. If you have that background plus the portfolio above, apply even when the posting asks for more Rust years than you have.

Match every posting against this table, then paste it with your resume into the ATS checker to see which of its tools are not on the page yet.

The Rust certification exam draws 25 questions from a bank covering Modules 01–14: 35 minutes, 70% to pass. The questions are phrased the way interviewers phrase them, and the wrong answers are the misconceptions this handbook warned about — thinking a move copies heap data, expecting a HashMap to keep order, indexing a String by position, believing a lifetime annotation makes a value live longer. Pass it and a SolutionGigs Rust Programming certificate is issued with your name, score, date and a verifiable ID.

1. 1
   Check the ticks

   The handbook landing page shows every lesson completed so far. Anything unticked in Modules 01–14 is a question you might miss — read it first.

2. 2
   Sit the exam

   Sign in with Google so the certificate carries the right name. It can be retaken; the paper is drawn fresh from the bank each time.

3. 3
   Put the certificate where it counts

   LinkedIn → Licenses & certifications, with the ID. Resume → Certifications, one line. GitHub profile README → one line with the link. The ID is what lets a recruiter verify it.

4. 4
   Then the funnel

   ATS checker against a real posting → fix the gaps it finds → apply with the portfolio repository or crates.io link in the first line of the application.

Rust rarely lives alone: services talk to databases, data platforms mix languages, and most teams hiring Rust also run code in something else. Pick the next step from the job you want, not from what is fashionable.

Keep the problem-solving muscle warm with graded problems in SQL practice — database questions appear in most backend interview loops — and revisit Module 14 and Module 15 the week before each interview.