12-module deep-dive on shipping full-stack SaaS, from schema design to deploy pipeline.
Premium tier — extended scope, 17,000+ words manuscript + 12 standalone course modules + 6 decision-table playbooks.
The gap between "this works for now" and "this will work for five years" is where most SaaS fails. You've shipped a product to production. You felt the pressure: which database do you scale to? When do you extract services? How do you build for the deploy strategy that survives year three? This course is the field guide for that gap.
A 12-module deep-dive covering the architectural decisions that compound over years. Senior-IC voice. Written as decision tables that survive rereading at the moment of decision, not blog posts that feel obvious until you ship. The book assumes you've shipped to production at least once. It's not a tutorial — it's the perspective on architectural leverage you wish you'd had after your first three SaaS products.
Inside: ~17,000 words across a typeset book (PDF, EPUB, Markdown), twelve standalone course modules designed to be read individually as you face the corresponding decision, and six decision-table playbooks covering the architectural calls that come up most — database choice, auth storage, queue system design, caching strategy, deploy pipeline, and observability stack.
Denormalization rules, indexing strategy, migration discipline. The two-clock rule, soft-delete trade-offs. The schema is the longest-lived artefact in your system — change it last.
When to extract, when to merge, the contract test pattern, the single-deploy-unit heuristic. Premature extraction is technical debt; late extraction is operational pain. The right timing frame.
REST patterns that survive, error shape consistency, versioning strategies, pagination, idempotency keys. The patterns that travel across team rewrites.
Secure cookies in detail, multi-tenant isolation, OAuth2 flows for B2B, session storage trade-offs, CSRF defense. The security properties that don't degrade under pressure.
Async work patterns, retry semantics, dead-letter queues, idempotent consumers, the "exactly-once" myth. The discipline that separates slow systems from broken systems.
Provider abstraction, prompt versioning, RAG fundamentals, output validation, cost & latency budgets. Building with AI suppliers, not AI services.
State management trade-offs, routing, hydration patterns, code-splitting strategy, the islands mental model. Shipping the right interface without the hydration debt.
Staging environments, canary releases, rollback strategy, immutable infrastructure, the deploy-is-reversible principle. Making deployment boring.
Structured logs, RED + USE metrics, error fingerprinting, sampling strategies. The visibility that prevents the 3 AM page.
Caching layers, the index-or-cache decision tree, CDN trade-offs, perceived performance. From slow to user-invisible.
On-call rotation design, the 3-step incident rule, blameless postmortems, runbooks vs tribal knowledge. The habits that make a product reliable.
What survives, when to rewrite, the 3-strikes rule for tech debt, paying down vs ignoring. Building for the long game.
PostgreSQL as the default primary store. When to add specialist stores (Redis, BigQuery, Elasticsearch) on observable need, not by default. Trade-offs between operational burden and query expressiveness.
Session storage options: database scaling, Redis invalidation, JWT statelessness. Trade-offs in revocation, scale, and security posture.
Message queue options for async work. Redis for low-latency in-process, Kafka for high-throughput event streams, SQS for serverless. When to add a queue.
Caching strategy: application cache for hot data, Redis for distributed state, CDN for static assets. The index-or-cache decision tree.
Deployment patterns: canary for gradual rollout, blue-green for instant switchover, rolling for slow drain. The deploy-is-reversible principle.
Observability choices: self-hosted (cost + operational burden), SaaS (uptime dependency), hybrid (complexity). Metrics, logs, traces, and when to add each.
Module 1 — Schema Design — is available as a free preview PDF. ~1,000 words covering denormalization rules, indexing strategy, and migration discipline. Read it before deciding.
Suggested 4–6 week pace. This is not a one-sitting read. The patterns are too dense; the decision tables won't stick if you skim them.
Week 1 — Foundations. Read modules 1–3 (Schema, Services, API). These are the highest-leverage chapters because they're hardest to change later. Re-read the decision tables at the end of each.
Week 2 — Core Plumbing. Read modules 4–6 (Auth, Queues, AI). These cover the cross-cutting concerns that touch every endpoint.
Week 3 — Edge & Delivery. Read modules 7–8 (Frontend, Deploy). These are the modules where patterns rotate fastest, but the underlying principles survive.
Week 4 — Operability. Read modules 9–10 (Observability, Performance). The discipline that turns a system from "ships features" to "ships features reliably".
Week 5 — Maintenance. Read modules 11–12 (Operational Rituals, 5-Year View). The longest-time-horizon material; re-read after a year in production.
Week 6 — Decision Tables. Print them. Pin them. Use them as the checklist before your next architectural commit.
Optional: Read one course module per week instead of sequential book reading. The course modules are written to stand alone; some readers prefer them as a slower, lower-density introduction.
Text only. PDF (typeset), EPUB (for e-readers), and Markdown. No video. The course modules are standalone markdown files designed for re-reading at the moment of decision, not passive watching.
No specific stack required. The patterns translate to any modern SaaS — Node, Python, Ruby, Go, Java, Rust. Postgres, Redis, Stripe are used as common-knowledge reference points; the decisions transfer across.
You've shipped at least one production system end-to-end. You're comfortable reading SQL, basic distributed-systems vocabulary (queue, cache, replica), and common HTTP patterns. You've been on-call at least once — the lessons land harder if you've felt the 3 AM page.
Yes. Each decision table is available as pure Markdown (renders perfectly on GitHub, GitLab, Notion, every static-site generator) and embedded in the main PDF. Print directly from PDF or convert markdown to PDF with your tool of choice.
License is single-seat. Team license available on request — contact info@shippedstack.com with team size.
Yes. Single-seat license allows you to install into your own projects, internal codebases, and private repositories, and to modify the content for internal use. See LICENSE file for full terms.
This is not a passive-watch product. It's a reference: something you read deeply once, then return to specific modules when you're facing the decision in your own system. If you prefer video walkthroughs, this is not the right product. If you want a decision framework you can grep and pin to your monitor, it is.
The architectural patterns covered (schema design, service extraction, deploy strategy, observability) are stable across 5+ year cycles. When the patterns do shift (newer databases emerge, cloud-native changes scale assumptions), v1.x updates cover them — free for all buyers. Current version: 1.0.0.
Full-Stack SaaS Architecture Course — €149 one-time, lifetime v1.x updates, 30-day refund. 12 modules, 6 decision tables, ~17,000 words.