Part 7 · Ship It & What's Next

Everything is built: a Rust backend, an Astro frontend, AI generation, Redis, Docker, Kubernetes, observability, and a profiled hot path. Part 7 ties the bow — the automation and judgment that turn “it works” into “it ships, repeatedly, without me holding my breath” — and then points you at what comes after quill.

What you’ll build

   git push ─► GitHub Actions ─► test ─► build image ─► push ─► deploy ─► verify
                    │              │          │            │        │        │
                  fmt+clippy    cargo test  multi-stage   registry  kubectl  probes
                                            Docker                  rollout   green?

• A CI pipeline: cargo fmt --check, clippy -D warnings, the full test suite, and a built image on every push — the same gates the base playbook’s askr hardening day introduced, now guarding a real deploy.
• A CD pipeline: build and push the Docker image, then roll it out to Kubernetes, with the rollout gated on your readiness probe going green.
• A production readiness checklist for quill: secrets out of the image, resource limits set, graceful shutdown wired, alerts on the golden signals, a rollback that works.

The readiness checklist (preview)

Area	The bar
Config	secrets in the platform, never in the image or git
Health	liveness + readiness probes that mean what they say
Resilience	graceful shutdown, retries with backoff, timeouts everywhere
Observability	golden-signal dashboards + at least one alert that would’ve paged you
Rollout	rolling deploy, a rollback command you’ve actually run
Cost	the AI endpoint is rate-limited, capped, and cached

The chapters

Ch	Title	You add	The idea it teaches
1	CI/CD	GitHub Actions: test → build → deploy	gates as code, reproducible builds, deploy on green
2	Readiness	the checklist, alerts, rollback	operating judgment, what “done” means for a service
3	What’s next	paths onward, the Solana bridge	where these skills compound next

Where this points next

You set out to master Solana/Anchor smart contracts, and this path was never a detour. Look at what transferred: async Rust under load, a service you can profile, operating real infrastructure, and the habit of measuring before believing. An on-chain program is a different runtime, but it’s the same language and the same discipline — correctness first, performance you can prove, failure handled explicitly.

   Base playbook  ─►  This path (ship real Rust)  ─►  Solana / Anchor
   (learn Rust)       (operate Rust systems)          (Rust on-chain)
        │                    │                              │
   logwise…solmini      quill, in production          real programs

The real graduation

When you can take an idea from cargo new to a monitored, autoscaling, profiled service in Kubernetes — and explain every layer and why it’s there — you’re no longer “learning Rust.” You’re an engineer who happens to use it. That’s the whole goal of this book.

This is the end of the planned arc. The chapters fill in from here — start the build at Part 1 · The Blog Core →.