MVP Development

Spin up a new project quickly with Titan

Before writing any custom code, create all the documentation you need to make development buttery smooth:

Have a high level conversations with Cursor in ‘Composer’ mode to generate the following:

• Product Requirements Doc (PRD)
• Technical Design Doc
• Initial Database Schema
• Most common App User flows

Example prompt:

You are a full-stack senior developer.

You are building a new app for the following idea:

[idea]

Help me generate detailed markdown documentation for each of the following:
1) A high level product requirements doc (PRD) detailing the core features 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:
  model user {
    id                Int      @id @default(autoincrement())
    created_time      DateTime @default(now())
    email             String   @unique
    first_name        String?
    last_name         String?
    gender            String?
    profile_image_url String?
    user_id           String   @unique
    subscription      String?
  }

  model payments {
    id               Int      @id @default(autoincrement())
    created_time     DateTime @default(now())
    stripe_id        String
    email            String
    amount           String
    payment_time     String
    payment_date     String
    currency         String
    user_id          String
    customer_details String
    payment_intent   String
  }

  model subscriptions {
    id                        Int      @id @default(autoincrement())
    created_time              DateTime @default(now())
    subscription_id           String
    stripe_user_id            String
    status                    String
    start_date                String
    end_date                  String?
    plan_id                   String
    default_payment_method_id String?
    email                     String
    user_id                   String
  }

  model subscriptions_plans {
    id           Int      @id @default(autoincrement())
    created_time DateTime @default(now())
    plan_id      String
    name         String
    description  String
    amount       String
    currency     String
    interval     String
  }

  model invoices {
    id              Int      @id @default(autoincrement())
    created_time    DateTime @default(now())
    invoice_id      String
    subscription_id String
    amount_paid     String
    amount_due      String?
    currency        String
    status          String
    email           String
    user_id         String?
  }

  Create any connections to these initial tables as needed.
4) A list of the most common user flows

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

Setup a logo and some basic branding

1. Logo - https://www.logoshaper.co/
2. Typography - https://www.fontshare.com/ or https://www.freefaces.gallery/ (choose fonts that match your business style).

You can now customise your landing page with these assets.

Refer to the Rapid UI Prototyping Guide for detailed instructions on styling your landing page.

Be sure to tag the ‘docs’ folder when prompting with Cursor.

Once you’re done, you can get initial feedback by:

1. Posting your landing page in the Discord #roast-my-site channel (or the Telegram group) to get feedback from the community.
2. Use LandingAnalyze for free detailed analysis of:
   • Copy effectiveness
   • Design elements
   • Conversion optimization

It’s time to bring everything together into a working MVP.

1. If you’re happy with the database schema, ask Cursor to update your Prisma schema with a prompt like:

Update @prisma.schema with the database schema changes we need to allow for my idea's features.

See @docs/database-schema.md

Then run the database migration:

TODO: Add instructions for running the database migration.

2. Design the main app (private dashboard behind a login).

Follow our Recommended Workflow to rapidly build a prototype.

3. Build the core features incrementally with AI

See Prompt Engineering for effective prompts for building features, fixing bugs and refactoring code.

Repeat until MVP feature set is complete (Remember to create a new Composer chat for each feature).

Once the core MVP is done, spread the word (more marketing) to get some initial feedback.

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

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.

Initially your product may be free, so you can skip this step if you’re not charging for it.

If, however, you want to charge for premium features, you need to set your pricing strategy, and verify that payments are working.

Also, consider these key pricing factors:

Design Principles

• Keep design simple to focus on pricing and benefits
• Use a value-focused headline for clarity
• Place CTA buttons close to pricing
• List essential features only, avoiding clutter
• Add social proof (logos, testimonials) below pricing
• Highlight annual subscription discounts (20-30% savings)
• Implement social proof popups using SalesPopup to show recent transactions

Plan Structure - The simpler the better

1. Free Tier

   • Start with a simple free plan to attract users
   • Include basic but valuable features
   • Use as lead generation for premium plans

2. Pro Plan

   • Position as recommended option with visual cues
   • Price competitively ($29-99/month range)
   • Target growing teams/businesses, for example
   • Include most-requested features

3. Enterprise Plan (if applicable)

   • Custom solutions and premium support
   • Use “Contact Sales” CTA
   • Focus on scalability features

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
• Implement SalesNip for AI-powered price negotiations
• Test different price points with early users

Payment Models

Choose your payment model based on the type of value you deliver:

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

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

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

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