How the Advanced Path Works

Most Rust learning stalls at the same place. You finish the syntax — ownership, Result, traits, async — and then… what? The tutorials all stop at cargo run. Nobody shows you the part that a job actually pays for: a real app, with a frontend, a database, a cache, AI, containers, an orchestrator, dashboards, and a profiler run to make it fast. This book is that part.

The two paths

There are two Rust books in this series, and they’re meant to be read in order:

	Base path	Advanced path (you are here)
Book	Rust · Project-First	Rust · In Production
Teaches	the language	the system around the language
Shape	many small runnable projects	one real app, taken to production
You leave knowing	”I can write Rust"	"I can ship Rust”

The base path

The base playbook teaches Rust by building: a CLI (logwise), a key-value store (kvlite), an async API (apilite), an AI CLI (askr), then three mini-blockchains (btcmini → ethmini → solmini). Every concept arrives the moment a project needs it. If any of ownership, borrowing, ?, traits, async/await, or axum feel shaky, do that first — this book assumes them and moves fast.

This path

The advanced path inverts the structure. Instead of seven small projects, there’s one application, and every part wraps another layer of production reality around it. The language stops being the subject; the system becomes the subject. By the end you’ll have built and operated a service the way a small team actually would.

The app you build: `quill`

quill is a small blog that grows an AI writing assistant. We pick a blog on purpose: the domain is boring and familiar, so all of your attention goes to the engineering around it — not to figuring out what a “post” is. We start with the simplest possible version and add exactly one hard thing at a time.

   Part 1  ▸  a blog: axum + Postgres, posts CRUD, real error handling
   Part 2  ▸  a face: Astro frontend, an editor, sessions, SSE plumbing
   Part 3  ▸  a brain: AI drafts/titles/summaries, streamed, as background jobs
   Part 4  ▸  a spine: Redis cache + rate limit, Docker images, Kubernetes
   Part 5  ▸  eyes: structured logs, metrics, distributed traces
   Part 6  ▸  speed: measure, then tune — with before/after numbers
   Part 7  ▸  ship: CI/CD, a readiness checklist, and what's next

Each part is a set of chapters. Each chapter teaches the concept the next slice of quill needs, then has you build that slice, and ends with a Check your understanding block (with answers) so you can prove the idea stuck before moving on.

The thread

Every page comes back to one question:

Once the code compiles, what does it take to make it run — safely, fast, and observably — for real users?

That question is the entire distance between a passing cargo build and a service on call at 3 a.m. Rust gives you an enormous head start on the “safely” — whole categories of production incident (data races, use-after-free, null derefs) are simply deleted at compile time. This book is about everything the compiler can’t hand you: architecture, integration, operations, and performance you can measure.

How to work through it

Build quill yourself. The reference crate under rust/quill/ is the answer key, not the assignment. Type each slice into your own project, run it, and break it on purpose.
Run the real dependencies. From Part 4 on you’ll use Docker Compose to bring up Postgres and Redis locally — this is a production book, so we use production infrastructure, not fakes.
Don’t skip the measurement. Parts 5 and 6 are where most tutorials wave their hands. Resist the urge to “optimize” before you’ve profiled; the whole discipline is measure-first.

Start here: What Rust Is Actually For → — the systems landscape, so you know why this language is worth taking all the way to production.