Rust Developer Resume Examples & Free Template (PDF, Word)

Imogen’s Fastly job is already typed into this free Rust developer resume template: Tokio services, a C decoder rewrite, Wasm cold starts. Replace her crates and numbers with yours, export a PDF or .docx, then scroll on for Iris, Sadia and Gunnar’s resumes and a 6-step guide.

4.9 5.0
Preview of Imogen Halloran’s filled-in Rust Developer resume: a 5-bullet summary, 7 skills rows and Fastly bullets about Tokio, unsafe code, a C rewrite and WebAssembly startup times
Emmanuel Gendre Ex-Google recruiter / Tech resume writer Updated Free, ATS-friendly, no signup

Interactive resume template generator

Interactive Rust Developer Resume Template

Fill in the side panel, then download your resume as a PDF or a Word file.

Edits update live as you type. Toggle Edit to rewrite paper text directly.

Edit mode is on. Click anywhere on the resume to rewrite text. Side-panel placeholders still update live.

Imogen Halloran Senior Rust Developer

San Francisco, CA • imogen.halloran@gmail.com • +1 415-555-0163

Profile Summary

  • Senior Rust Developer with 10 years of experience building memory-safe networking and edge software for a global CDN and edge compute platform, specializing in async Rust services, C interop and WebAssembly runtimes.
  • Hands-on with Rust (Rust 1.99, 2024 edition), async (Tokio, Axum), interop (bindgen, C and C++), WebAssembly (Wasmtime, WASI) and observability (tracing, Prometheus).
  • Deep expertise in ownership and lifetime design, Tokio service design, unsafe code review and C-to-Rust rewrites, using benchmark-first changes and fuzzing on every parser to ship Rust that stays fast and free of memory bugs in production.
  • Works closely with edge networking, security and SRE teams and customers building on the Compute platform, in RFC reviews, incident calls and quarterly roadmap planning.
  • Mentors engineers on the borrow checker and unsafe code review, runs a fortnightly Rust office hour, and wrote the team’s unsafe code policy and crate template.

Technical Skills

Languages:
Rust 1.99, C, C++, Python, Bash
Async & Networking Crates:
Tokio, Axum, tonic, hyper, Tower, serde, reqwest
Systems & Interop:
unsafe Rust, bindgen, cbindgen, cxx, Rayon, crossbeam
Wasm & Embedded Tooling:
WebAssembly, Wasmtime, WASI, wasm-bindgen, wasm-pack
Testing & Verification:
cargo test, cargo-nextest, proptest, cargo-fuzz, Miri, loom
Profiling & Observability:
criterion, perf, cargo-flamegraph, dhat, tracing, Prometheus
Build, CI & Supply Chain:
Cargo workspaces, clippy, rustfmt, cargo-deny, cargo-semver-checks, GitHub Actions, Docker

Education

University of California, Santa Cruz B.S. in Computer Engineering
Santa Cruz, CA • Sep 2012 to Jun 2016

Work Experience

Fastly Senior Software Engineer
San Francisco, CA • Apr 2021 to Present
  • Reworked the request header types in the edge proxy’s Rust core around borrowed &str and Cow views with explicit lifetimes, replacing owned Strings and per-call clones, cutting heap allocations per request from 41 to 7.
  • Built the real-time log streaming service on Tokio and Axum with bounded mpsc channels, backpressure per destination, select! cancellation and graceful shutdown, now delivering 2.6M log lines a second with no lost batches during deploys.
  • Profiled the image optimization worker with perf, cargo-flamegraph and dhat, then moved per-request buffers into a bumpalo arena and split resizing across Rayon threads, cutting p99 latency from 212 ms to 61 ms.
  • Wrapped the C TLS session cache in a safe Rust API generated with bindgen, with a SAFETY comment on every unsafe block and Miri and AddressSanitizer runs in CI, shrinking the unsafe code the team reviews from 2,400 lines to 290.
  • Rewrote the C HPACK header decoder in Rust behind its existing C ABI with cbindgen, ran old and new decoders side by side on mirrored production traffic for 6 weeks, then deleted 14,000 lines of C with no customer-facing regressions.
  • Added proptest properties and cargo-fuzz harnesses for the URL and header parsers, plus loom models for the lock-free connection pool, which found 23 crashes and race conditions before they reached production in the first year.
  • Designed and published 3 open source crates for edge configuration and rate limiting, with small public APIs, optional features, cargo-semver-checks in GitHub Actions and examples on docs.rs, now at 45,000 downloads a month.
  • Cut cold starts for customer WebAssembly modules on Wasmtime by compiling them ahead of time at deploy and pooling instance memory, bringing instance startup from 1.7 ms to 85 microseconds across the Compute platform.
Juniper Networks Software Engineer
Sunnyvale, CA • Jul 2016 to Mar 2021
  • Optimized the session lookup path in C for the SRX firewall data plane with cache-aligned tables and fewer branches, raising throughput per core by 22%.
  • Fixed 31 use-after-free and buffer overflow bugs that AddressSanitizer found in the C++ telemetry agent, then made the case for writing the next component in Rust.
  • Wrote the team’s first Rust tool, a config diff checker built with clap and serde, which 60 engineers ran before every release.

Done editing? Download a real PDF (selectable text, ATS-friendly, US Letter) or an editable Word file if a recruiter asks for one.

About this template

A Rust Developer resume template, built by a tech recruiter.

A Rust developer writes software where speed and memory safety both matter: network proxies, databases, browser engines, command-line tools and firmware. You’ll get C-level speed without C’s use-after-free bugs, as long as you don’t fight the borrow checker. Plenty of 2026 openings are about moving legacy C and C++ into Rust, piece by piece, or compiling Rust to WebAssembly and microcontrollers.

Read 20 Rust resumes back to back and the openings blur together: memory safety, zero-cost abstractions, fearless concurrency. That’s the language’s own pitch, and everybody copies it. A Rust team wants to see what you built with it. Show them the C code you replaced, the unsafe blocks you kept small, the allocations you cut, the crates other teams depend on and the bugs your fuzzers found.

