Skip to content

Expert · Rust careers and interviews · topic 50 of 50 · 25 min

Portfolio, open source and a learning plan

Explanation

Build three or four real projects that show different skills: a CLI tool, an axum API with a database, a WebAssembly demo, and a small library published on crates.io. Contribute to open source through "good first issue" labels. Keep practising with Rustlings, Rust by Example and Exercism, and follow a 90-day plan after this course.

Why a portfolio matters more for Rust

Because many Rust roles ask for experience, your public work becomes your experience. A reviewer who opens your GitHub should see, in two minutes, that you can write idiomatic, tested Rust that does something useful. Quality beats quantity: three polished projects are better than fifteen half-finished tutorials.

Four projects that cover the ground

ProjectShowsIdeas
CLI toolOwnership, error handling, file I/O, clap, testsExpense summariser, log analyser, bulk file renamer, CSV to JSON converter
Web APIasync, tokio, axum, serde, SQL, DockerLibrary management, clinic appointments, URL shortener with a database
WebAssembly demoPerformance, FFI boundary, JS interopImage filters, EMI calculator, Markdown preview in the browser
Library on crates.ioAPI design, docs, semver, doc testsIndian number formatting, GSTIN or PAN validation, IFSC parser

What a reviewer looks for

  • A README with what it does, a screenshot or terminal example, how to install and run, and design notes.
  • cargo fmt and Clippy clean; tests that run in CI (a green badge helps).
  • Good error handling: Result, clear messages, no unwrap on user input.
  • Sensible structure: modules, lib.rs, small functions, doc comments.
  • Commit history that shows steady work, with clear messages.

Contributing to open source

Open source means projects whose code is public and accepts contributions. Contributing teaches you to read large codebases, take review feedback and work with others, and it is highly visible to employers. Start small:

  1. Pick a Rust project you use (a CLI tool, a crate from your projects).
  2. Look for issues labelled "good first issue" or "help wanted", and read CONTRIBUTING.md.
  3. Comment that you would like to work on one, then make a small, focused pull request.
  4. Respond to review comments politely and quickly. Documentation fixes count too.

Practice resources

  • The Rust Book: read it fully once; re-read the ownership and traits chapters.
  • Rustlings: small exercises that make you fix compiler errors, run locally.
  • Rust by Example: runnable examples for every feature.
  • Exercism's Rust track: exercises with optional free mentoring.
  • Advent of Code (December) in Rust: great for iterators and collections.

A 90-day plan after this course

output
Days 1-30:  Re-read ownership/traits chapters. Finish Rustlings.
            Build the CLI project with tests and CI.
Days 31-60: Build the axum API with sqlx + PostgreSQL + Docker.
            Write integration tests. Deploy it somewhere free.
Days 61-75: Wasm demo + publish a small library to crates.io.
Days 76-90: 2 open-source PRs. Polish READMEs. Mock interviews
            (modules 12.2 and 12.3). Start applying.
Adjust to your time: one focused hour a day is enough if you are consistent.

Staying current

Rust releases a new stable version every six weeks. Read the release notes on the official Rust blog, skim "This Week in Rust", and update your toolchain with rustup update. You do not need every new feature; just know what changed in the areas you use.

Common mistakes

  • Many unfinished projects. Finish and polish fewer.
  • No README or screenshots, so nobody understands what the project does.
  • Waiting to "know everything" before applying. Apply while you keep learning.
  • Opening a huge pull request as your first contribution. Start small.

Need help?

Stuck on a word or an idea? Search this course, or every course, and jump straight to the explanation or a worked question.

Try:

Watch the lesson

Portfolio, open source and a learning plan · 1/6

3 polished > 15 unfinished

For Rust roles, your public work is your experience. Quality beats quantity.

Prefer a video by a teacher? Find free videos on “rust portfolio projects ideas open source contribution” on YouTube ↗

In real life: Publishing a tiny useful crate

A student in Kochi notices that many Indian apps need to validate GSTIN numbers. She writes a small crate with a validate function, careful error types, doc tests and a README with examples, and publishes it on crates.io with cargo publish. A few developers use it and open issues; she fixes them. In interviews, this one crate gives her concrete stories about API design, semver and handling user feedback.

rust
/// Checks the basic shape of a GSTIN: 15 characters, starting with a 2-digit state code.
///
/// ```
/// assert!(gstin_lite::looks_valid("27AAPFU0939F1ZV"));
/// assert!(!gstin_lite::looks_valid("123"));
/// ```
pub fn looks_valid(s: &str) -> bool {
    s.len() == 15
        && s.is_ascii()
        && s[..2].chars().all(|c| c.is_ascii_digit())
        && s.chars().all(|c| c.is_ascii_alphanumeric())
}
A shape check only; a full validator would also verify the checksum character.

Practice (0/2 done)

Task 1 · Question

Which portfolio is stronger for a Rust job application?

Task 2 · Practice

Write your own 90-day plan: list your four portfolio projects with a one-line description each, the weeks you will work on them, two open-source projects you will look at for first issues, and the day you will start applying.

Quick quiz

Question 1

1.What is a good first open-source contribution?

Question 2

2.Which resource gives small exercises where you fix compiler errors?

Question 3

3.How often does Rust release a new stable version?

Read more (free)

Open a question to see the answer and why. The first ones are this topic's own quiz, so try the quiz above before you peek.

What is a good first open-source contribution?

Answer: A small fix from a "good first issue", including docs

Small, focused pull requests are welcomed.

Which resource gives small exercises where you fix compiler errors?

Answer: Rustlings

Rustlings is designed around small failing programs.

How often does Rust release a new stable version?

Answer: Every 6 weeks

Stable releases come every six weeks.

What should never be committed to a public portfolio repository?Related

Answer: Keystores and secret keys

Keep secrets private.

From Portfolio and next steps

What should never be committed to a public portfolio repository?Related

Answer: API keys and keystores

Secrets must stay private.

From Portfolio and next steps

Which portfolio is stronger for a junior full-stack role?Related

Answer: Two or three live projects with clear READMEs and real users

Finished, live projects with good READMEs show that you can make decisions and ship, which clones cannot show.

From Your portfolio and GitHub

What is a handler in axum?Related

Answer: An async function that answers a request

Handlers are async functions wired to routes.

From Rust for the web with axum

Pass the quiz (60% or more) or mark this topic as done when you are ready.

Your progress is saved on this device only.

Back to the course →

Next steps

  1. This is the last topic of “Rust careers and interviews”. The module exam comes next.
  2. Module 12 exam: Rust careers and interviews · 10 questions · 20 min, without help. 4 topics of this module still to finish first.
  3. 50 topics left in the course before the final exam.

← Previous: Interview questions: traits, errors, pointers and concurrency