MVP Development

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

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 Clients

Client Prerequisites (they must provide):

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

Spin up a new project quickly with Titan

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

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.

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):

• 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.

2. 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)

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

​

Generate Legal Pages with AI

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

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).

​

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

   • Install the Browser MCP Chrome Extension
   • Add to Cursor MCP settings:
   Copy

   {
     "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

​

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).

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

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.

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

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