I built Imogen’s Fastly job around that kind of proof. Her 8 bullets map one to one onto what a Rust team checks, from borrow checker habits to WebAssembly startup times, and every one carries a number. After the template come Iris, Sadia and Gunnar’s resumes, then 6 steps to write a Rust Developer resume.

Is your Rust resume getting silence? Upload it below and I’ll send you a free CV review, written by me and not by a bot. I usually start with the bullets that read like chapters of the Rust Book.

Industry signal

What the market says about Rust Developer roles

Rust keeps moving deeper into software you use every day. Ubuntu 26.04 LTS came out on April 23 with sudo-rs as its default sudo and Rust coreutils underneath. Rust 1.99 followed on October 1, and you can now define C variadic functions in Rust, a gap that used to block some C rewrites. Google says memory safety bugs are down to under 20% of Android’s vulnerabilities. Companies want their C and C++ replaced, and hiring managers need people who’ve done it without breaking production.

18.0% Developers doing extensive Rust work, 2026 Stack Overflow Developer Survey 2026
$120,233 Average advertised pay, US Rust developer jobs Talent.com

Resume Samples

Rust Developer Resume Examples

I picked 3 Rust careers that look nothing alike, so you can see what each level has to prove. Hold yours up against these 3 Rust developer resume samples. Iris, the junior, swapped embedded C for Rust firmware at a Nijmegen consultancy. Sadia, the senior, owns a time series database’s write path. Gunnar, at staff level, moves Firefox’s C++ parsers into Rust. You can download each one as a PDF or a Word file, free and with no signup.

Junior Rust Developer Resume Example

A junior Rust resume doesn’t need years of Rust. It needs proof that you write it carefully: firmware or services you shipped, unsafe code you kept small and explained, and the tests or fuzzing that found bugs before a customer did.

Years of experience
5 years (2 in Rust)
Industry
Rust consultancy, embedded
Stack
RustCTokioSTM32
Download PDF Download Word

Click to download the Junior Rust Developer resume example as a PDF or a Word file. Free / No signup.

Iris Vandenberg

Junior Rust Developer

Nijmegen, Netherlands · iris.vandenberg@gmail.com · +31 6 5550 1287 · linkedin.com/in/irisvandenberg

Profile Summary

  • Junior Rust Developer with 2 years writing embedded and systems Rust for clients of a Rust consultancy, after 3 years of embedded C on industrial machine controllers.
  • Builds in Rust and C, with Embassy and embedded-hal on STM32 and nRF52 chips, Tokio for gateway services, and probe-rs and defmt for flashing and logging.
  • Strong in no_std firmware, safe wrappers over C vendor SDKs and porting C drivers to Rust, and adds proptest and cargo-fuzz tests to every parser before it ships.
  • Works with hardware engineers, client firmware teams and test technicians, and joins client design reviews in Dutch and English.
  • Co-maintains the company’s embedded Rust training exercises, published an embedded-hal sensor driver crate, and reviews pull requests from 2 interns.

Technical Skills

Languages:
Rust, C, Python, Bash
Async & Networking Crates:
Tokio, serde, postcard, rumqttc (MQTT)
Systems & Interop:
unsafe Rust, bindgen, heapless, critical-section
Wasm & Embedded Tooling:
no_std, embedded-hal 1.0, Embassy, probe-rs, defmt, STM32 and nRF52 HALs
Testing & Verification:
cargo test, defmt-test, proptest, cargo-fuzz, hardware-in-the-loop rigs
Profiling & Observability:
criterion, cargo-bloat, RTT logging, power profiler, logic analyzer
Build, CI & Supply Chain:
Cargo, clippy, rustfmt, cargo-deny, GitHub Actions, Docker
Page 2 of 2

Work Experience

Tweede golf Rust Engineer Nijmegen, Netherlands · Sep 2024 to Present
  • Wrote no_std firmware in Rust with Embassy async tasks for a client’s nRF52 battery sensor, sleeping the radio between readings and cutting average current draw from 41 to 12 microamps.
  • Ported a client’s energy meter driver from C to Rust over a bindgen wrapper of the vendor SDK, keeping unsafe at the SDK boundary, and field bug reports dropped from 9 a quarter to 1.
  • Published an embedded-hal 1.0 driver crate for a humidity sensor, with async and blocking APIs behind feature flags and examples for 2 boards, now used in 4 client projects.
  • Added proptest properties and a cargo-fuzz harness to the Modbus frame parser that 3 client projects share, finding 6 panics on malformed frames before any device shipped.
  • Built a Tokio gateway that collects device readings over MQTT with bounded channels and borrowed, zero-copy postcard decoding, handling 8,000 messages a second on a small ARM board.
Sioux Technologies Embedded Software Engineer Eindhoven, Netherlands · Aug 2021 to Aug 2024
  • Wrote C firmware for Arm Cortex-M motor controllers in industrial machines, shipped in 12,000 units across 3 customer product lines.
  • Cut boot time on a controller board from 1.9 s to 420 ms by reordering peripheral setup and moving flash checks after startup.
  • Rewrote the interrupt-driven ring buffer in Rust as a no_std side project the team adopted, removing 2 race conditions the C version had.

Education

Eindhoven University of Technology B.Sc. in Electrical Engineering Eindhoven, Netherlands · Sep 2018 to Jul 2021

Senior Rust Developer Resume Example

A senior Rust resume should put one system front and center, the one you own. I look for the async or lock-free design behind it, the profiler output that changed it, and the tests that prove it survives a crash, with the crate written into each bullet.

Years of experience
9 years
Industry
Time series databases
Stack
RustTokioApache ParquetC++
Download PDF Download Word

Click to download the Senior Rust Developer resume example as a PDF or a Word file. Free / No signup.

Sadia Rahman

Senior Rust Developer

Toronto, ON · sadia.rahman@gmail.com · +1 647-555-0184 · linkedin.com/in/sadiarahman

