This page was last updated on: 15th May 2025

Important: Before starting MVP development:

  1. Complete Parent Company Setup first - this is done ONCE for your business entity (Ignore this if you’re just building for yourself for fun and no payments are involved)
  2. Complete Idea Validation for the specific product you’re building

This guide applies to BOTH:

  • Building your own products (under your company)
  • Building products for agency clients
1

Quick Prototype with an AI Site Builder

With the insights and initial PRD from your Granola and Grok conversations (as detailed in the Idea Validation page), use them to quickly create and launch a live landing page. This allows you to start gathering user interest immediately. Adding a waitlist at this stage is optional, but can be useful for collecting emails if you anticipate a longer development cycle (but waitlists aren’t mandatory).

This step focuses on creating your initial public-facing landing page. For this, consider AI-powered no-code tools like:

  • Lovable - Highly recommended for this stage for rapid public landing page creation and its smoother integration with Titan, especially if you choose to implement a waitlist. Lovable allows for rapid landing page creation and offers integration with services like Clerk for easy waitlist setup if you choose to implement one. See their guide: Lovable + Clerk Integration.
  • Emergent
  • bolt.new
  • Chef by Convex
  • Youware
  • Tempo - includes wireframes and user flows

The primary goal here is to get a functional public landing page deployed as fast as possible. You can iterate on its design later.

These tools can help you:

  • Optionally start collecting emails for a waitlist.
  • Get user feedback on your core value proposition and initial branding.
  • Test different messaging approaches before committing to more development.
  • Create a visual presence for potential investors or early adopters.

Once your landing page is live and you ‘think’ you’ve nailed the core value proposition, get further feedback by:

  1. (Optional) Deploying it and posting it to social media (LinkedIn, X, WhatsApp, etc.) in order to start collecting emails (if you’ve implemented a waitlist) and initial feedback
  2. Posting it in the Community Discord Server #roast-my-site channel (Community members will give you constructive criticism as to why this is a bad idea or what you can do to improve it)
  3. Using LandingAnalyze for free detailed analysis of copy, design, and conversion optimization

While you might explore several AI site builders, we recommend prioritizing getting one version live quickly. Our current favorite for this is Lovable due to its straightforward Clerk integration if you decide to set up a waitlist (see their Clerk Integration Guide). The exported files or the entire repository from this initial landing page (e.g., your Lovable project) should be saved. We will clone this prototype repository into a folder within your Titan project later to use as a direct reference. If you decide to publish the landing page immediately (with or without a waitlist), the social media feedback will directly inform the features and design of your subsequent documentation and full MVP.

2

Product-Specific Setup

Before diving into development, set up the product-specific infrastructure:

For Your Own Products

  1. Domain & Email

    • Purchase product domain (separate from your company domain)
    • You’ll either use your own personal email address or have a company email address already setup in Parent Company Setup
  2. Third-Party Services

    • Use your company’s (or your own) existing accounts:
      • Stripe (payment processing)
      • Supabase (database)
      • Clerk (auth)
      • Plunk (emails)
      • Vercel (deployment)
    • Set up new project within each service

For Agency owners, using your own accounts to setup and test the MVP is okay because the handover will be cleaner later when you transfer ownership of the services to the client.

See the Account Management Guide page for more details on how this works and how to transfer ownership of each service to the client, later.

For Agency Clients

Client Prerequisites (they must provide):

  • Brand assets (logo, colors, fonts)
  • Content and copy (ideally, but not required)

See the Account Management Guide page for more details on why you should use your own personal email address or have a company email address already setup in Parent Company Setup and don’t need the client to setup any of the 3rd-party services for the stack (like Supabase, Clerk, Stripe, etc.).

For agency work, clients should own all services and domains. This ensures clean handover and avoids billing/ownership complications.

3

Create a new Codebase

Spin up a new project quickly with Titan

Just run ‘Setup via CLI’ step in the Titan guide so that we simply create a new repository.

We will start building the actual product (MVP) in later steps, but there are a few things to do first, like generating the right documentation and embedding that in the codebase so that we have enough business and product context for the LLMs, and creating all the brand assets and landing page (especially if we want to start collecting emails and building a waitlist).

