Chapter 1: Introduction - what you’ll build

This handbook teaches you to build, deploy, operate, monitor, and monetize AI-assisted web applications on a low budget. By the end, you will own the full stack - from Dockerfile to domain, from database backup to Stripe webhook fulfillment - with no managed platform lock-in and a mostly predictable low monthly bill.

This handbook is not: deep DevOps certification prep, cybersecurity cert prep, legal reference, or an ML engineering handbook. Legal and compliance topics are covered at an operational-awareness level only - enough to launch responsibly, not enough to represent others or build a regulated product. This book is not legal advice, so consulting a lawyer is always advisable.

What this handbook covers

Most tutorials stop at localhost. They show you how to render a page on your laptop, maybe connect to a database, and then they end. You are left with a folder of code and no path to a domain, a payment flow, or a customer who can actually buy what you built.

This handbook walks through shipping real paid digital or physical goods end-to-end: from choosing tools and registering a domain to handling Stripe webhooks and writing a privacy policy that matches what your app actually stores.

Ch 1–2   Orientation & tools
   ↓
Ch 3–6   Four example apps (portfolio → YouTube → fitness API → Stripe payments)
   ↓
Ch 7–8   VPS deploy, domains, email, DNS
   ↓
Ch 9–10  Production checklist, launch
   ↓
Ch 11    Recap and next steps

End-to-end path: idea → deployed paid product

1. Clarify scope - What are you selling? Who is it for? What is the smallest version you can launch with?
2. Set up tooling - Docker, git, Makefile, and Cursor (Chapters 1–2).
3. Build applications - Four example apps of increasing complexity (Chapters 3–6).
4. Accept payments - Stripe Checkout, webhooks, access keys (Chapter 6).
5. Deploy to a VPS - Dokploy, TLS, environment secrets, persistent volumes (Chapter 7).
6. Configure email - Transactional vs marketing, DNS authentication (Chapter 8).
7. Harden and launch - Security baseline, legal pages, soft launch (Chapters 9–10).

Each step builds on the previous one. You are not jumping from a todo-app tutorial straight into complex infrastructure. You are learning patterns that scale from a first paid download to a small SaaS.

Chapter map at a glance

The eleven chapters are sequential but not equally weighted:

Appendices A–E (environment reference, troubleshooting, AI tooling, DNS reference, OS setup) are reference material you will revisit during deployment, not front-to-back reading.

If you already know Docker, skim Chapter 2 and spend the saved time on Chapter 5 (Go + SQLite fitness tracker) - that example carries the most transferable backend patterns.

What we build vs what we configure

Both coding and configuration matter for a paid product:

You will write real Go and React code. You will also log into Stripe, your domain registrar, and your VPS provider. This handbook does not hide those steps behind a “one-click deploy” button.

Who this is for (and not for)

This handbook assumes you have shipped small programs before - even if only homework assignments or personal scripts - and you are ready to connect those skills into a production-shaped workflow.

Good fit:

• Developers comfortable with HTML/CSS and at least one programming language (JavaScript, Python, Go, or similar)
• Readers who can use a terminal for basic file navigation and running commands
• People willing to run commands inside Docker rather than installing a dozen runtimes on their host
• Solo founders or small teams shipping a first paid web product - digital guide, template pack, physical goods, API access, or lightweight SaaS

Not a fit:

• Complete beginners with no programming exposure. If terms like “variable,” “function,” and “HTTP request” are unfamiliar, start with a general programming intro first.
• Teams needing enterprise patterns: SSO with SAML, multi-tenant isolation, complex role-based access control.
• Anyone expecting live instructor support, email help with handbook questions, or video-only content. This is text-first with copy-pasteable commands — use the appendices, example READMEs, AI tools and good old-fashioned web search when you get stuck.
• Readers who want a turnkey SaaS boilerplate. You will learn patterns, not receive a white-label product.

If you are on the fence, work through Chapter 2 before deciding. If Docker and a terminal feel manageable, you are in the right place.

What you’ll have at the end

Four reference applications

You will receive patterns - how to structure handlers, where to put migrations, how to verify a webhook signature - that transfer to your own domain and pricing.