Profile Summary

  • Senior Rust Developer with 9 years in database and storage engines, now building the write path and compaction of a time series database, after 4 years on a C++ in-memory planning engine.
  • Builds in Rust with Tokio, Apache Arrow, DataFusion and Parquet on object storage, and reads C++ daily for the parts of the older engine still in production.
  • Strong in async and lock-free concurrency, heap profiling with dhat and heaptrack, and crash-safety testing, and backs every storage change with criterion benchmarks and fault injection.
  • Works with the query team, SRE, support engineers and enterprise customers on upgrade plans, and takes the storage on-call rotation one week in six.
  • Leads design reviews for storage RFCs, mentors 3 engineers on unsafe code review, and sends fixes upstream to Apache Arrow and DataFusion.

Technical Skills

Languages:
Rust, C++, SQL, Python, Bash
Async & Networking Crates:
Tokio, tonic, hyper, serde, object_store, futures
Systems & Interop:
unsafe Rust, cxx, bindgen, crossbeam, parking_lot, jemalloc
Wasm & Embedded Tooling:
WebAssembly, wasm-bindgen, wasm-pack
Testing & Verification:
cargo-nextest, proptest, cargo-fuzz, Miri, loom, fault injection
Profiling & Observability:
criterion, perf, dhat, heaptrack, tracing, OpenTelemetry
Build, CI & Supply Chain:
Cargo workspaces, clippy, cargo-deny, cargo-semver-checks, CircleCI, Docker
Page 2 of 2

Work Experience

InfluxData Senior Software Engineer Toronto, ON (remote) · Apr 2021 to Present
  • Rebuilt the write-ahead log in Rust on Tokio, batching writes per table through bounded channels and borrowed buffers instead of copies, raising sustained ingest to 1.4M rows a second per node.
  • Reworked Parquet compaction after dhat heap profiles showed whole files held in memory, moving to a streaming merge over Apache Arrow batches and cutting peak compactor memory from 22 GB to 5.8 GB.
  • Built a crash-injection harness with proptest-generated workloads that kills the server mid-write and checks every acknowledged row, catching 11 durability bugs before release.
  • Wrote safe Rust bindings with cxx to the C++ decoder still used for legacy files, with every unsafe call behind a checked wrapper, closing 4 crash reports in the first quarter.
  • Split the line protocol parser into its own crate and compiled it to WebAssembly with wasm-bindgen so the web UI checks writes in the browser, cutting rejected writes by 38%.
Kinaxis Software Developer Ottawa, ON · Jul 2017 to Mar 2021
  • Wrote C++ query operators for the in-memory planning database, cutting scenario recalculation for the largest customers from 14 minutes to 5.
  • Moved the snapshot file reader from C++ to Rust behind a C ABI as the team’s first Rust component, and crash reports from that code fell from 9 a year to 0.
  • Added benchmark suites to CI for the 20 most used operators, catching 12 slowdowns before customer releases.

Education

University of Waterloo B.Math. in Computer Science Waterloo, ON · Sep 2012 to Apr 2017

Staff Rust Developer Resume Example

Staff Rust resumes get read for judgment across teams. Show which C++ you chose to rewrite and why, how unsafe code stays reviewed, and which rules or shared components let other teams ship Rust without you in the room.

Years of experience
15 years
Industry
Web browsers
Stack
RustC++FirefoxWebAssembly
Download PDF Download Word

Click to download the Staff Rust Engineer resume example as a PDF or a Word file. Free / No signup.

Gunnar Hedlund

Staff Rust Engineer

Seattle, WA · gunnar.hedlund@gmail.com · +1 206-555-0158 · linkedin.com/in/gunnarhedlund

Profile Summary

  • Staff Rust Engineer with 15 years in systems and browser engineering, now moving C++ parsing code to Rust in a web browser with millions of daily users, after 7 years writing C++ for network appliances.
  • Works in Rust and C++ with cbindgen, bindgen and UniFFI at the boundary, ships to Windows, macOS, Linux and Android, and uses WebAssembly sandboxing for third-party C libraries.
  • Strong in unsafe code review, incremental C++ to Rust migration and fuzzing at scale, and picks rewrite targets from each component’s crash and security bug history.
  • Works with security engineering, release management, the Android and desktop teams and open source contributors, and writes the RFCs on how teams mix Rust and C++.
  • Co-wrote the unsafe Rust review rules 3 teams follow, mentors 6 engineers moving from C++ to Rust, and reviews cross-team designs for the platform group.

Technical Skills

Languages:
Rust, C++17, C, Python, JavaScript
Async & Networking Crates:
Tokio, serde, futures, hyper
Systems & Interop:
unsafe Rust, cbindgen, bindgen, UniFFI, cxx, Rayon
Wasm & Embedded Tooling:
WebAssembly, RLBox, wasm2c, Wasmtime, WASI
Testing & Verification:
cargo test, cargo-fuzz, libFuzzer, proptest, Miri, AddressSanitizer
Profiling & Observability:
Firefox Profiler, perf, criterion, heaptrack
Build, CI & Supply Chain:
Cargo, clippy, rustfmt, cargo-vet, cargo-deny, Taskcluster
Page 2 of 2

Work Experience

Mozilla Staff Software Engineer Seattle, WA (remote) · Mar 2019 to Present
  • Rewrote a C++ image metadata parser in Rust with 3 other engineers, keeping its C++ interface through cbindgen and shipping it behind a pref for 2 releases, which retired 11,000 lines of C++.
  • Reviewed new unsafe blocks in the media crates for 3 years and wrote the SAFETY comment rules teams now follow, cutting unsafe blocks per 10,000 lines from 31 to 9.
  • Set up cargo-fuzz and libFuzzer harnesses for the new parsers in continuous fuzzing, plus Miri runs on the FFI layer in CI, finding 40+ bugs before any reached a release build.
  • Moved 2 third-party C libraries into WebAssembly sandboxes with RLBox and wasm2c, so a memory bug in either stays inside the sandbox, at a CPU cost under 3%.
  • Designed a shared UniFFI crate that brings Rust sync code to the Android and iOS apps, replacing separate Kotlin and Swift copies and cutting sync bug reports by 45%.
