We Built 3 Products in 3 Months — Here's the Exact Stack and Process

We do not talk in hypotheticals. Here are three real products, their real timelines, and the exact stack and process behind each one.

BigDevSoon.me — Developer education platform, 12K+ users, core platform built in 5 days
BullAlert.ai — Crypto price alerts app, built in 2 weeks
JobTrackr.it — Job tracking app + Chrome extension, 1K+ users, built in 4 weeks

Same developer. Same tech stack. Same AI-first process. Different products, different complexities, consistent results.

Let us break down exactly how.

The Three Products

BigDevSoon — 5 Days to a Working Platform

BigDevSoon.me is a developer education platform where users learn by building real projects. The core features shipped in 5 days:

GitHub OAuth authentication
Project system with structured learning paths
Code editor with live browser preview (CodeMirror 6 + iframe sandbox)
User dashboard with progress tracking
Stripe payments for premium plans

Today it has 12,000+ registered users and runs on the same architecture we built in that initial sprint. The codebase has grown significantly since then, but the foundation — auth, payments, core loop, deployment — was solid from day one.

Key decision that saved time: We used Supabase for auth and database instead of building custom backends. That alone saved 2–3 days of work that would have gone into user management, session handling, and database migrations.

BullAlert.ai — 2 Weeks to Launch

BullAlert.ai is a crypto alerts application. Users set price thresholds for any cryptocurrency, and the app notifies them when prices cross those thresholds.

What we shipped in 2 weeks:

Email/password authentication via Supabase Auth
Alert configuration — select crypto, set price target, choose notification method
Real-time price tracking via external API integration
Notification delivery — email alerts via Resend
Dashboard — active alerts, alert history, account settings
Stripe billing — free tier + paid plans with higher alert limits

Key decision that saved time: Edge functions on Supabase for the price monitoring cron. No separate backend server, no container orchestration, no infrastructure to manage. One TypeScript function running on a schedule.

JobTrackr.it — 4 Weeks for App + Chrome Extension

JobTrackr.it is the most complex of the three. A job application tracker with a companion Chrome extension that auto-captures job listings from LinkedIn, Indeed, and other job boards.

What we shipped in 4 weeks:

Authentication with Supabase
Job tracking board — Kanban-style with drag-and-drop columns (Applied, Interview, Offer, Rejected)
Job detail pages — company, role, salary, notes, timeline
Chrome extension — captures job listing data from supported sites with one click
Analytics dashboard — application stats, response rates, timeline visualization
Stripe payments — free tier + premium with unlimited tracking
Transactional email — welcome flow, weekly summary, interview reminders

The Chrome extension added a full week to the timeline. Browser extensions have their own build pipeline, manifest configuration, content scripts, and a separate review process for the Chrome Web Store. If JobTrackr.it were web-only, it would have been a 3-week build.

Today it has 1,000+ users.

Bonus: VoidBalls.game — A Game in 10 Days

Not every product is a SaaS. VoidBalls.game is a 2D roguelite game published on Steam, built in 10 days. Different tech stack (game engine, not web), but the same principle: one developer with AI agents, ruthless scope control, and a fixed deadline.

It proves that the speed comes from process and experience, not from the specific technology.

The Universal Stack

Every web MVP we build uses the same core stack. Here is what it is and why.

Astro or Next.js — Frontend Framework

Astro for content-heavy sites, landing pages, and products where SEO matters from day one. It ships zero JavaScript by default and only hydrates interactive components (“islands architecture”). Our own site runs on Astro.

Next.js for application-heavy products where most pages are interactive. Dashboard-style apps, real-time features, complex client-side state.

Why not both? Some products use Astro for the marketing site and Next.js for the app. BigDevSoon.me’s landing page is Astro. The app is React.

Supabase — Backend and Database

Supabase replaces what used to require 3–4 separate services:

PostgreSQL database — production-grade, with Row Level Security
Authentication — GitHub, Google, email/password, magic links
Edge Functions — serverless TypeScript functions (Deno runtime)
Storage — file uploads with access control
Realtime — WebSocket subscriptions for live data

We do not build custom auth systems. We do not set up and manage databases. We do not write API frameworks from scratch. Supabase handles all of this out of the box, and we focus on building the actual product.

Cost for an MVP: Supabase’s free tier handles up to 50K monthly active users. Most MVPs never need to upgrade during the validation phase.

Vercel — Deployment and Hosting

Push to GitHub, Vercel builds and deploys. Preview deployments on every pull request. Production deploys on merge to main. SSL, CDN, edge caching — all automatic.

We set up CI/CD on day one of every project. There is no “we will figure out deployment later.” Every commit is deployable from the first day.

Stripe — Payments

Stripe Checkout for one-time payments. Stripe Billing for subscriptions. Stripe Customer Portal for self-service plan management. Webhooks for server-side payment events.