4

Requirements & Documentation

Import your Granola recording summary into Cursor and then use the below strategy to generate comprehensive documentation:

  1. Have a high-level conversation with Cursor in ‘Agent’ mode to generate:
  • Product Requirements Doc (PRD)
  • Technical Design Doc
  • Initial Database Schema
  • Landing Page Copy
  • Most common App User flows
  • System Architecture Diagram
  • UI/UX Design
  • Brand Identity Guidelines

For best results, use either gemini-2.5-pro (gemini-2.5-pro-preview-05-06) or claude-4-sonnet-thinking.

Example prompt:

You are a full-stack senior engineer.

I want to first have a high-level conversation with you to understand the MVP version of the idea that I would like to build, and then generate all the required documentation:

This is my idea:

[idea]

Here are the customer interview summaries from Granola:
[paste Granola summaries]

Before we generate the below documentation, let's have a high-level conversation to understand the idea and ensure we're on the same page.

Ask me questions to help you understand the idea better. Ask about edge cases, pricing models, APIs I might use, websites I know similar to what I'm building, etc. etc.

Get as much context as possible from me about the idea.

Initially use my idea to first create a markdown file in the docs folder called 'idea.md' that captures the high-level idea and business model and only the 1 or 2 core features that users can't live without. Those are the only features that should be included in the MVP.

Everytime you ask me a clarifying question, ask me if I am satisfied with the current state of the 'idea.md' file. Once I reply with a 'yes' (or similar), then you can help me generate the following detailed documentation files (for each of the below, create a new markdown file in the docs folder):