F5 Networks Senior Software Engineer Seattle, WA · Aug 2011 to Feb 2019
  • Wrote packet inspection code in C++ for BIG-IP appliances handling 40 Gbps of inline traffic per box.
  • Cut per-packet CPU cost by 35% with cache-line aligned structures and by removing an allocation from the hot path.
  • Built a Tokio load generator in Rust for TLS termination tests, replacing a Python tool and raising test traffic from 2 to 18 Gbps.

Education

KTH Royal Institute of Technology M.Sc. in Computer Science Stockholm, Sweden · Aug 2006 to Jun 2011

Free resume review

A recruiter screen, but with feedback

You applied to hundreds of jobs: no result. Companies won’t give you feedback, so you’re stuck in a loop. Rejections will keep coming until you know what’s wrong.

Let’s break this cycle today!

I’ll screen your resume the same way I did at Google.

You’ll get:

  • Your resume sections and content scored.
  • A clear list of what to improve, why, and how.
  • Behind the scenes secrets on the screening process.

How I rewrite Rust Developer resumes

How to write a Rust Developer resume

Emmanuel Gendre, ex-Google recruiter

Emmanuel Gendre Ex-Google recruiter, tech resume writer

For 13 years I was the one screening resumes, many of those years at Google. These days I rewrite them, and Rust resumes share a habit I don’t see as often with other languages. The bullets describe Rust instead of the work. Ownership, traits, async, zero-cost abstractions... and you’ve no clue what the code does or who’d notice if it broke.

That’s the part I put back when a Rust developer books my tech resume writing service: the component, why it moved to Rust, what perf or cargo-fuzz turned up, and the result. If you’re doing it yourself, though, focus on these 6 steps. You’ll see Imogen’s resume in every example.

  1. Step 1 Format & layout One column, standard headings, PDF first and .docx on request. Go to step 1
  2. Step 2 Profile Summary Your Rust level, crates and strengths in 5 lines. Go to step 2
  3. Step 3 Work Experience 8 Fastly bullets mapped to the 8 Rust competencies. Go to step 3
  4. Step 4 Bullet Points Turning one HPACK rewrite into a 44-word bullet. Go to step 4
  5. Step 5 Technical Skills 7 skill rows from Rust job ads, plus 5 soft skills. Go to step 5
  6. Step 6 Keywords & Metrics Tiered Rust keywords, a JD scanner, 24 sample metrics. Go to step 6

Step 1 · Format & Layout

Rust Developer resume format and layout

Of the 6 steps, this one takes the least time, and most Rust developers have it half right already. Your file has 2 readers: a parser, then a recruiter checking your title, current employer and dates. Keep the layout simple and neither of them trips.

01ATS Compliance

ATS compliance for your Rust Developer resume

Rust teams at startups tend to use Greenhouse or Ashby, and larger companies use Workday. Each is an ATS (Applicant Tracking System), and each turns your file into structured fields long before a person reads a line. A recruiter’s later search for “Tokio” or “no_std” can only match text that parsed cleanly. I wrote about how applicant tracking systems parse resumes separately. Getting your crates in front of that search comes down to 3 rules:

The 3 rules
  1. Use a 100% text based format (no Canva!)

  2. Avoid tables, pictures, and complex structures.

  3. Use the most predictable section names, like “Profile Summary” and “Work Experience”

02Design & Layout

Rust Developer resume design and layout

I still get Rust resumes with Ferris the crab in the header and a bar chart rating “lifetimes” at 80%. Google taught me early that recruiters hate fancy designs, and that hasn’t changed. When someone has 50 resumes open, a 2-column layout with icons only makes your current employer harder to find.

That’s why the template looks deliberately dull: one column, one typeface, the section titles a recruiter expects and no side panels. Let a number like 14,000 lines of C deleted be what stands out. Starting from a blank doc instead? Here’s the spec sheet.

Layout Spec
Columns
One. No sidebars, tables, columns, pictures or tabs.
Margins
0.7 in on all four sides
Body size
10 to 11 pt
Type
One family, weight for hierarchy
Length
One page under 5 years, two after
Section order
Summary, Skills, Experience, Education
PDF

03File Format

Resume file format for your Rust Developer resume

Send PDF by default. Greenhouse and Workday extract its text without trouble, your formatting holds on any screen, and nobody can nudge your p99 numbers by accident. Keep the .docx for agency recruiters who rebrand resumes with their logo, or for the odd posting that insists on Word. For the rest (plain text, Google Docs links), read my PDF vs Word resume format comparison.

Format Guide
PDF
Your default. Layout holds, text stays selectable.
Word (.docx)
When the posting or a recruiter asks for it. Use the Word download above.
Plain text
For portals that make you paste into a box
Never
Images, scans, password-protected PDFs, shared-drive links
File name
Imogen-Halloran-Rust-Developer.pdf

Step 2 · Profile Summary

Rust Developer profile summary

C++ veterans moving to Rust often drop the summary as marketing fluff. Keep it. A recruiter’s first look lasts a few seconds and stops near the top: title, years, the type of Rust you write, a handful of crates. Get those lines wrong and the second look may never happen. Here’s how a recruiter’s 2-step resume screen works.

