In the last post, I talked about how my emotion chatbot idea pivoted into TalkWith.chat — a daily debate platform. This time, let's get into the nuts and bolts: how I chose the tech stack and designed the architecture to stay under $100/month.
🎯 The Three Constraints That Shaped Everything
Before picking any technology, I wrote down three hard rules:
- Under $100/month in total operating costs
- Zero server management — every hour spent on infra is an hour not spent on features
- Ship fast as a solo dev — no over-engineering
These constraints didn't limit my choices. They clarified them.
🏗️ The Stack at a Glance
| Layer | Choice | Why |
|---|---|---|
| Frontend | Next.js 15 (React 18, TypeScript) | Server components, great DX, Vercel-native |
| Hosting | Vercel | Zero-config deploys, generous free tier |
| Backend + DB | Supabase | PostgreSQL + Auth + Storage + Realtime, all in one |
| Styling | TailwindCSS | Rapid UI development, no CSS file sprawl |
| AI Content | Ollama + Qwen3 8B (local) | $0/month for content generation |
| Error Monitoring | Sentry | Catch bugs before users report them |
Let me walk through the key decisions.
⚡ Why Next.js + Vercel
I considered a few frontend options:
- Plain React SPA — cheap to host but terrible for SEO
- Remix — great framework, but smaller ecosystem
- Next.js — server components, API routes, middleware, and first-class Vercel integration
The deciding factor was Server Components. For a content-heavy platform like a debate site, server-side rendering directly impacts initial load speed and SEO. For a brand-new platform with no name recognition, organic traffic is a lifeline.
The Vercel pairing was a no-brainer. Push to GitHub, it deploys. No Docker, no CI/CD pipeline to maintain, no SSH-ing into a server at 2 AM. For a solo developer, this friction reduction is worth more than any performance benchmark.
Cost: $0 on the Hobby plan (with room to upgrade to Pro at $20/month when needed).
🗄️ Why Supabase Over Everything Else
This was the biggest decision. The alternatives I evaluated:
- Firebase — great DX, but vendor lock-in and Firestore's querying limitations felt risky for a debate platform with complex data relationships
- PlanetScale + separate auth — powerful, but more services to manage
- Self-hosted PostgreSQL — cheapest at scale, but the opposite of "zero server management"
- Supabase — PostgreSQL with batteries included
Supabase gave me four services in one dashboard:
Database — Full PostgreSQL. Row-level security policies mean I can enforce access control at the database level, not just in application code. For a platform where users read and write opinions, this matters a lot.
Authentication — Email, OAuth (Google, GitHub), magic links — all built in. I didn't write a single line of auth logic.
Storage — Profile images, uploaded assets. S3-compatible under the hood.
Realtime — Subscriptions for live updates when new opinions come in on a debate topic.
Cost: $0 on the free tier (500MB database, 1GB storage, 50K monthly active users). The $25/month Pro plan is there when I need it.
🤖 The $0 AI Strategy: Local Models
This is where the budget constraint got creative.
Any content platform faces the cold-start problem — no one wants to be the first to post. To seed initial content, I built a system with 100 diverse AI personas — different ages, personalities, and perspectives — that generate opinions on each day's debate topics. These are clearly labeled as AI-generated, so users always know what they're looking at.
Calling OpenAI or Anthropic APIs for this would cost hundreds of dollars monthly. Instead:
Ollama + Qwen3 8B runs locally on my development machine. The content generation pipeline is triggered by GitHub Actions on a daily schedule:
- Google Trends → fetch trending topics
- Local AI generates opinions from various personas
- Content is pushed to Supabase
The AI never touches production servers. It's a batch job that runs on my machine, generates content, and uploads the results. Total API cost: $0/month.
The tradeoff? Generation is slower and quality is slightly below GPT-4. But for simulating diverse opinions in a debate, Qwen3 8B is more than good enough — especially when you have 100 personas with distinct system prompts adding variety.
🎨 TailwindCSS: The Solo Dev's Best Friend
I'll keep this short because the choice is straightforward. When you're building alone:
- You don't want to context-switch between component files and CSS files
- You don't want to name things (
.debate-card-header-activegets old fast) - You want to iterate on UI fast
Tailwind lets me style directly in JSX. The result is ugly code and beautiful UI. I'll take that trade every time.
📊 The Monthly Bill
Here's what the stack actually costs right now:
| Service | Plan | Cost |
|---|---|---|
| Vercel | Hobby | $0 |
| Supabase | Free | $0 |
| Sentry | Developer | $0 |
| Ollama | Local | $0 |
| GitHub Actions | Free tier | $0 |
| Total | $0/month |
Yes, really. The platform is running at $0 right now.
So what happens when users start coming in? Here's my projected cost at 1,000 DAU:
| Service | Change | Projected Cost |
|---|---|---|
| Vercel | Upgrade to Pro | $20/month |
| Supabase | Upgrade to Pro | $25/month |
| AI Content | 5 topics/day × 100 persona opinions + content moderation | $10~20/month |
| Sentry | Team | $0 (within free limits) |
| Total | ~$55~65/month |
The AI cost stays at $0 if I keep using local models only. But at 1,000 DAU, I'd likely mix in some API calls (e.g., GPT-4o-mini) for better content quality and moderation accuracy. Even then, it stays well under the $100 ceiling.
🧪 Tradeoffs I Accepted
Every stack has tradeoffs. Here are the ones I made deliberately:
Supabase's free tier has cold starts. The database pauses after inactivity. I knew this going in — it's fine for development, and I'll upgrade to Pro before launch to ensure a snappy experience.
Next.js App Router has a learning curve. Server Components, Client Components, the "use client" directive, caching behavior — it took time to get comfortable. But once I did, the mental model clicked, and the server-first approach pays off in performance where it matters most.
Local AI generation trades reliability for cost. Qwen3 8B occasionally produces off-topic or repetitive content. I built validation and retry logic to handle this, and for bootstrapping seed content, the quality-to-cost ratio is hard to beat.
⏭️ Coming Up Next
Post #3: "100 AI Personas Debating Every Day" will cover how I built the AI content generation system — the persona design, the generation pipeline, and how local models can produce surprisingly diverse opinions.
💬 TalkWith.chat is a debate platform where you can share quick opinions on trending topics every day. Launching soon.
What's your go-to stack for side projects? Have you tried running local AI models for content generation? Let me know in the comments!
Top comments (0)