• understand what unsafe blocks promise and what they cost
• cross an FFI boundary in both directions without UB
• review unsafe code critically instead of trusting it

Write safe Rust bindings over a small C library — document the invariants each unsafe block relies on.

• ▢I can explain aliasing rules and why unsafe blocks carry proof obligations
• ▢I've called into C (or been called from it) across an FFI boundary
• ▢I know when to reach for Box/Rc/Arc/Cow and what each costs
• ▢I've read unsafe code in a real crate and could review it critically

• understand stack vs heap, cache lines, and layout costs
• process data zero-copy where it matters and prove the win
• profile allocations instead of guessing

Build a binary file parser (e.g. a WAL or image format) that's zero-copy where possible — benchmark it against a naive version.

• ▢I can explain why Bytes enables zero-copy sharing and when it doesn't help
• ▢I've memory-mapped a file and processed it without loading it whole
• ▢I've found and fixed an allocation hot spot using a profiler
• ▢I can reason about struct layout, padding, and #[repr(...)]

• understand what Send and Sync actually promise the compiler
• choose between channels, locks, and lock-free structures and justify it
• measure parallel speedups instead of assuming them

Build a parallel grep or log analyzer: rayon for scanning, crossbeam channels for results, a benchmark table in the README.

• ▢I've parallelized a CPU-bound workload with rayon and measured the speedup
• ▢I can choose between channels, Mutex, RwLock, and dashmap and justify it
• ▢I understand what Send and Sync actually promise the compiler
• ▢I've debugged a real deadlock or race and can tell the story

• understand what happens between connect() and the first byte
• implement a wire protocol with framing you can defend
• run TLS on both ends and know what the handshake costs

Write a TCP chat or key-value server with a documented wire protocol, TLS, and a stress-test client — numbers in the README.

• ▢I've implemented a small wire protocol with length-prefixed framing
• ▢I've configured TLS (rustls) on both client and server ends
• ▢I can explain what happens between connect() and the first byte
• ▢I've load-tested a network service and interpreted the bottleneck

• benchmark honestly and know why microbenchmarks lie
• read a flamegraph and act on it
• make something measurably faster and document before/after

Take any earlier project and make it 2× faster — publish the flamegraphs, the benchmark suite, and what didn't work.

• ▢I benchmark with criterion and know why microbenchmarks lie
• ▢I've read a flamegraph and acted on it
• ▢I can use perf/dtrace (or pprof) on a running Rust process
• ▢I've made something measurably faster and documented before/after

• understand containers in terms of namespaces and cgroups
• know what fsync guarantees and what it costs
• write software that survives kill -9 correctly

Build a minimal process supervisor (start, restart, signal forwarding, log capture) using nix — no shelling out.

• ▢I've used nix/libc to work with signals, pipes, or process control
• ▢I can explain what a container is in terms of namespaces and cgroups
• ▢I know what fsync guarantees and what it costs
• ▢I've written something that survives kill -9 correctly