26 - What's Next

🎁 You know Rust. Now the real question: how do you go from "I finished a course" to "I can build production systems in Rust"? The answer is deliberate practice with a concrete plan.

The Gap Between Learning and Doing

Finishing this course means you understand Rust's concepts. It doesn't mean you can build production software quickly yet. That gap closes through building real things, not reading more.

The goal for the next 12 weeks is not to know every Rust feature. The goal is:

"I can build and explain production-style systems software in Rust."

Assume ~45-60 minutes a day, 5 days a week.

Weeks 1-2: Fluency (Stop Fighting the Compiler)

You've seen all the concepts. Now internalize them by writing code without looking everything up.

Build:

• CLI file analyzer (count lines, words, characters per file)
• Log parser (read a log file, filter by level, output counts)
• Configuration loader (read a TOML/JSON file, deserialize into structs)

Focus on:

• Writing ownership and borrowing without friction
• Error handling with ? everywhere, no .unwrap() in production paths
• Modules and Cargo

Do not spend days reading theory. Let the compiler teach you. When it rejects your code, read the error message carefully — Rust's errors are the best in any language.

Weeks 3-4: Real Tooling

Build:

• Parallel file scanner (walk a directory tree, collect stats concurrently)
• System information CLI (CPU, memory, disk — use the sysinfo crate)
• Process monitor (list running processes, filter by name, output as JSON)

Focus on:

• Iterators and method chaining
• Traits and generics
• Serde for JSON/TOML serialization
• Lifetimes (only when the compiler demands them — don't force them)

A small project to tie it together:

syswatch
├── CPU usage
├── memory usage
├── disk usage
├── top processes
└── JSON output

Weeks 5-6: Concurrency

This is where Rust's ownership model pays off most visibly.

Build:

• Worker pool (N threads processing a queue of jobs)
• Parallel job executor (fan out work, collect results)
• Concurrent log processing pipeline (read → parse → aggregate → output)

Focus on:

• std::thread and std::sync::mpsc channels
• Arc<Mutex<T>> for shared state
• Rayon for data parallelism
• Basic async with Tokio

The key insight: Rust's compiler prevents data races at compile time. Once your concurrent code compiles, it's safe. That's not true in most languages.

Weeks 7-8: Networking

Build:

• TCP echo server
• HTTP service (use Axum)
• Reverse proxy (accept connections, forward to backends)

Focus on:

• Async Rust with Tokio
• HTTP with Axum or Actix
• Graceful shutdown
• Timeouts and connection handling

A realistic final project shape:

client
   |
reverse proxy (Rust)
   |
backend services
   |
metrics / logging

Weeks 9-10: Production Patterns

This is where you move from "it works" to "it works reliably."

Build:

• Reliable job queue with retry, timeout, backoff, and persistence

Focus on:

• Structured logging with tracing
• Configuration management
• Error type design (custom errors, thiserror crate)
• Benchmarking with Criterion

This is the kind of project you can discuss in depth in interviews. Be able to explain every design decision: why this error type, why this retry strategy, why this data structure.

Weeks 11-12: One Serious Project

Pick one and finish it. A half-finished project teaches you nothing about production Rust.

Option A: Developer platform tool

• Local Kubernetes helper
• Deployment validator
• Log aggregation agent

Option B: Infrastructure component

• Key-value store
• In-memory cache with eviction
• Task scheduler

Option C: High-performance data tool

• Log/event processing pipeline
• File format converter
• Data aggregation service

Whatever you pick, add:

• A README explaining what it does and how to run it
• Tests (unit and integration)
• Benchmarks
• CI (GitHub Actions)

This is your portfolio piece. You should be able to walk someone through the code in 20 minutes and explain every decision.

Practice Alongside (Every Week)

Don't wait until week 12 to start interview preparation.

Every week:

• 2-3 LeetCode problems in Rust (focus on array, string, and tree problems)
• 1 system design topic reviewed

Your Rust muscle memory builds through repetition. The sooner you start writing Rust daily, the sooner it stops feeling foreign.

Crates Worth Learning

Don't add all of these at once. Learn each one when a project demands it.

Key Takeaways

• Finishing a course gives you concepts. Projects give you skill.
• Build in order of complexity: CLI tools → concurrent tools → networked services → production systems
• Let the compiler teach you — read every error message carefully
• Add tests, benchmarks, and a README to every serious project
• Practice LeetCode in Rust weekly, don't wait until you feel "ready"
• One finished serious project is worth ten half-built ones