1) A high level product requirements doc (PRD) detailing the core feature/s of the MVP only, following this format:
  - Introduction: Problem statement and product vision (what is the painpoint we are solving)
  - Objectives & Goals: Core purpose and ideal outcomes
  - Target Users & Roles: User types and their actions
  - Core Features for MVP: Must-have functionality (Just 1 or 2 core features that users can't live without)
  - Future Scope: Features for later phases
  - User Journey: Step-by-step flows for each role
  - Tech Stack: Main Stack + 3rd Party libraries/providers/APIs to be used
2) A technical design doc (TDD) explaining what libraries and providers we should use to implement all the features (any 3rd party libraries if needed)
3) An updated database schema on top of my initial schema that lives at `db/schema/index.ts`

  Create any connections to these initial tables as needed.

  For each table, specify:
  - Any necessary database indexes for performance optimization (considering common query patterns - i.e. whether this will be a read-heavy or write-heavy app)
  - Row-Level Security (RLS) policies (since we're using Supabase) to control data access
  - Foreign key relationships and cascade behavior

  From our conversation, we would've extracted the recommendations for the pricing model, so based on that, decide whether I would need both a subscription pricing model or a one-time payment model.

  Use this as a reference for the pricing model decision:

  a. **Recurring Subscriptions**
   - Use when you provide ongoing value
   - Examples:
     - SaaS tools used regularly
     - Monitoring services
     - Continuous access platforms
   - Benefits:
     - Predictable revenue
     - Higher customer lifetime value
     - Easier to scale

  b. **One-Time Payments**
    - Use when value is delivered once
    - Examples:
      - Digital downloads
      - One-off transformations
      - Limited-time access
    - Benefits:
      - Simpler to manage
      - No recurring obligations
      - Clear value proposition

  c. **Hybrid Models**
    - Combine both payment types
    - Examples:
      - Course platform with setup fee + monthly access
      - Software with one-time purchase + optional subscription support
    - Benefits:
      - Maximizes revenue opportunities
      - Caters to different user preferences
      - Provides flexibility in pricing strategy

  Product Type Considerations:
    1. **Transformation Products**
      - Focus on one-time payments
      - Example: Fitness apps, course platforms
      - Emphasize testimonials and results

    2. **Utility Products**
      - Focus on subscription models
      - Example: Budget trackers, productivity tools
      - Highlight integrations and features

  Currency & Pricing Psychology:
    - Align currencies with target demographics
    - Use psychological pricing (e.g., $29 vs $30)
    - Configure Stripe for local currency handling

  If, for example, you think we should use a one-time payment model, then remove the subscriptions and subscription plans tables and remove the subscription_id from the invoices table.

  If only subscription plans are needed, then remove the one-time payment related tables and fields and any connections to them in the database schema.

  If both subscription plans and one-time payments are needed, then keep all the tables and fields and any connections to them in the database schema.

  4) A list of the most common user flows

  5) UI/UX Design of the main app/dashboard:
  - Create a minimal UI design focusing on core functionality
  - Explain the main user interactions and flows
  - Highlight key UI components and their purpose
  - Document accessibility considerations
  - Define responsive design approach

  6) System Architecture (in Mermaid.js):
  Generate a high-level system design diagram showing:
  - Key components and their relationships
  - Data flow between services
  - External API integrations
  - Infrastructure layout

  7) Brand Identity Guidelines:
  Based on the visual design of the landing page prototype created in Step 2 (e.g., with Lovable) and your overall product vision:
  - **Typography Recommendations:** Identify the primary fonts used in the prototype. Suggest a typographic hierarchy (headings, body text, captions) using these or complementary fonts that maintain the established style. Refer to [Google Fonts](https://fonts.google.com/) or [fontshare.com](https://www.fontshare.com/) for compatible options if variations are needed.
  - **Logo Style Recommendations:** Based on the prototype's aesthetic and your product's industry/target audience, describe an ideal logo style (minimal, illustrated, text-based, abstract, etc.) that would integrate well. This description can then be used with a logo generation tool or given to a designer.
  - **Color Palette Suggestions:** Identify the primary and secondary colors used in the prototype. Formalize this into a complete palette, suggesting 1-2 accent colors and neutrals that would complement this existing scheme and enhance the desired brand vibe for the entire product.

  Add these docs to a 'docs' folder at the root of the codebase.

You can use the @web tag in agent-mode to let Cursor search the web for inspiration and verify details (font names, colors, etc.)

5

Develop Full Brand Assets & Prepare Landing Page for Titan Integration

In Step 2 (“Quick Prototype with AI No-Code Tools”), you prototyped an initial landing page design and potentially gathered feedback if you chose to launch it. In Step 5 (“Requirements & Documentation”), you generated ‘Brand Identity Guidelines’. Now, let’s develop your full brand assets and prepare to integrate your validated landing page design into Titan.

  1. Develop Full Brand Assets (Logo, Colors, Font/s):

Agency clients will and should provide their own brand assets.

  • Refer to your ‘Brand Identity Guidelines’ (from docs/brand-identity-guidelines.md) if you’re building for yourself.
  • Create/Finalise your comprehensive logo using tools like logo.com, logoshaper.co, or ray.so/icon if the initial one was basic.
  • Finalise your complete color palette (primary, secondary, accent, neutrals) and typography. Use Design Inspiration libraries or a Colour Palette tool.

You can use this chrome extension to identify fonts on other websites: WhatFont

  1. Prepare Landing Page for Titan Integration (or Refine Live Version):
    • Your landing page prototype (e.g., from Lovable) serves as a validated design blueprint. The task now is to ensure its design is ready for your Titan project.
    • Option A (Refine Branding on Live AI-Built Page): If you chose to deploy your AI-built landing page and it allows, apply your finalized brand assets (logo, colors, fonts) to it directly. Ensure legal pages (from the next step) are linked in its footer.
    • Option B (Prepare for Titan Rebuild/Integration): If you plan to rebuild the landing page natively in your Titan-generated repo for maximum control (common for scaling), your AI-built landing page prototype serves as the validated blueprint. Your full brand assets will be applied during this Titan build process (see Step 8: Build MVP).

The goal is to have a polished brand identity and a clear plan for how your validated landing page design will live within your project.

Be sure to tag the docs folder (especially brand-identity-guidelines.md) when prompting with Composer or any AI tool for assistance with brand asset finalization.

Fonts should go in the public/fonts/ folder. Remove the default font in that folder (Sora.zip)

For Agency Work: Use the client’s provided brand assets and guidelines. If they don’t have any, help them develop these using the tools mentioned above before proceeding.

While launching a landing page with a waitlist in Step 2 was optional, having that early version (live or not) provides a solid design foundation for this stage.

6

Legal Pages

Every product needs legal documentation to protect both you and your users. Instead of expensive legal consultations for your MVP, use AI to generate these essential pages:

  1. Privacy Policy
    • Details how you collect, use, and protect user data
    • Required for GDPR, CCPA, and most app stores
  2. Terms of Service
    • Outlines rules for using your product
    • Protects you from liability and misuse
  3. Booking Terms (if applicable)
    • Specific terms for appointment/booking services
    • Cancellation policies and scheduling rules
  4. Refund Policy
    • Clear guidelines on when refunds are offered
    • Process for requesting refunds

Use this prompt with Cursor agent mode to generate all required legal pages for your MVP and save them to your documentation folder:

Update any variables in the prompt below with the correct values.

You are an excellent legal document specialist. I need your help to create three essential legal documents for my product: Privacy Policy, Terms of Service, and Refund Policy. Save each document as a separate markdown file in the /docs folder.

Here is the context about my product:

- Product name: [PRODUCT_NAME]
- Stack: Supabase, Clerk, Stripe, Plunk, Vercel, UserJot, DataFast (by Marc Lou) etc.
- Website URL: [YOUR_WEBSITE_URL_OF_THE_LIVE_LANDING_PAGE]
- Description: [BRIEF_PRODUCT_DESCRIPTION]
- Business model: [SUBSCRIPTION/ONE-TIME/FREEMIUM]
- User data collected: [LIST_OF_DATA_COLLECTED e.g., name, email, payment information]
- Non-personal data collection: Web cookies, Analytics.
- Data sharing practices: [WHO_YOU_SHARE_DATA_WITH or "we do not share data with third parties"]
- Refund policy: [YOUR_REFUND_POLICY e.g., full refund within 7 days of purchase]
- Ownership terms: [RIGHTS_AND_RESTRICTIONS e.g., users can use but not resell content]
- Governing law: [YOUR_JURISDICTION e.g., United States]
- Contact information: [YOUR_CONTACT_EMAIL]

Please create the following three documents:

1. A comprehensive Privacy Policy (saved as /docs/privacy-policy.md) covering:
   - Data collection practices
   - Use of cookies and tracking
   - How data is stored and protected
   - User rights regarding their data
   - Children's privacy protections
   - Policy update procedures
   - GDPR and CCPA compliance as applicable

2. Terms of Service (saved as /docs/terms-of-service.md) covering:
   - User rights and responsibilities
   - Acceptable use policy
   - Intellectual property rights
   - Limitation of liability
   - Account termination conditions
   - Dispute resolution
   - Changes to terms

3. Refund Policy (saved as /docs/refund-policy.md) covering:
   - Eligibility for refunds
   - Refund timeframe
   - How to request refunds
   - Exceptions or special conditions
   - Processing time for refunds

Format each document professionally with clear sections, using plain language where possible.
Include all standard protections and disclaimers typical for this type of product.

Ask me any clarifying questions about the documents too (especially if I've missed anything from the above).

For Agency Work: Generate these documents using the client’s company details and have them review and approve before implementation.

7

Setup Local Development Tools & Build MVP

Before building the MVP, set up essential development tools that will accelerate your workflow. Then continue to the Titan guide.

Essential Tool Setup

Set up these tools in your project to maximize development speed:

  1. TaskMaster - AI-powered task management

    • We’ll be using TaskMaster to help us manage our project. It’s a tool that helps us manage individual features and breaking them down into smaller tasks.
    • Follow the instructions on the TaskMaster GitHub repo to install the TaskMaster CLI and setup your project.
    • Use the MCP Server setup option in the README. It’s much faster.
  2. CodeRabbit - AI-Powered Code Reviews

    • CodeRabbit provides Free AI-driven code reviews directly in your Git workflow and IDE.
    • Helps catch bugs, improve quality, and speeds up reviews with line-by-line suggestions and PR summaries.
    • Install the Extension since we can’t use the App.
  3. StageWise - Precise UI refinements

    • Install from Cursor extensions marketplace
    • Press Cmd+Shift+P → search “StageWise” → “Auto Setup StageWise Toolbar”
    • Enables selecting UI elements directly in browser for precise updates (syncs with Cursor)
  4. BrowserMCP - Browser automation for testing

    {
      "mcpServers": {
        "browsermcp": {
          "command": "npx",
          "args": ["@browsermcp/mcp@latest"]
        }
      }
    }
    
    • Enables Cursor to automate tests of user flows and form interactions, take screenshots, get console logs, and more.
  5. Operative.sh MCP - Automated manual web app testing

    • Install via Operative.sh
    • Get free API key from operative.sh dashboard
    • Enables Cursor to automatically test your entire web app:
      • Runs end-to-end tests without writing test scripts
      • Tests edge cases and invalid inputs
      • Provides detailed test results and error logs
      • Shows live browser preview during tests
      • Integrates with Playwright for browser automation

See the Building Guide if you want detailed setup instructions and advanced usage of these tools.

Building the MVP

With your documentation, brand assets, a clean landing page design (from Step 2 & 5), and development tools (TaskMaster, StageWise, BrowserMCP) set up, it’s time to build the core MVP features.

Leveraging Your AI-Built Public Landing Page/Prototype: The public landing page you prototyped with an AI tool (e.g., Lovable in Step 2) is a valuable asset for your project’s public face.

  1. As a Reference: Keep the AI prototype project/files (e.g., cloned into docs/prototype_references/live_landing_page_v1/) open as a direct visual and functional reference for your public-facing pages in Titan.
  2. Content & Structure Migration: You can use an AI assistant like Cursor to help transfer the content and structure:
    • Point Cursor to your AI prototype’s repository or exported files.
    • Instruct it to analyze the landing page (HTML, CSS, content).
    • Ask it to replace or update Titan’s default public landing page components/content with the structure and text from your validated AI-built landing page.

Once you’ve added the landing page to the codebase, we can now start building the MVP (the core feature/s that makes the product what it is).

Focus on implementing the 1-2 core features identified in your PRD. The goal is a functional, testable product. Tell agent-mode in Cursor to use TaskMaster for everything.

See Titan - Building the Product, for the technical build process.

For Agency Work:

  • Regular client demos and feedback sessions
  • Document all development decisions
  • Keep credentials and access secure
  • Prepare for eventual handover
8

Beta Testing

Once the core MVP is done (1 main feature that is tested and works end-to-end), spread the word (marketing) to get some initial feedback.

See our Marketing Guide for more lots of strategies to get initial feedback.

If you’re simply building a product to show proof you’re proactive (to recruiters and hiring managers), then simply posting to LinkedIn and any personal social media is good enough (to get users)

Aggressively fix bugs and improve the product based on the feedback (UserJot). Continue to market.

Record product demos to help with marketing - using Cursorful

If people see that you squash bugs at lightning speed and deliver features so fast they can’t keep up, they’re drastically more likely to pay for your product and not churn.

Thankfully, Cursor can help you do this. Keep referring to the Building page for lots of tips and tricks. Make those workflows second nature.

For Your Own Products

  • Follow the Marketing Guide
  • Post to LinkedIn and social media
  • Collect user feedback via UserJot

For Agency Clients

  • Help set up analytics and feedback tools
  • Train client team on basic usage
  • Document common operations
  • Prepare user guides if needed
9

Official Launch & Decision Point

After 2-3 weeks of beta testing, you can continue to work on it or keep it on the backburner.

You have 2 options based on any ‘success’ so far:

Kill Criteria (Fast Fail)

  • Almost no users (paying or free)
  • Flat/declining signups
  • High churn → Document learnings and move to next idea

Scale Criteria (Keep Building)

If you have 20+ active users OR $100+ MRR:

  1. Product Development

    • Focus on features users want (UserJot)
    • Rapid bug fixes
    • Weekly releases
  2. Growth

    • Advertise for a technical co-founder via the #technical-hiring channel
    • Advertise for a marketing co-founder via the #marketing-hiring channel
    • Continue to work on the product, iterate fast, and market aggressively

For Agency Work

After successful launch:

  1. Final Handover

    • Transfer all documentation
    • Conduct handover training
    • Remove your access to services
    • Archive project materials
  2. Maintenance Plan

    • Define support terms
    • Set up monitoring
    • Establish update schedule
    • Document contact procedures