My test for a Rust summary is whether it clears up 3 doubts. Is this production Rust or weekend projects? Services, systems code or firmware? Can this person work with the C++ engineers whose code they’d be replacing? Imogen’s 5 bullets below each handle one part of that. My profile summary writing tips cover the general rules.

  1. 1

    Title, years and scope

    The title you’re targeting, your years of Rust (plus any C or C++ before it), what you build and where it runs. Read alone, this line should tell a recruiter your seniority and whether you’re a services, systems or embedded Rust developer.

  2. 2

    Your stack

    Rust release and edition, async runtime, web framework, binding generator and targets, under short labels like async or interop. This is often the line an ATS keyword search hits first, so copy each crate letter for letter from the ad.

  3. 3

    Domain expertise

    4 things you’d want a Rust team to hire you for (unsafe code review, C-to-Rust rewrites, Tokio service design), then how you work and what that gets the team. Recruiters tend to paste these words into their notes, so borrow them from the posting.

  4. 4

    Collaboration

    The people around your work each week (security, SRE, the owners of the C++ you’re replacing) and where you meet them: RFC reviews, incident calls, planning. Rewrites mean editing other teams’ code, so a manager checks you can keep those teams on your side.

  5. 5

    Leadership

    What you do past your own pull requests: an unsafe code policy, a crate template, office hours, thorough reviews. A junior can keep it to a few words. A senior resume with nothing here suggests someone who codes alone.

Rust Developer resume summary example, from the template above
  • Senior Rust Developer with 10 years of experience building memory-safe networking and edge software for a global CDN and edge compute platform, specializing in async Rust services, C interop and WebAssembly runtimes.
  • Hands-on with Rust (Rust 1.99, 2024 edition), async (Tokio, Axum), interop (bindgen, C and C++), WebAssembly (Wasmtime, WASI) and observability (tracing, Prometheus).
  • Deep expertise in ownership and lifetime design, Tokio service design, unsafe code review and C-to-Rust rewrites, using benchmark-first changes and fuzzing on every parser to ship Rust that stays fast and free of memory bugs in production.
  • Works closely with edge networking, security and SRE teams and customers building on the Compute platform, in RFC reviews, incident calls and quarterly roadmap planning.
  • Mentors engineers on the borrow checker and unsafe code review, runs a fortnightly Rust office hour, and wrote the team’s unsafe code policy and crate template.

Step 3 · Work Experience

Rust Developer work experience

The second read comes from the hiring manager, and it’s slower. I’ve found that 95% of their decision rests on your current or latest job, which is logical: the Rust you write today is the closest thing they’ve got to a sample of your work on their codebase.

Use it to cover the Rust Developer role profile. Think of it as a scorecard with 8 boxes, and the hiring team ticks a box only when one of your bullets proves it. No unsafe code or fuzzing on the page? Then as far as they know, you’ve never done either. Here’s my order for the 8.

Rust Developer role profile
  1. Ownership, Lifetimes & Type Design

    You design types that the borrow checker and your teammates can both live with. Code that clones everything still compiles, but it burns CPU and memory, and a reviewer will spot it in your diff in seconds. Show how you used lifetimes and Cow or newtypes to remove copies or rule out a class of bugs.

    Techniques
    borrowed views and lifetimes, Cow and newtypes, typed errors, zero-copy parsing
    Tools
    rustc, clippy, thiserror, anyhow
    Metrics
    allocations per request, clones removed, CPU per request, compile time
  2. Async Services on Tokio

    You run Tokio services that keep answering when traffic spikes. One blocking call on the executor or one unbounded channel can stall a whole service, and you can bet a Rust interviewer will dig into it. Walk them through a time Axum or tonic, plus bounded channels, kept your service up through a spike.

    Techniques
    bounded channels, backpressure, cancellation with select!, graceful shutdown
    Tools
    Tokio, Axum, tonic, Tower, tracing
    Metrics
    tail latency (p99), sustained requests a second, dropped messages, deploy errors
  3. Performance & Memory Profiling

    You measure where the time and memory go before you touch the code. Companies often pick Rust for speed, so a speed claim without a benchmark won’t convince anyone. Point out what criterion and a heap profiler showed you, and the latency or memory you cut after.

    Techniques
    benchmarking, flamegraphs, heap profiling, arena allocation
    Tools
    criterion, perf, cargo-flamegraph, dhat, Rayon
    Metrics
    p99 latency, peak memory, allocations, cost per request
  4. Unsafe Code & C/C++ Interop

    You write unsafe Rust only where it’s needed, and you can explain why it’s sound. Every unsafe block is a spot where memory bugs can come back, so security teams will read your unsafe lines closely. Explain how you used bindgen or cxx and Miri to put a safe API in front of a C or C++ library.

    Techniques
    SAFETY comments, safe wrappers, repr(C) types, panic boundaries
    Tools
    bindgen, cbindgen, cxx, Miri, AddressSanitizer
    Metrics
    unsafe lines, unsafe blocks reviewed, memory bugs, crash reports
  5. C & C++ to Rust Rewrites

    You replace C or C++ code without breaking the people who call it. A lot of Rust hiring in 2026 is for exactly this, and a failed rewrite can cost your new team a year. Describe how you used differential tests and mirrored traffic to switch over safely and delete the old code.

    Techniques
    incremental rewrites, differential testing, mirrored traffic, ABI compatibility
    Tools
    cbindgen, cargo-fuzz, feature flags, CMake and Cargo builds
    Metrics
    lines of C retired, regressions, security bugs in that code, crash rate
  6. Property Tests, Fuzzing & Miri

    You catch what the compiler lets through. Rust stops memory errors, not logic errors or panics on bad input, and a parser that panics in production is still an outage. Let them know how proptest, cargo-fuzz or Miri helped you find crashes before your users did.

    Techniques
    property testing, coverage-guided fuzzing, model checking, snapshot tests
    Tools
    proptest, cargo-fuzz, Miri, loom, cargo-nextest
    Metrics
    bugs found before release, panics fixed, flaky tests, CI time
  7. Crate Design & Publishing

    You publish crates that other people build on. A messy public API or a surprise breaking change can hold up a dozen teams, so a lead wants to see that you take semver seriously. Mention the feature flags and cargo-semver-checks gates that keep your crate stable, and how many projects pull it in.

    Techniques
    small public APIs, feature flags, semver checks, MSRV policy
    Tools
    Cargo workspaces, cargo-semver-checks, cargo-deny, docs.rs
    Metrics
    downloads, dependent crates, breaking releases, build time
  8. WebAssembly & Embedded Targets

    You ship Rust to places with no server, and sometimes there’s no operating system either. WebAssembly and embedded teams want to see that you know no_std, tight memory limits and cross-compiling. Detail how you used Wasmtime, wasm-bindgen or Embassy to get Rust running on that target, and what it improved.

    Techniques
    no_std code, ahead-of-time compilation, cross-compiling, sandboxing
    Tools
    wasm-bindgen, Wasmtime, WASI, Embassy, probe-rs
    Metrics
    cold start time, binary size, current draw, devices shipped

