Skip to content
  1. Home
  2. Hire
  3. Back-End
  4. Rust
Hire developers

Senior Rust developers: 3 vetted profiles in 48 hours

Senior Rust engineers for the parts where a crash or a pause is not an option: services, CLIs, and the native core behind a product written in something else.

What we test for

Rust 2021 editionTokio and asyncAxum or Actix Webserdesqlx or Dieselcargo test, clippy and miriFFI and WebAssembly targets

Typical work

  • A service where tail latency matters more than developer hours
  • The hot path of a product written in Python or Node, called over FFI
  • CLIs and tools that have to run anywhere with no runtime installed
  • Replacing C or C++ in a component that keeps producing memory bugs

The coding test

Here is code that compiles because everything is cloned and wrapped in Arc>. Remove the locks that are not needed and explain each one you keep. Then make an async task cancellable without leaving a half-written file behind. Scored on the ownership argument, not on whether it got shorter.

For your interview loop

Five interview questions you can reuse

We use questions like these in our soft-skills and technical rounds. Steal them for your own interviews.

  1. When is unsafe the right answer?

    A strong answer covers: When you are implementing something the borrow checker cannot express and you can write down the invariant that makes it sound: FFI, a data structure with internal aliasing, or a performance path you have measured. The senior answer always includes who checks the invariant and how it is tested, usually with miri. Reaching for unsafe to make a lifetime error go away is the version that ships an unsound library.

  2. A struct needs a reference to something that outlives it. What are the options?

    A strong answer covers: Own the data, reference-count it, or make the lifetime explicit and let the caller prove it. Most of the time the honest answer is that the struct wants ownership and the reference was an attempt to avoid a clone that costs nothing. Lifetimes in a struct are a contract for the whole API, so they are worth it only when the type is genuinely a view.

  3. When does Arc> mean the design is wrong?

    A strong answer covers: When every task takes the same lock on its hot path, which turns a concurrent program back into a serial one with context switches. Usually the state wants to live in one task that owns it and receives messages, or the lock wants to be smaller than the whole struct. Keeping a MutexGuard across an await is the related bug, and the compiler will often let it happen in a single-threaded runtime.

  4. anyhow or thiserror?

    A strong answer covers: thiserror in a library, where the caller needs to branch on what went wrong; anyhow at the top of a binary, where the next step is a log line and an exit code. The mistake is anyhow in a library, which gives every caller a string and no way to handle anything.

  5. What happens to an async task when you drop its future?

    A strong answer covers: It stops at its last await point, and anything after that never runs, which is why cleanup belongs in Drop or in a guard rather than after the await. Cancellation in Rust is silent, so the thing to design for is what a half-finished operation leaves behind: a temporary file, a lock, a row marked in-progress.

How we work

One invoice a month.

The shortlist is free. Pick the contract that suits you: monthly, six months or twelve.

What every seat includes

  • Contracts, payroll and compliance handled
  • Vetting: coding test, soft skills, English and a level check
  • Free replacements: unlimited on 12+ months, 2 on 6 months, 1 on monthly
  • A direct line to our CEO
Get 3 profiles in 48 hours

Terms in plain words

  • Monthly, six months or twelve, your choice
  • Your rate is locked for the whole contract on 6 and 12+ months
  • Monthly ends with 30 days’ notice
  • Want to hire the developer full-time? The buyout is set in the contract from day one

The full terms, contract by contract

Questions tech leads ask us

Can you really staff Rust in Latin America?

There are fewer senior Rust engineers than senior Java engineers, and we will tell you if a brief is not realistic rather than send profiles that do not meet the bar. Most of ours came from C++ or Go. We test the ownership model, because that is what takes a year to learn.

How senior are your Rust developers?

6+ years of professional systems or backend work, with production Rust rather than a side project. We ask what they shipped, who runs it, and what they had to use unsafe for.

Skip the sales rep. Talk to the CEO.

Tell us what you're building, your stack and when you need people. Three vetted profiles per role within 48 hours of the call, and a straight answer on whether we're the right fit.