Solo Developer Guide
From Idea to Production
A comprehensive step-by-step cookbook for building full-stack applications on Vercel. Each phase includes a copyable prompt you can paste directly into v0.
Pro tip: For planning phases (1-2), use Gemini with Canvas to brainstorm and organize visually, then bring your refined plan to v0 to start building.
New to Vercel?
Watch this quick introduction to understand the platform before diving in.
9
Phases
50+
Checklist Items
1
Developer
100%
Production Ready
Start Here: Research Prompt for Gemini
Copy this master prompt into Gemini to compile a complete learning guide with videos, docs, and resources
You are a research assistant helping me create a comprehensive learning guide for Vercel and v0 (Vercel's AI-powered development platform). I need you to do deep research and compile resources organized by skill level. ## Research Objective Find and organize the best learning resources for building full-stack applications using Vercel's ecosystem, including: - **v0.dev** (AI-powered code generation) - **Vercel Platform** (deployment, hosting, edge functions) - **Next.js** (the React framework Vercel created) - **Vercel AI SDK** (for building AI applications) - **Integrations** (Supabase, Neon, Stripe, etc.) ## What I Need You to Find ### 1. YouTube Videos & Tutorials Search for and organize videos by skill level: - **Beginner**: "v0 tutorial for beginners", "Vercel getting started", "Next.js crash course 2024/2025", "deploy first app Vercel" - **Intermediate**: "v0 full stack app tutorial", "Next.js App Router deep dive", "Vercel serverless functions", "Supabase Next.js authentication" - **Advanced**: "Vercel edge functions", "Next.js performance optimization", "AI SDK streaming", "production-ready Next.js" For each video, provide: - Title and creator - Direct YouTube link - Duration - Skill level (Beginner/Intermediate/Advanced) - Key topics covered - Why it's valuable ### 2. Official Documentation & Guides Find the essential docs: - v0.dev documentation and examples - Vercel official docs (deployment, environment variables, domains) - Next.js documentation (App Router, Server Components, Server Actions) - Vercel AI SDK documentation - Integration guides (Supabase, Neon, Stripe) ### 3. Blog Posts & Articles Search for high-quality written content: - Vercel blog posts about best practices - Dev.to and Medium articles about v0 and Vercel - Case studies of apps built with v0 - Comparison articles (v0 vs other tools) ### 4. GitHub Repositories & Templates Find starter templates and example projects: - Official Vercel templates - v0 example projects - Next.js starter kits with authentication - Full-stack SaaS templates ### 5. Community Resources - Vercel Discord server - Reddit communities (r/nextjs, r/vercel) - Twitter/X accounts to follow - Newsletter recommendations ## Output Format Please organize your findings in a structured format: ### BEGINNER TRACK (0-3 months experience) **Goal**: Deploy your first app and understand the basics [Videos] 1. [Title] - [Creator] - [Duration] - [Link] Topics: ... [Documentation to Read] ... [Projects to Build] ... --- ### INTERMEDIATE TRACK (3-12 months experience) **Goal**: Build full-stack applications with databases and auth [Same structure] --- ### ADVANCED TRACK (1+ year experience) **Goal**: Production-ready apps with performance optimization [Same structure] --- ### QUICK REFERENCE - Best single video to start: ... - Best documentation page: ... - Best template to fork: ... - Estimated time to competency: ... ## Additional Instructions - Prioritize content from 2024-2025 (recent and up-to-date) - Focus on practical, hands-on tutorials over theoretical content - Include free resources primarily, but note premium courses if exceptionally valuable - Verify links are working and content is still relevant - Note if any resource is particularly well-produced or highly recommended by the community Please begin your deep research and compile a comprehensive guide.
How to use: 1. Copy the prompt above 2. Go to gemini.google.com 3. Enable "Deep Research" mode 4. Paste the prompt and let Gemini compile your personalized learning guide 5. Return here with your plan and start building with the phase prompts below
Phase 1
Discovery & Planning
Define your product vision, target users, and MVP scope before writing any code.
Define Your Product
- Core problem:Write a 1-sentence problem statement
- Target users:Create 2-3 user personas (name, role, pain points, goals)
- Success metrics:Define 3-5 measurable KPIs
- MVP scope:List the absolute minimum features needed to validate the idea
Deliverables
0/3Planning Tip
For planning phases, consider using Gemini with Canvas to brainstorm and organize your thoughts visually. Once you have a clear plan, come back to v0 to start building.
I'm starting a new project and need help with discovery and planning. Here's what I'm building: [DESCRIBE YOUR APP IDEA IN 2-3 SENTENCES] Please help me create: 1. **Problem Statement**: A clear 1-sentence description of the core problem we're solving 2. **User Personas**: 2-3 detailed personas including: - Name and role - Pain points - Goals and motivations - How they'll use this product 3. **Success Metrics**: 3-5 measurable KPIs to track 4. **MVP Feature List**: Prioritized list of features categorized as: - Must Have (launch blockers) - Should Have (important but not critical) - Nice to Have (future iterations) 5. **1-Page Product Brief**: A concise summary document Format the output so I can save it as my planning document.
Phase 2
Technical Architecture
Choose your technology stack and define your project structure.
Recommended Vercel Stack
| Layer | Technology |
|---|---|
| Framework | Next.js 16 (App Router) |
| Styling | Tailwind CSS v4 + shadcn/ui |
| Database | Supabase or Neon |
| Auth | Supabase Auth or custom |
| File Storage | Vercel Blob or Supabase Storage |
| AI Features | Vercel AI SDK + AI Gateway |
| Payments | Stripe |
| Hosting | Vercel |
| Monitoring | Vercel Analytics + Sentry |
Project Structure
/app
/api → API routes & server actions
/(auth) → Auth pages (login, signup)
/(dashboard) → Protected app pages
/page.tsx → Landing page
/components
/ui → shadcn components
/features → Feature-specific components
/lib
/db.ts → Database client
/auth.ts → Auth utilities
/utils.ts → Helper functions
/scripts → Database migrationsDeliverables
0/3Planning Tip
For planning phases, consider using Gemini with Canvas to brainstorm and organize your thoughts visually. Once you have a clear plan, come back to v0 to start building.
I need help planning the technical architecture for my application. **Project Overview:** [PASTE YOUR 1-PAGE PRODUCT BRIEF OR DESCRIBE YOUR APP] **Key Features:** [LIST YOUR MUST-HAVE FEATURES] Please help me create: 1. **Technology Stack Recommendations**: For each layer (framework, styling, database, auth, storage, payments, hosting), recommend the best option and explain why 2. **Database Schema Design**: - List all entities/tables needed - Define relationships between them - Suggest key fields and data types - Include any indexes needed for performance 3. **API Endpoint List**: - Group by feature area - Include HTTP method, path, and brief description - Note which require authentication 4. **Project Folder Structure**: - Recommended file organization - Where different types of code should live 5. **Architecture Diagram**: - Describe the components and how they connect - Note any external services Keep recommendations focused on the Vercel/Next.js ecosystem.
Phase 3
Design & Prototyping
Create your design system and build high-fidelity mockups in v0.
Design System Setup
In v0, you get shadcn/ui pre-configured. Customize your theme in globals.css:
@theme inline {
--background: #ffffff;
--foreground: #0a0a0a;
--primary: #2563eb;
--primary-foreground: #ffffff;
/* Define 3-5 colors total */
}Design Workflow
- Wireframe in v0: Describe your pages, let v0 generate initial layouts
- Use GenerateDesignInspiration: For any page, ask v0 to generate design direction
- Iterate visually: Use v0's Design Mode to refine styles
- Component library: Build reusable components as you go
Key Pages to Design
0/5I'm ready to start designing my application in v0. **Project:** [YOUR APP NAME] **Description:** [1-2 SENTENCE DESCRIPTION] **Target Users:** [WHO WILL USE THIS] **Mood/Vibe:** [e.g., "Professional and clean", "Fun and playful", "Dark and modern"] Please help me: 1. **Create a Design System**: - Suggest a color palette (3-5 colors max) that fits my vibe - Recommend font pairings - Define spacing and sizing scales - Generate the globals.css theme tokens 2. **Design the Landing Page**: - Hero section with clear value proposition - Key features section - Social proof / testimonials area - CTA sections - Footer Make it visually polished and production-ready. Use modern design patterns and ensure it's fully responsive.
Phase 4
Foundation Development
Set up your database, authentication, and core infrastructure.
Database Setup
- Connect integration: Click "Connect" in sidebar → Add Supabase or Neon
- Create schema: Write SQL migration in
/scripts/001-initial-schema.sql - Run migration: v0 can execute scripts directly
-- scripts/001-initial-schema.sql
CREATE TABLE users (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
email TEXT UNIQUE NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE TABLE projects (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID REFERENCES users(id),
name TEXT NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW()
);Authentication Options
Supabase Auth (Recommended)
- Use @supabase/ssr package
- Implement middleware for session refresh
- Add Row Level Security (RLS) policies
Custom Auth
- Hash passwords with bcrypt
- Use HTTP-only cookies for sessions
- Store sessions in database
Core Infrastructure
0/5I need to set up the foundation for my application with database and authentication. **My App:** [APP NAME AND BRIEF DESCRIPTION] **Database Schema I Need:** [PASTE YOUR SCHEMA FROM PHASE 2, OR DESCRIBE YOUR MAIN ENTITIES] Please help me: 1. **Set Up Database**: - Connect Supabase (or Neon) integration - Create the SQL migration script in /scripts/001-initial-schema.sql - Include proper indexes and constraints - Add Row Level Security (RLS) policies for Supabase 2. **Set Up Authentication**: - Implement Supabase Auth with email/password - Create login and signup pages - Add protected route middleware - Handle session management 3. **Create Base Layout**: - Navigation component with auth state - Protected layout wrapper - Loading and error states 4. **Error Handling**: - Global error boundary - Toast notifications for user feedback Run the database migration after creating the script.
Phase 5
Feature Development
Build your features systematically, from core MVP to polish.
Development Order
Tier 1: Core MVP
- User dashboard (home after login)
- Primary CRUD operations for main entity
- Basic search/filtering
- Simple data display (tables, cards)
Tier 2: Essential Features
- Advanced workflows
- Notifications (email or in-app)
- Data export (CSV, PDF)
- Basic analytics/reporting
Tier 3: Polish
- Bulk operations
- Advanced filtering/sorting
- Customization options
- Performance optimization
Development Workflow in v0
1. Describe the feature you want
2. v0 generates code
3. Test in preview
4. Iterate with feedback
5. Commit to GitHub (optional)
6. Deploy to VercelBest Practices
0/5I'm ready to build a feature for my application. **Feature Name:** [NAME OF THE FEATURE] **Description:** [WHAT SHOULD THIS FEATURE DO] **User Story:** As a [USER TYPE], I want to [ACTION] so that [BENEFIT]. **Acceptance Criteria:** - [CRITERION 1] - [CRITERION 2] - [CRITERION 3] **Database Tables Involved:** [LIST TABLES OR "NONE"] Please build this feature with: 1. **Database Changes** (if needed): - Migration script for any new tables/columns - Update RLS policies if using Supabase 2. **API/Server Actions**: - Server actions or API routes needed - Proper error handling - Input validation 3. **UI Components**: - Main feature component(s) - Form handling with validation - Loading states - Error states - Empty states 4. **Integration**: - Connect to existing navigation - Add to protected routes if needed Follow best practices: server components where possible, split into reusable components, use TypeScript, mobile-first design.
Phase 6
Integration & Testing
Connect third-party services and ensure everything works correctly.
Third-Party Integrations
| Integration | How to Add |
|---|---|
| Stripe | Connect in sidebar - Add Stripe |
| Email (Resend) | Add RESEND_API_KEY in Vars |
| AI features | Use AI Gateway (zero config) |
| Analytics | Vercel Analytics (automatic) |
Manual Testing Checklist
0/5Performance Checklist
0/4I need to add integrations and test my application. **Current App State:** [BRIEFLY DESCRIBE WHAT'S BUILT] **Integrations I Need:** - [ ] Stripe (payments) - [ ] Email (Resend) - [ ] AI features - [ ] Analytics - [ ] Other: [SPECIFY] Please help me: 1. **Set Up Selected Integrations**: - Guide me through connecting each service - Create necessary API routes/webhooks - Add environment variables needed 2. **Create a Testing Checklist**: - List all user flows to test - Include edge cases - Note any specific test scenarios 3. **Performance Audit**: - Check image optimization - Review bundle size - Identify any performance issues - Suggest optimizations 4. **Fix Any Issues Found**: - Address problems identified during testing - Improve error handling where needed
Phase 7
Pre-Launch Preparation
Configure your production environment and finalize SEO.
Production Environment
- Connect Vercel: In v0 sidebar - Settings - Connect Vercel Project
- Set Environment Variables: Add production keys in Vercel dashboard
- Custom Domain: Add in Vercel - Project - Domains
- SSL: Automatic with Vercel
Environment Variables
# Database
DATABASE_URL=
# Auth (if using Supabase)
NEXT_PUBLIC_SUPABASE_URL=
NEXT_PUBLIC_SUPABASE_ANON_KEY=
SUPABASE_SERVICE_ROLE_KEY=
# Payments (if using Stripe)
STRIPE_SECRET_KEY=
NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=
# Other services
RESEND_API_KEY=SEO & Metadata
export const metadata = {
title: 'Your App Name',
description: 'Clear description of what your app does',
openGraph: {
title: 'Your App Name',
description: '...',
images: ['/og-image.png'],
},
}Pre-Launch Checklist
0/8I'm preparing to launch my application. Please help me get production-ready. **App Name:** [YOUR APP NAME] **Description:** [1-2 SENTENCES FOR SEO] **Domain:** [YOUR DOMAIN OR "will set up later"] Please help me: 1. **Production Environment Setup**: - Guide me through connecting my Vercel project - List all environment variables I need to set - Verify all integrations work in production mode 2. **SEO & Metadata**: - Update layout.tsx with proper metadata - Create OpenGraph image (or guide me to create one) - Add proper title and description - Set up robots.txt and sitemap if needed 3. **Final Pages**: - Create a styled 404 page - Add error boundary with nice UI - Create privacy policy page (template) - Create terms of service page (template) 4. **Pre-Launch Checklist**: - Run through all items - Fix any issues found - Confirm everything is production-ready
Phase 8
Launch
Deploy your application and announce it to the world.
Soft Launch
- Deploy: Click "Publish" in v0 or push to connected GitHub repo
- Test production: Verify everything works with real data
- Invite beta users: 5-10 trusted users
- Collect feedback: Use a simple form or direct communication
Full Launch
- Announce: Share on social media, communities
- Monitor: Watch Vercel Analytics and error logs
- Respond quickly: Fix critical bugs same-day
- Document: Note any issues for future reference
Launch Day Checklist
0/4I'm ready to launch! Please help me with the launch process. **App:** [APP NAME] **URL:** [YOUR PRODUCTION URL] Please help me: 1. **Final Pre-Launch Verification**: - Test all critical user flows one more time - Verify production environment is working - Check all integrations in production mode 2. **Soft Launch Preparation**: - Create a feedback collection form or method - Identify 5-10 beta users to invite - Prepare a brief onboarding message for them 3. **Launch Monitoring Setup**: - Ensure Vercel Analytics is working - Set up error monitoring alerts - Create a simple uptime check 4. **Launch Announcement Draft**: - Write a social media announcement - Create a brief product hunt / launch description - List communities where I should share 5. **Contingency Plan**: - Document rollback procedure - List common issues and fixes - Prepare support response templates
Phase 9
Post-Launch Operations
Maintain, monitor, and continuously improve your application.
Ongoing Maintenance
Daily
- Check error logs (Vercel + Sentry)
- Respond to user issues
Weekly
- Review analytics
- Prioritize bug fixes
- Plan small improvements
Monthly
- Dependency updates
- Security review
- Performance audit
- Feature roadmap review
Scaling Checklist
0/5Feature Evolution
- Collect feature requests systematically
- Prioritize based on user impact
- Build in iterations (don't wait for "perfect")
- A/B test when unsure
My app is live and I need help with post-launch operations. **App:** [APP NAME] **Launch Date:** [WHEN DID YOU LAUNCH] **Current Issues/Feedback:** [ANY IMMEDIATE CONCERNS] Please help me: 1. **Set Up Operational Rhythm**: - Create a daily monitoring checklist - Set up weekly review template - Monthly maintenance schedule 2. **Analytics Review**: - Help me understand my Vercel Analytics data - Identify key metrics to track - Set up custom events if needed 3. **Performance Optimization**: - Audit current performance - Identify bottlenecks - Implement caching where needed - Add database indexes for slow queries 4. **Feature Roadmap**: - Organize collected feedback - Prioritize next features - Create a simple roadmap 5. **Scaling Preparation**: - Review current architecture for scale - Identify potential bottlenecks - Plan for increased traffic
Reference
Quick Reference
Essential commands and workflows at a glance.
v0 Workflow
DESCRIBE
Tell v0 what you want to build
GENERATE
v0 creates code
PREVIEW
Test in browser preview
ITERATE
Refine with feedback
CONNECT
Add integrations (DB, auth, payments)
DEPLOY
Publish to Vercel
MONITOR
Use Vercel Analytics
Key Commands
| Task | How |
|---|---|
| Start project | Open v0.dev, describe your app |
| Add database | Sidebar → Connect → Supabase/Neon |
| Run migration | Ask v0 to execute script |
| Add env vars | Sidebar → Vars |
| Deploy | Click "Publish" button |
| Custom domain | Vercel Dashboard → Domains |
| View logs | Vercel Dashboard → Logs |
Start small. Ship fast. Iterate based on real user feedback.
The key to success is not building the perfect app on day one, but getting something in front of users quickly and improving from there.