One tip on order inside that job: if the ad is for embedded Rust, open with the no_std bullet, and if it’s a Tokio services team, open with the async one. How to write each bullet is next, in Step 4.

Submit your resume for a free review!

Step 4 · Bullet Points

Rust Developer resume bullet points

Bullets take more of my time than the rest of a Rust resume combined, because they hold the evidence. I write them in levels, a method that grew out of Google’s XYZ formula. Each level adds what a Rust lead would ask next: the technique, the crates and tools, the method, and finally the result. My resume bullet point formula, step by step goes deeper.

Picture each level as one more question about a single change you made. Level 5 is the payoff, and on Rust work it’s usually C deleted, latency saved or crashes found. Here, an HPACK decoder rewrite starts as 8 words and ends as a full bullet.

  1. Level 1Task

    What did I do? Start with the task, in one line. It’s true, and it tells a manager nothing about how hard it was.

    Rewrote the C HPACK header decoder in Rust.

  2. Level 2+ Techniques

    How did I do it? Add your techniques. On a rewrite, a reader wants to see you didn’t just swap the code and hope.

    Rewrote the C HPACK header decoder in Rust behind its existing C ABI, running old and new side by side on mirrored traffic.

  3. Level 3+ Tools

    Which tools did I use? Write the real crate and tool names. A recruiter searching for cbindgen won’t find “FFI tooling”.

    Rewrote the C HPACK header decoder in Rust behind its existing C ABI with cbindgen and cargo-fuzz, running old and new side by side on mirrored traffic.

  4. Level 4+ Method

    What method did I follow? Say how you chose and planned the work. A rewrite picked from crash data reads like judgment, not a hobby.

    Rewrote the C HPACK header decoder in Rust behind its existing C ABI with cbindgen and cargo-fuzz, running old and new side by side on mirrored traffic, after choosing it from 3 years of crash reports.

  5. Level 5+ Metric

    What changed? End on one number you can defend, like lines deleted or bugs gone. It’s the first thing the interviewer will ask you about.

    Rewrote the C HPACK header decoder in Rust behind its existing C ABI with cbindgen and cargo-fuzz, running old and new side by side on mirrored traffic, after choosing it from 3 years of crash reports, deleting 14,000 lines of C with no regressions.

    1. 01 Task What you worked on
    2. 02 Techniques How you did it
    3. 03 Tools The stack you used
    4. 04 Method The method you followed
    5. 05 Metric The result, one number

These numbers usually exist already, spread across criterion reports, crash dashboards, the fuzzer’s crash folder and the PR that removed the C. Collect them first and write second. In the interview, “it’s in the criterion history” is a great answer to “how do you know?”

Step 5 · Technical Skills

Rust Developer resume skills

The Rust job ads I’ve read split their requirements into roughly 7 groups: languages, async and networking crates, systems and interop, Wasm and embedded, testing, profiling, and build tooling. Use the ad’s exact spelling for each crate. A recruiter searching for SQLx won’t find “compile-time checked SQL”.

Think of your skills list as a table of contents for your bullets. Put Miri there with no unsafe code anywhere in your jobs, and a manager will ask what you ran it on. First come the 7 categories with must-haves starred, then Imogen’s rows, then the soft skills I rate. Keywords get their own step next.

The 7 skill categories for a Rust Developer resume

Starred chips are the ones most Rust ads mention, and I’d start every row with them. Add a version number only when it carries weight, like embedded-hal 1.0 or the 2024 edition.

Languages

Rust goes first, with the release you build on. Most Rust ads also want C or C++, since you’ll read and call that code, and Python or Bash for scripts.

RustCC++PythonSQLTypeScriptBash

Async & Networking Crates

Tokio’s in almost every Rust services job, usually with Axum or tonic on top and serde wherever data crosses a boundary. List the crates you’ve run in production.

TokioAxumserdetonichyperTowerreqwestSQLx

Systems & Interop

This row shows you can work below safe Rust: unsafe code, bindings to C and C++ with bindgen or cxx, and parallel code with Rayon or crossbeam.

unsafe RustbindgencbindgencxxPyO3UniFFIRayoncrossbeam

Wasm & Embedded Tooling

Skip this row if the job doesn’t touch it. WebAssembly roles look for wasm-bindgen, Wasmtime and WASI, embedded ones for no_std, embedded-hal and Embassy.

WebAssemblywasm-bindgenwasm-packWasmtimeWASIno_stdembedded-halEmbassy

Testing & Verification

cargo test is a given. proptest and cargo-fuzz show you test inputs nobody thought of, and Miri or loom show you check what the compiler can’t.

cargo testproptestcargo-fuzzcargo-nextestMiriloominstaAddressSanitizer

Profiling & Observability

How you find slow or memory-hungry code and watch it in production. Interviewers like to ask about criterion and perf, and tracing is the usual crate for logs and spans.

criterionperfcargo-flamegraphdhatheaptracktracingOpenTelemetryPrometheus

Build, CI & Supply Chain

Cargo and clippy are expected, so they won’t set you apart. cargo-deny, cargo-audit and cargo-semver-checks show you care about dependencies and breaking changes, which matters once you publish crates.

Cargoclippyrustfmtcargo-denycargo-auditcargo-semver-checksGitHub ActionsDocker

A finished Rust Developer skills section