We have integrated Stripe enough times that the entire payment flow — from pricing page to webhook handler — takes less than a day.

Resend — Transactional Email

Welcome emails, password resets, receipts, notifications. Resend handles transactional email with a clean API and reliable delivery.

We configure SPF, DKIM, and DMARC records during setup. Emails land in inboxes, not spam folders.

Why This Specific Stack?

Familiarity breeds speed. We have shipped multiple production products on this exact combination. We know the edge cases. We know where Supabase’s Row Level Security gets tricky. We know how Vercel’s edge functions differ from Supabase’s. We know which Stripe webhook events to listen for and which to ignore.

When you use the same stack repeatedly, you stop Googling and start building. That is where the speed comes from — not from the technology itself, but from deep knowledge of how the pieces fit together.

AI-First Development with Claude Code

Here is where the process diverges from traditional development. We do not use AI as an autocomplete tool. We use it as a development partner.

Claude Code as the Primary Builder

Claude Code is our primary development tool. It reads the entire codebase, understands the architecture, and writes production-quality code. Not snippets — full features, with tests, error handling, and documentation.

A typical workflow:

We define the feature in plain English with specific requirements
Claude Code writes the implementation across multiple files
We review the code, adjust architecture decisions, and run tests
Claude Code handles the revisions based on our feedback

For a feature that would take a solo developer 4–6 hours, this loop completes in 1–2 hours. The quality is equivalent because we review every line.

The Agentic Pipeline

For larger features, we use a multi-agent approach:

Builder Agent — Writes the initial implementation. Given a feature spec, it generates the database schema, API routes, frontend components, and integration logic.

Review Agent — Reviews the Builder’s output against our coding standards, checks for security issues, validates error handling, and ensures consistency with the existing codebase.

QA Agent — Writes and runs tests. Unit tests for pure logic, integration tests for API routes, and E2E tests with Playwright for critical user flows.

This is not theoretical. This is how we build every day. The agents work from context files (CLAUDE.md, MEMORY.md) that encode our standards, patterns, and conventions.

Day-by-Day: A Typical 4-Week MVP Sprint

Here is how a typical project breaks down. The exact schedule varies by product, but the phases are consistent.

Week 1: Foundation (Days 1–7)

Day 1–2: Project Setup

Initialize repository with our starter template
Configure Supabase project (database, auth, storage)
Set up Vercel deployment with CI/CD
Create CLAUDE.md and MEMORY.md with project context
Deploy “Hello World” to production URL

By end of day 2, there is a live URL with automatic deployments. Every commit after this point is immediately visible.

Day 3–4: Authentication and Core Schema

Implement auth flow (sign up, sign in, password reset)
Design and create database schema for core entities
Set up Row Level Security policies
Build basic navigation and layout

Day 5–7: Core Feature Loop

Build the primary feature that defines the product
This is the thing users came for — the job board, the alert system, the project tracker
Focus on the happy path first, edge cases in week 2

Week 2: Feature Completion (Days 8–14)

Day 8–10: Core Feature Polish

Error handling and edge cases
Loading states, empty states, error states
Mobile responsiveness
Input validation

Day 11–12: Payments

Stripe integration (Checkout, Billing, or both)
Webhook handlers for payment events
Plan-based feature gating
Customer portal for self-service

Day 13–14: Transactional Email

Welcome email flow
Payment receipts
Key notifications (configurable per user)
Email template design

Week 3: Quality and Secondary Features (Days 15–21)

Day 15–17: Secondary Features

Features that support the core loop (settings, profile, analytics)
Admin utilities if needed
Import/export functionality

Day 18–19: Testing

Unit tests for business logic
Integration tests for API routes
E2E tests with Playwright for critical paths
Fix bugs found during testing

Day 20–21: Performance and Security

Performance audit (Core Web Vitals, bundle size)
Security review (RLS policies, input sanitization, rate limiting)
SEO fundamentals (meta tags, sitemap, robots.txt)

Week 4: Polish and Handover (Days 22–28)

Day 22–24: Final Polish

UI/UX refinements based on internal testing
Copy review and updates
Error message improvements
Analytics integration

Day 25–26: Documentation and AI Context

Finalize CLAUDE.md with complete project context
Write MEMORY.md with all architectural decisions
Create AGENTS.md with task-specific agent workflows
Notion Handover Guide with step-by-step instructions

Day 27: Handover Preparation

Set up dedicated Google profile with all SaaS services
Configure 1Password vault with every API key and credential
Final deployment verification
Transfer GitHub repository ownership

Day 28: Handover Day

Walk-through of the Notion guide
Verify client access to all services
Begin 4-week async support period

Mistakes and Lessons

We are not going to pretend everything goes perfectly. Here is what has actually slowed us down on past projects, and what we learned.

Underestimating Third-Party API Quirks

