The $1,800 Budget MVP (And the Eight-Week Schedule That Actually Ships It)

The problem

Conventional wisdom puts an MVP at $50,000 and three to six months. That number is a decade out of date. Cloudflare Workers handle 100,000 requests per day on the free tier. Supabase ships 500 MB of PostgreSQL with auth, row-level security, and real-time. Google Cloud throws in $300 of credit for new accounts. Stacked correctly, these three free tiers run a production system processing real transactions — without spending a cent on infrastructure for the first year.

This is the playbook for getting from first commit to live deployment in eight weeks on $1,800 total. Not per month, not per sprint — total. Domain registration, design tools, the occasional API key. The infrastructure budget is $0 because the design forces every architectural decision through a free-tier constraint, and the constraint makes the architecture better, not worse.

The thing the playbook explicitly is not: a “build a SaaS landing page in a weekend” tutorial. The system at the end of week eight is a real AI commerce platform with dual-protocol payment support, hybrid cryptographic signatures, MCP server integration, and end-to-end test coverage. Every dollar tracked, every week documented, every free tier pushed to its operational limit.

What most people get wrong

Mistake one: treating free tiers as a development crutch instead of a production target. Most founders use free tiers for the first weekend, then assume they’ll graduate to paid plans before launch. That mindset produces architectures that won’t survive the free-tier transition — they assume always-on origin servers, they batch poorly, they hammer the database when KV would do the job. By the time the dev team notices, the system can’t run cheaply because it was never designed to.

The book inverts this. The free-tier limits are treated as production targets. Cloudflare Workers’ 10ms CPU budget shapes the handler design. The 100,000 requests-per-day cap forces aggressive caching, request batching, and Cache-Control discipline. Supabase’s 500 MB storage limit shapes the schema toward narrow, indexed tables rather than wide denormalized ones. These constraints are not compromises — they push you toward architectures that scale linearly when you do eventually upgrade.

Mistake two: assuming “MVP” means “throwaway code.” The phrase “minimum viable product” has eroded into “minimum acceptable demo.” That’s why six-month MVPs become twelve-month rewrites. The $1,800 budget makes throwaway code unaffordable — you can’t afford the rewrite. So the constraint forces the opposite: protocol-first design, shared infrastructure, end-to-end test coverage from day one. The week-7 launch state in this book has 306 of 306 E2E tests passing because the tests were written alongside the code in weeks 2–6, not bolted on at the end.

The architectural discipline is what extends runway. If you reach 1,000 daily-active users on a $0/month stack, you have months — sometimes years — to find product-market fit before the bill arrives. If you reach 1,000 DAU on a $3,000/month stack, you need revenue inside 90 days.

A working approach

The four-sprint schedule:

1. Weeks 1–2 — Foundation Sprint. Domain registration, cloud accounts, database schema with row-level security on every table, authentication, deployment pipeline. The output: a Worker that takes a POST /api/auth/signup and returns a session token, with the response signed by your shared crypto service.
2. Weeks 3–4 — Protocol Sprint. MCP server registered, AP2 intent-mandate flow, ACP checkout protocol, shared protocol infrastructure (the 60%+ code-sharing pattern). The output: a Claude or ChatGPT user can invoke a tool that completes a real payment.
3. Weeks 5–6 — Integration Sprint. Google A2A bridge, marketplace architecture, commission system (server-side calculation, never trust client-sent amounts), Stripe webhook handler. The output: agents can discover the platform, transact, and the commission table reflects the truth.
4. Weeks 7–8 — Launch Sprint. Landing pages with Astro, DNS and SSL on the apex domain, monitoring on free tiers, launch checklist, smoke tests. The output: production traffic.

The free-tier stack table the book treats as ground truth:

Resource	Free Tier Limit	Where it shows up
Cloudflare Workers requests	100,000/day	Every API call
Workers CPU time	10 ms per invocation	Handler design
Workers KV reads / writes	100,000 / 1,000 per day	Nonce store, rate limit, cache
D1 rows read / written	5,000,000 / 100,000 per day	Edge-local relational data
R2 storage / egress	10 GB / unlimited	Assets, agent packages
Supabase DB storage	500 MB	Core relational tables
Supabase auth MAU	50,000	User accounts
Google Cloud credit	$300 (one-time)	A2A bridge, overflow

R2’s zero-egress pricing changes the math more than any single line item. AWS S3 charges $0.09 per GB transferred out. R2 charges $0 — forever. For a platform serving images, agent packages, or downloadable assets, that single difference eliminates the most unpredictable item on the cloud bill. Most teams budget for egress; this stack doesn’t.

The shared protocol pattern (chapter 4) is what makes the $1,800 budget work. Both AP2 and ACP need crypto, nonce validation, and mandate persistence. Instead of building two implementations, you build one shared service consumed by both — the book documents a real 69.5% code-sharing measurement, and the schema below is the unified mandate table that both protocols write to:

CREATE TABLE mandates (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  protocol_type TEXT NOT NULL CHECK (protocol_type IN ('ap2', 'acp')),
  protocol_metadata JSONB NOT NULL,
  signature_classical TEXT NOT NULL,
  signature_quantum TEXT NOT NULL,
  nonce TEXT NOT NULL UNIQUE,
  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

CREATE INDEX idx_mandates_protocol ON mandates(protocol_type);
ALTER TABLE mandates ENABLE ROW LEVEL SECURITY;

One table, both protocols, RLS on every row. New protocol support means a new value in protocol_type and a new JSONB shape — not a new table.

Where this scales

The article above is the eight-week spine. The full book extends in four directions:

• Day-by-day execution detail — what gets built Monday through Friday in each week, with checkpoints at the end of every two-week sprint that gate progress to the next phase.
• Complete budget line items — fixed costs, monthly recurring (it’s $0), tool and service costs, what the $1,800 does and does not cover.
• Scaling beyond free tiers — the upgrade-trigger framework, three scenarios (1K, 10K, 100K DAU), and which Cloudflare / Supabase tier matches each band.
• The launch checklist — pre-launch testing, DNS cutover, post-launch monitoring, and what to do when the first real traffic arrives.

The bonus setup checklist captures the same sequence in a checkable list you can paste into your project tracker.

Included with the book

• setup-checklist.md — week-by-week checklist mirroring the four sprints. Tracks every task with a checkpoint at the end of each two-week phase.
• setup-checklist.pdf — same checklist rendered for offline reading and printing.

Get the full picture

Readers of this also chose

Questions readers ask

Does the $1,800 cover salaries or just infrastructure and tools?

The $1,800 is the out-of-pocket cost for tools, domains, and services — not salaries. The book assumes you (or a small team) are doing the engineering. If you're paying contractors, that's a separate line item. The point of the playbook is that the infrastructure and tooling layer can run on free tiers; the labor side is whatever your team costs.

What if I'm not technical — can I still use this playbook?

The book is written for technical founders. Every chapter assumes you can write or direct code (including with AI assistants like Claude or Copilot). If you can scaffold a TypeScript project and deploy a Cloudflare Worker with wrangler deploy, you can ship the eight-week build.

Will this work for non-AI-commerce products?

The free-tier stack and the protocol-first discipline are generic. The specific examples (MCP server, AP2/ACP, agent marketplace) are AI-commerce. You can swap those for whatever protocols your product needs — the architecture pattern is the load-bearing piece, not the protocol names.

When do I have to start paying for infrastructure?

Chapter 8 covers this in detail. Roughly: Workers free tier covers ~2,000–5,000 daily-active users depending on calls per session. Supabase free tier covers ~50,000 MAUs. R2 stays free up to 10 GB. The book includes upgrade triggers — when revenue or usage justifies each next-tier line item — so you upgrade from profit, not from optimism.

What's the refund policy?

Lemon Squeezy's standard refund window applies. If the eight-week schedule doesn't fit your shape, the refund link is in the receipt email.