Technical Skills sample, from the template above
Languages
Rust 1.99, C, C++, Python, Bash
Async & Networking Crates
Tokio, Axum, tonic, hyper, Tower, serde, reqwest
Systems & Interop
unsafe Rust, bindgen, cbindgen, cxx, Rayon, crossbeam
Wasm & Embedded Tooling
WebAssembly, Wasmtime, WASI, wasm-bindgen, wasm-pack
Testing & Verification
cargo test, cargo-nextest, proptest, cargo-fuzz, Miri, loom
Profiling & Observability
criterion, perf, cargo-flamegraph, dhat, tracing, Prometheus
Build, CI & Supply Chain
Cargo workspaces, clippy, rustfmt, cargo-deny, cargo-semver-checks, GitHub Actions, Docker

Soft skills for a Rust Developer resume

“Team player” next to Tokio won’t sway anyone. Proof does, like the C++ owners you got on board. All 5 soft skills here come with the bullet I’d put on a Rust resume to back them up.

  • Coaching C++ engineers through their first fights with the borrow checker

    Resume bulletRan 8 lunchtime ownership workshops for C++ developers, after which 5 shipped production Rust inside a quarter.

  • Getting a component’s owners on board before rewriting it

    Resume bulletCo-wrote the HPACK rewrite RFC with the 2 teams that owned the C code, and both signed off before any Rust merged.

  • Choosing the safe version when unsafe only buys a few percent

    Resume bulletDropped an unchecked indexing trick worth 3% CPU once review showed the safe code met its latency target.

  • Writing the docs and examples before asking anyone to adopt a crate

    Resume bulletWrote a guide and 6 runnable examples before announcing the rate limiting crate, and 4 teams adopted it in a month.

  • Calling off a rewrite when the numbers don’t justify it

    Resume bulletStopped a rewrite of a C logging module with 0 bugs in 2 years, and moved the effort to the TLS cache.

Step 6 · Keywords & Metrics

Rust Developer resume keywords and metrics

Your finished resume still has 2 hurdles. The first is search: recruiters filter the ATS by words like “Rust”, “Tokio” or “WebAssembly”, so keywords decide if you appear at all. The second is the engineer on the panel, who trusts metrics over adjectives.

Next you’ll find the keywords in 3 tiers, a scanner for the ad you’re applying to, and 24 metrics written into Rust bullets, 3 for every area.

+42%

Rust Developer resume keywords, ranked

Tapping a chip shows you the wording employers tend to use. One ad says “Rust”, the next “systems programming in Rust”, so mirror whichever one you’re answering.

Must-have

8

Put each of these in your summary, a skills row and at least one bullet under your current job.

In a job description“Strong proficiency in Rust and its ecosystem”

Strong supporting

10

List the ones you’ve really used in your skills rows and back each one with a bullet.

In a job description“Design idiomatic Rust APIs with traits and generics”

Bonus

9

Add these only for ads that mention them, and only if you’ve done the work.

In a job description“Experience compiling Rust to WebAssembly (wasm-bindgen, wasm-pack)”

Extract Rust Developer keywords from a job description

Paste the Rust, systems or embedded Rust job ad you’re eyeing. The scanner pulls out every crate, tool, target and language it mentions, sorted into tiers, and you can compare that list with your skills rows line by line.

Must-have
Put these in your skills section and back each one with a bullet.
Strong supporting
Add the ones you’ve actually worked with. Skip the rest.

Nothing is uploaded: it all happens in your browser.

Metrics for a Rust Developer resume

Every area of the profile gets 3 metrics, shown in bullets from Imogen’s jobs at Fastly and Juniper. Use whichever one your dashboards can actually back up.