External APIs are the biggest wildcard in any project. The documentation says one thing, the actual behavior says another. Rate limits are not always documented. Error responses are inconsistent.

Lesson: We now budget 2x the estimated time for any feature that depends on a third-party API. If we estimate 4 hours for an integration, we plan for 8.

Premature Optimization

On one project, we spent a full day optimizing database queries that handled 100 rows. The product had 50 users. Those queries would not have been a problem until 10,000 users.

Lesson: Ship the straightforward implementation first. Optimize when real usage data tells you what is actually slow. PostgreSQL with proper indexes handles more traffic than most MVPs will ever see.

Scope Negotiation Is Hard

Founders are emotionally attached to their feature lists. Telling someone that 3 of their 8 “must-have” features should wait for v2 is an uncomfortable conversation. But it is a necessary one.

Lesson: We now have the scope conversation before any contract is signed. The scoping questionnaire we send after initial contact specifically asks founders to rank features. If they cannot cut any, the project is probably not a fit for a 4-week build.

Chrome Extensions Add a Week

Browser extensions are their own ecosystem. Manifest V3, content scripts, background workers, the Chrome Web Store review process — it is a separate product inside your product.

Lesson: We always quote an additional week for any project that includes a browser extension. JobTrackr.it confirmed this estimate.

What You Receive on Day 28

The handover is not just a GitHub link. Here is the complete list of deliverables:

Dedicated Google profile — Every SaaS service (Supabase, Vercel, Stripe, Resend, etc.) is connected to a Google account we create specifically for your project. Browser tabs are organized. Bookmarks are set. You log in and everything is there.
1Password vault — Every API key, every secret, every credential. Organized by service, documented with notes on what each key does and where it is used.
GitHub repositories — Full source code with complete commit history. You own it outright.
AI context files — CLAUDE.md, MEMORY.md, and AGENTS.md. The self-driving codebase that lets AI tools (or your next developer) understand the entire project in minutes.
Notion Handover Guide — Step-by-step documentation covering: how to deploy, how to add features, how to debug common issues, architecture overview, database schema explanation, and third-party service configuration.
Playwright test suite — End-to-end tests for critical user flows. Run them before every deploy to catch regressions.
Live Vercel deployment — Your product is already live with CI/CD configured. Push to main, it deploys automatically.
Resend email configuration — Transactional email is set up, tested, and sending. SPF, DKIM, and DMARC records configured for deliverability.
4 weeks async support — Questions, bug fixes, and guidance via Slack and Notion. Not an upsell — included in the $10K.

The Self-Driving Codebase in Practice

The AI context files deserve special attention because they are the most forward-looking part of the handover.

Here is a real example of what CLAUDE.md covers:

Project overview and business context
Complete tech stack with version numbers
File structure and naming conventions
Database schema with relationship explanations
Authentication flow details
API route patterns and conventions
Environment variables and their purpose
Deployment process
Testing conventions
Known limitations and planned improvements

When a developer (or even a non-technical founder using AI tools) opens this project 6 months later, they do not start from zero. The AI reads CLAUDE.md and understands the project as if it had been working on it from day one.

MEMORY.md captures the decisions that are not obvious from code alone. Why we chose one library over another. Which approaches we tried and abandoned. What the performance bottlenecks are. The institutional knowledge that usually walks out the door when a developer leaves.

AGENTS.md provides ready-made workflows: “To add a new feature, follow these steps.” “To fix a database migration issue, check these files.” “To deploy to staging vs production, use these commands.” It turns complex development tasks into repeatable processes that AI tools can execute.

The Numbers Tell the Story

We built BigDevSoon.me’s core platform in 5 days. It now has 12K+ users.

We built BullAlert.ai in 2 weeks. It monitors prices and sends alerts around the clock.

We built JobTrackr.it in 4 weeks, including a Chrome extension. It has 1K+ users tracking their job applications.

We built VoidBalls.game — a 2D roguelite game — in 10 days. It is on Steam.

Same developer. Same process. Different products. Consistent results.

This is what 10+ years of experience at companies like Ericsson, Sinch, Kinsta, Nutrient, and Mimica looks like when combined with AI-first development. Not faster because we cut corners — faster because we know exactly which corners do not need to exist.

Your MVP, 4 Weeks From Now

We take on 1 project per month. If you are reading this, there is likely a slot open in the next 1–2 months.

Here is how it works:

Apply — Tell us what you are building
Scope — We send a questionnaire and define the MVP together
Build — 4 weeks of focused development
Handover — Everything listed above, transferred to you
Support — 4 weeks of async help while you get settled

$10K flat. No hourly billing. No scope creep. No surprises.

Apply for your MVP slot — we respond within 24 hours.

Want to understand the cost landscape first? Read our complete MVP pricing breakdown for 2026.

Not sure what to look for in a developer? Here is our hiring checklist with 8 questions to ask.