Production platform literacy

Even if you never build a paid digital goods storefront, you will understand:

• How Dokploy runs container images with TLS and env secrets
• Why Stripe Checkout is hosted instead of custom card forms for a first launch
• How to separate transactional email from marketing email
• What a minimal GDPR-aligned privacy policy must disclose
• How to implement session-based access control for digital products

Your own goal project

The checkpoint at the end of this chapter asks you to describe the product you want to ship. By Chapter 11, you should be able to map that paragraph onto concrete repos, a domain, a Stripe product, and a launch checklist.

Scope creep is the main reason solo launches slip. The four reference apps intentionally stay small: a portfolio page is not a design system; the fitness tracker is not a social network. Apply the same discipline to your goal project - one deliverable, one payment SKU, one email flow - then iterate after real customers exist.

What you will not build here

Honesty about scope prevents disappointment:

• No mobile native apps (web-first only)
• No multi-region high availability or Kubernetes clusters
• No custom video hosting platform - you sell access to content
• No enterprise SSO or team billing

If your vision requires those, treat this handbook as a foundation for the solo-product slice of a larger roadmap.

How AI fits in

AI coding tools accelerate every phase in this handbook - scaffolding, boilerplate generation, error debugging, configuration, and drafting. Cursor is the default editor throughout; Appendix C covers the full AI tooling landscape.

The deliberate loop you will internalize: write a spec or checkpoint goal → let the agent apply changes → review every diff → run make up / curl / browser test → commit. If the agent breaks something, git restore . and narrow the prompt.

AI fails at knowing your business rules, your Stripe account state, or whether an API endpoint exists in the library version you installed. Stripe webhooks are the single highest-risk target for hallucinations - Chapter 6 teaches exactly where AI helps and where you must verify every line against the reference implementation.

Full AI tooling reference, including Cursor agent mode, skills, rules, MCP, verification habits, the OpenSpec workflow, and local-vs-cloud model tradeoffs: Appendix C.

Example applications

Each Chapter 3–6 app ships as a downloadable zip. Unzip into a folder, open in Cursor, and follow the README. Each example includes a README, Makefile, and docker-compose.yml.

Save git commits at each checkpoint so you can roll back if an AI edit goes wrong. Work through the chapters sequentially - each builds on the previous one.

Checkpoint exercise

Write one paragraph describing the product you want to ship after this handbook. Include:

1. Audience - Who pays, and what problem do they have?
2. Core deliverable - PDF, templates, API access, SaaS feature?
3. Why own the stack - What do you gain vs using a platform like Gumroad or Teachable?

Save it in your project notes - a local file or private doc, not a public gist with business ideas. Revisit after Chapter 11 and note what changed.

Example (do not copy blindly - yours should be specific):

I want to sell a short guide for freelance designers on writing client contracts. Audience is solo designers in the EU who have never used a lawyer. Deliverable is a PDF plus three Notion templates. I want to own the stack so I can add automated buyer emails later, control checkout copy for GDPR, and avoid platform fees on a low-price product.

Key takeaways

• This handbook covers build, deploy, operate, monitor, and monetize - not just “code on localhost”
• Four reference apps increase in complexity: portfolio → API dashboard → REST API → payments
• AI coding tools accelerate every phase, but you remain responsible for what ships
• The checkpoint you wrote above is your north star - revisit it after Chapter 11

Further reading

• Docker overview - the container model used in every example app
• Stripe overview — the payment platform you will integrate in Chapter 6
• Appendix C: AI-assisted development reference (Available in full handbook) - the full AI tooling landscape
• Appendix E: OS setup (Available in full handbook) - Docker installation walkthroughs per platform

Common pitfalls

• Skipping the Docker chapter - Chapters 3–6 assume containers work on your machine. Fix Docker now, not during the fitness tracker build.
• Treating AI output as authoritative - Always run the code and read Stripe/Docker docs for your version. If the agent cites an API, verify it in official documentation.
• Optimizing for perfect design before deploy - Ship a narrow MVP, then iterate. The portfolio example is intentionally simple.

You now have enough context to decide whether to continue. Chapter 2 installs Docker, initializes git, and serves your first static page.