MetricExample bullet
Ownership & type design
Allocations per request Count Heap allocations one request makes on a hot path, from a heap profiler or a counting allocator.Moved the edge proxy’s header map to borrowed &str views with explicit lifetimes, cutting allocations per request from 41 to 7.
Clones removed Count Calls to clone() taken out of a code path after an ownership or lifetime redesign.Reworked config loading around borrowed views and Cow, removing 320 clone() calls from the request path across 6 crates.
Bug classes ruled out Count Kinds of runtime error the type system now rejects at compile time.Replaced raw status codes and string IDs with newtypes and enums, ruling out 3 classes of bugs that had caused 5 incidents in a year.
Async services
p99 latency Time How long the slowest 1% of requests take, the number callers notice.Moved the purge API from a thread per request to Tokio tasks with a bounded queue, cutting p99 latency from 480 ms to 95 ms.
Throughput Count Messages or requests a second a service sustains at its latency target.Rebuilt log streaming on Tokio and Axum with backpressure per destination, raising sustained delivery to 2.6M log lines a second.
Dropped messages Count Messages lost during deploys, restarts or overload, from the service’s own counters.Added a graceful shutdown that drains in-flight batches before exit, taking lost log batches per deploy from about 1,200 to 0.
Performance & memory
Peak memory Count The most resident memory a process uses under real load.Swapped per-request buffers for a bumpalo arena in the image optimizer, cutting peak memory per worker from 3.1 GB to 900 MB.
CPU per request Percent CPU time per request compared with before a change, from perf or production profiles.Replaced a hand-written header search with memchr after a cargo-flamegraph capture, lowering CPU per request on the proxy by 17%.
Benchmark time Time Median time per iteration in a criterion benchmark, tracked in CI.Rewrote URL normalization to work on bytes instead of chars, taking its criterion benchmark from 1.9 microseconds to 410 nanoseconds per call.
Unsafe code & interop
Unsafe lines Count Lines inside unsafe blocks, the code that needs a manual safety review.Put a safe API generated with bindgen in front of the C TLS session cache, cutting the unsafe code the team reviews from 2,400 lines to 290.
Undefined behavior found Count Problems Miri or the sanitizers report in unsafe or FFI code.Turned on Miri and AddressSanitizer for the FFI crates in CI and fixed what they reported, 9 undefined behavior bugs in the first month.
Crashes at the boundary Frequency Crashes a month that start in code crossing between Rust and C.Caught panics at every extern "C" function and returned error codes instead, taking boundary crashes from 6 a month to 0.
C & C++ rewrites
Lines of C retired Count C or C++ code deleted once its Rust replacement takes all the traffic.Moved the HPACK decoder from C to Rust behind the existing ABI and deleted 14,000 lines of C after a 6-week side-by-side run.
Regressions after cutover Count Customer-facing bugs caused by switching to the Rust version.Compared every output of the old and new decoders on mirrored traffic before switching, with 0 customer-facing regressions after cutover.
Memory safety bugs in the component Frequency Memory safety bugs reported a year in a component, before and after its rewrite.Rewrote the C cookie parser in Rust, and memory safety bugs reported in that code went from 4 a year to 0 since launch.
Testing & fuzzing
Bugs found before release Count Crashes, panics and logic bugs that tests or fuzzers caught before production.Added proptest properties and cargo-fuzz harnesses for the URL and header parsers, finding 23 crashes and race bugs before release in a year.
Fuzzing coverage Percent Share of a parser’s branches the fuzzer reaches, from coverage reports.Built a seed corpus from sampled real requests for the header fuzzer, raising branch coverage of the parser from 54% to 88%.
CI time Time Wall-clock time from a push to a green test run.Moved the workspace tests to cargo-nextest with sccache, cutting CI time on every pull request from 26 to 9 minutes.
Crate design & publishing
Monthly downloads Count Downloads a month on crates.io, a rough sign of how many projects depend on a crate.Published the edge rate limiting crate with a small public API and docs.rs examples, now at 45,000 downloads a month.
Breaking releases Count Releases that forced users to change their code outside a planned major version.Added cargo-semver-checks to CI for the 3 public crates, going from 4 accidental breaking releases a year to none.
Clean build time Time Time to build a crate from scratch, which every user of it pays.Moved rarely used parsers behind optional features, cutting clean build time for the config crate from 48 to 11 seconds.
Wasm & embedded targets
Cold start time Time Time to create and start a new WebAssembly instance for a request.Compiled customer WebAssembly modules ahead of time and pooled instance memory, bringing instance startup from 1.7 ms to 85 microseconds.
Binary size Count Size of a .wasm module or firmware image, which drives load time and flash use.Trimmed the SDK’s starter WebAssembly module with opt-level z and wasm-opt, shrinking it from 2.3 MB to 640 KB.
Modules in production Count Customer modules or devices running your code in production.Shipped the WASI host functions for edge key-value access that 9,000 customer modules now call in production.

What if you don’t have exact numbers?

  • 1

    Dig through CI history. criterion keeps its past results, cargo-fuzz keeps its crash files, and old CI runs show test times from before your change.

  • 2

    Go conservative and keep proof. “About 40,000 downloads a month” holds up when crates.io shows it, and “roughly 14,000 lines of C removed” holds up when the PR does.

  • 3

    Use counts when there’s no comparison. Crates you maintain, targets you build for, devices running your firmware or requests a second through your service all show how much was riding on your code.

Free resume review

A recruiter screen, but with feedback

You applied to hundreds of jobs: no result. Companies won’t give you feedback, so you’re stuck in a loop. Rejections will keep coming until you know what’s wrong.

Let’s break this cycle today!

I’ll screen your resume the same way I did at Google.

You’ll get:

  • Your resume sections and content scored.
  • A clear list of what to improve, why, and how.
  • Behind the scenes secrets on the screening process.

Frequently asked

Rust Developer resume FAQ

Free, yes. There’s no login, no email gate and no premium version hiding behind the download button. Overwrite Imogen’s Fastly details, download your PDF, and return when your next crate release deserves a bullet.

Sure. Use the Word button above the preview for a .docx of your edited version, and grab a Word copy of the Iris, Sadia or Gunnar samples too. I’d still apply with the PDF. The .docx exists for recruitment agencies that rebuild every resume in their own branded layout.

It is. One column, the headings every parser expects, and an export made of real text rather than a picture of text. To test your own copy, drag-select the whole PDF, paste it into a blank .txt file, and check that every employer, date and bullet shows up in order.

If you’re under 5 years in, 1 page does the job. With systems work, published crates and a C rewrite to explain, 2 pages won’t hurt you. Rust resumes get skipped for bullets that read like a tutorial on the borrow checker, never for having a page 2.

Rarely. There isn’t a Rust certificate most hiring managers look for. Formal training, from Ferrous Systems for example, can go under Education if you’re new to the language. Shipped Rust and pull requests merged into crates they know count for a lot more.

Anything a benchmark, a profile, CI logs or a dashboard can confirm: p99 latency, peak memory, allocations per request, unsafe lines, lines of C retired, fuzzer finds, crate downloads, binary size. Step 6 shows 24 of these inside sample Rust bullets.

On a Rust resume, I expect proof the other two rarely need: unsafe code kept sound, C or C++ replaced, allocation and memory numbers. Compare with the Go developer resume template, which centers on services, goroutines and Kubernetes tooling, and the back-end engineer resume template, which works across languages around APIs and data. Rust on microcontrollers? The embedded software engineer resume examples are closer to your world.

Use whatever Rust has your name on it: a published crate, a PR merged into Tokio, ripgrep or another known project, or a little tool you wrote to solve a problem at work. Rust done on the job goes under that job, even when your title says C++ developer. Everything else belongs in a Projects section, each entry with a repo link and one metric.

Put it in once, in your Languages row (“Rust 1.99, 2024 edition”), to show you keep up with releases. Bullets don’t need it. For crates, mention a version only if the upgrade itself was the work, like moving drivers to embedded-hal 1.0.

No. Recruiters move faster through a layout they recognize, and nobody checks where your formatting came from. Leaving Imogen’s bullets in is what hurts: an interviewer asking about “your” HPACK rewrite will find out fast. Every bullet should describe your own crates, components and results.

More resources

More help with your Rust Developer resume