Explained so anyone can understand it. Then explained again so engineers can build it.
Imagine a mall. The mall has one parking lot, one power system, one security desk. But it has lots of stores inside — a shoe store, a food court, a barber shop. Each store has its own name, its own sign, its own customers. But they all share the building.
fortune0 is the mall. The stores are your products.
You own multiple domain names. Each one is a different door into the same building. Different people find different doors based on what they care about.
These aren't separate products. They're separate marketing channels for the same platform. One account works everywhere. One server runs everything. The domains are just SEO and branding.
A 404 error means: "this could exist, but nobody built it yet."
That's literally the problem fortune0 solves. Someone has an idea — a real estate business, an affiliate program, a privacy tool — and right now they hit a 404. It doesn't exist yet. There's no easy way to go from idea to running business.
fortune0 turns 404s into 200s. You show up, you pick what you want to build, and the platform gives you the tools to make it real. No code required. Just sign up and go.
Unlimited access to everything. Lower than every competitor. The price is so low it's a non-decision.
When someone uses the affiliate tools and makes money, the platform takes a small %. Tiered from 5% down to 3% based on volume. Aligned incentives — we only win when you win.
This is the simple version. Click "Technical" above for the architecture, or "Build It" for the step-by-step implementation plan.
For engineers, CTOs, and technical co-founders. How this actually works under the hood.
# In your domain registrar (GoDaddy, Namecheap, Cloudflare, etc.) fortune0.com CNAME → your-server.example.com death2data.com CNAME → your-server.example.com installkernel.com CNAME → your-server.example.com bootstrapprotocol.com CNAME → your-server.example.com # All four domains now point to the same server. # The server figures out which one the person typed.
@app.route('/')
def homepage():
# The server checks which domain the browser sent
host = request.headers.get('Host', '')
if 'death2data' in host:
return render_template('landing_d2d.html')
elif 'installkernel' in host:
return render_template('landing_ik.html')
elif 'bootstrapprotocol' in host:
return render_template('landing_bp.html')
else:
# fortune0.com or anything else → main landing
return render_template('landing_fortune0.html')
# BUT — every domain shares the same API:
# /api/activate → same endpoint regardless of domain
# /api/contacts → same endpoint
# /api/affiliates → same endpoint
# The branding changes. The backend doesn't.
1. User visits fortune0.com/start 2. Enters email → receives magic link (or enters email + password) 3. Server creates: - User record in central DB - Per-user SQLite database - Referral code (IK-XXXXXXXX) - Free tier flag (no payment yet) 4. User gets session token (cookie) 5. Cookie works across all domains (if using fortune0.com as auth domain) OR each domain validates the same session token via API FREE TIER: - Can use CRM (limited contacts) - Can browse standards - Can see affiliate program (can't withdraw) - Sees upgrade prompts PAID TIER ($1/mo via Stripe): - Unlimited everything - Affiliate payouts enabled - Full API access - MCP server access
fortune0.com → main landing page fortune0.com/start → signup fortune0.com/login → login fortune0.com/dashboard → user dashboard (after login) fortune0.com/re → real estate vertical landing fortune0.com/privacy → privacy vertical landing fortune0.com/build → builder/developer landing fortune0.com/earn → affiliate program landing fortune0.com/pricing → $1/month pitch # API (same server, /api prefix) fortune0.com/api/contacts → CRM fortune0.com/api/affiliates → affiliate engine fortune0.com/api/stats → dashboard data fortune0.com/api/standards/* → RESO, FHIR, FIX fortune0.com/health → uptime check
HMAC-signed license keys. Session tokens with 7-day expiry. Per-user database isolation — one user can never see another's data. Already built in main.py.
Most hosting platforms auto-provision TLS certificates via Let's Encrypt. Every domain gets the lock icon. No configuration needed.
100 requests per minute per IP. Prevents abuse. Built as middleware in the Flask app.
All database queries use parameterized statements. No string concatenation. Already done in main.py.
Shopify webhooks are HMAC-verified — the server cryptographically proves the webhook came from Shopify, not an attacker.
Per-user SQLite files. User data never mixes. Can export or delete any user's data instantly. GDPR-friendly by architecture.
BACKEND: Python 3.11 + Flask DATABASE: SQLite (per-user) + central SQLite AUTH: HMAC license keys + session tokens PAYMENTS: Stripe ($1/mo) + Stripe Connect (affiliate payouts) HOSTING: Any VPS ($5/mo), any PaaS, or your own machine DNS: Cloudflare (free) — manages all 4+ domains HTTPS: Auto-provisioned by host or Cloudflare MCP: Built-in /mcp endpoint for Claude Desktop MONITORING: /health endpoint + whatever your host provides WHAT YOU DON'T NEED: - No React frontend (server-rendered HTML is fine for now) - No Postgres (SQLite handles thousands of users) - No Redis (in-memory sessions are fine for MVP) - No Kubernetes (one process, scale when you need to) - No microservices (one Python server does everything)
Click "Build It" above for the exact step-by-step implementation checklist.
Exactly what to do, in order. No decisions to make — just follow the steps.
Goal: fortune0.com is live on the internet and you can show it to someone.
F0_LICENSE_SECRET=your-secret python3 server.py. Works on any VPS ($5/mo DigitalOcean, Linode, Hetzner), any PaaS (Railway, Fly, Render), or even your own Mac with a tunnel.@app.route('/') that returns HTML — a simple landing page with: logo, one-liner, email signup form, and links to /re, /privacy, /earn.You have a live website at fortune0.com with HTTPS, an API, and a landing page. You can put fortune0.com on a business card. It works. It's real.
Goal: People can sign up and log in. Free tier works.
Goal: People can pay $1/month. Affiliate commissions are tracked.
Goal: Merchants can install your app from the Shopify App Store.
Do not start Phase 4 until Phases 1-3 are deployed and working with real users. Ship the simple version first. The Shopify app is an expansion, not a prerequisite.
Flask API server (main.py) DONE
License key system (HMAC) DONE
Per-user SQLite databases DONE
Contact/Listing CRUD DONE
MCP endpoint DONE
RESO/FHIR/FIX standards DONE
Affiliate commission engine DONE
Referral code system DONE
Platform-agnostic deployment DONE
Landing page HTML ~1 hour
Email signup flow ~2 hours
Dashboard HTML ~4 hours
Stripe checkout ~3 hours
Merge affiliate into main.py ~2 hours
Domain DNS setup ~1 hour
Shopify app ~1 week
Embeddable widget ~3 days
~13 hours of coding + 1 hour of config gets you to a live platform at fortune0.com where people can sign up, pay $1/month, and use all the tools. The Shopify integration adds ~2 weeks on top of that.
Monthly cost: ~$10-15 (any $5/mo host + domain renewals). Revenue starts at first subscriber.
The architecture is intentionally simple. One Python process, SQLite for storage, runs on any host. This supports thousands of users before you need to think about Postgres, Redis, or horizontal scaling. The per-user SQLite pattern gives you data isolation, easy backup/restore, and GDPR compliance by default. When you outgrow it, the migration path is straightforward: swap SQLite for Postgres, add Redis for sessions, containerize with Docker. But don't do any of that until you have paying customers.
Everything you described makes sense. The "internet for implementing ideas" is real — it's a platform where someone shows up, picks a vertical, and gets working tools immediately. The 404 analogy is the entire pitch: "every idea that doesn't exist yet is a fortune waiting to happen. We turn 404s into products." The hard part isn't the code — most of it is already built. The hard part is shipping one thing before building the next. Deploy server.py. Point fortune0.com at it. Then iterate.