Product-Market Fit | Bootspring Docs

The Product-Market Fit (PMF) workflow helps you measure whether your product truly satisfies market demand. Using the Sean Ellis survey, retention analysis, and qualitative signals, this guide provides a systematic approach to understanding and achieving PMF.

Overview#

Property	Value
Methods	3 (Survey, Retention, Qualitative)
Tier	Free
Typical Duration	Ongoing measurement
Best For	Early-stage startups validating product

Outcomes#

A successful PMF measurement process delivers:

Clear PMF score using the Sean Ellis methodology
Retention benchmarks for your category
Qualitative understanding of user value
Action plan to improve PMF if needed
Confidence to scale (or not)

What is Product-Market Fit?#

Marc Andreessen's definition:

"Product-market fit means being in a good market with a product that can satisfy that market."

In practice, PMF feels like:

Users actively seeking out your product
Word-of-mouth growth happening naturally
Retention curves that flatten (not decline to zero)
Clear value proposition that resonates

                    NO PMF                              PMF
              ┌────────────────┐              ┌────────────────┐
              │ Pushing users  │              │ Users pulling  │
              │ to try product │              │ for product    │
              ├────────────────┤              ├────────────────┤
              │ High churn     │              │ Strong         │
              │ flat retention │              │ retention      │
              ├────────────────┤              ├────────────────┤
              │ Unclear value  │              │ Clear "aha"    │
              │ proposition    │              │ moment         │
              ├────────────────┤              ├────────────────┤
              │ Struggling to  │              │ Organic growth │
              │ get traction   │              │ happening      │
              └────────────────┘              └────────────────┘

Method 1: Sean Ellis Survey (PMF Score)#

The Question#

Ask users who have experienced your core value:

"How would you feel if you could no longer use [Product]?"

Answer options:

Very disappointed
Somewhat disappointed
Not disappointed

The Benchmark#

40% or more answering "very disappointed" indicates PMF.

PMF Score	Interpretation
40%+	Strong PMF - ready to scale
25-40%	Getting close - iterate
<25%	Not yet PMF - major changes needed

Implementation#

Database Schema:

// prisma/schema.prisma
model PMFSurvey {
  id          String   @id @default(cuid())
  userId      String
  response    PMFResponse
  feedback    String?
  userSegment String?
  createdAt   DateTime @default(now())

  user        User     @relation(fields: [userId], references: [id])
}

enum PMFResponse {
  VERY_DISAPPOINTED
  SOMEWHAT_DISAPPOINTED
  NOT_DISAPPOINTED
}

Survey Component:

// components/PMFSurvey.tsx
'use client';

import { useState } from 'react';

export function PMFSurvey({ onComplete }: { onComplete: () => void }) {
  const [response, setResponse] = useState<string | null>(null);
  const [feedback, setFeedback] = useState('');
  const [step, setStep] = useState(1);

  async function handleSubmit() {
    await fetch('/api/surveys/pmf', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ response, feedback }),
    });
    onComplete();
  }

  if (step === 1) {
    return (
      <div className="p-6 max-w-md mx-auto bg-card rounded-lg border">
        <h3 className="text-lg font-semibold mb-4">
          How would you feel if you could no longer use [Product]?
        </h3>
        <div className="space-y-3">
          {[
            { value: 'VERY_DISAPPOINTED', label: 'Very disappointed' },
            { value: 'SOMEWHAT_DISAPPOINTED', label: 'Somewhat disappointed' },
            { value: 'NOT_DISAPPOINTED', label: 'Not disappointed' },
          ].map((option) => (
            <label
              key={option.value}
              className={`flex items-center p-3 rounded border cursor-pointer ${
                response === option.value
                  ? 'border-primary bg-primary/10'
                  : 'border-border hover:border-primary/50'
              }`}
            >
              <input
                type="radio"
                name="pmf"
                value={option.value}
                checked={response === option.value}
                onChange={(e) => setResponse(e.target.value)}
                className="mr-3"
              />
              {option.label}
            </label>
          ))}
        </div>
        <button
          onClick={() => setStep(2)}
          disabled={!response}
          className="mt-4 w-full py-2 bg-primary text-primary-foreground rounded disabled:opacity-50"
        >
          Continue
        </button>
      </div>
    );
  }

  return (
    <div className="p-6 max-w-md mx-auto bg-card rounded-lg border">
      <h3 className="text-lg font-semibold mb-4">
        {response === 'VERY_DISAPPOINTED'
          ? 'What do you love most about [Product]?'
          : 'What would make [Product] a must-have for you?'}
      </h3>
      <textarea
        value={feedback}
        onChange={(e) => setFeedback(e.target.value)}
        placeholder="Your feedback..."
        className="w-full p-3 border rounded min-h-[100px]"
      />
      <button
        onClick={handleSubmit}
        className="mt-4 w-full py-2 bg-primary text-primary-foreground rounded"
      >
        Submit
      </button>
    </div>
  );
}

API Endpoint:

// app/api/surveys/pmf/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { prisma } from '@/lib/prisma';
import { auth } from '@/lib/auth';

export async function POST(request: NextRequest) {
  const session = await auth();
  if (!session?.user) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
  }

  const { response, feedback } = await request.json();

  await prisma.pMFSurvey.create({
    data: {
      userId: session.user.id,
      response,
      feedback,
    },
  });

  return NextResponse.json({ success: true });
}

Calculating PMF Score:

// lib/analytics/pmf.ts
export async function getPMFScore() {
  const responses = await prisma.pMFSurvey.groupBy({
    by: ['response'],
    _count: true,
  });

  const total = responses.reduce((sum, r) => sum + r._count, 0);

  if (total === 0) {
    return { score: 0, total: 0, hasPMF: false };
  }

  const veryDisappointed =
    responses.find((r) => r.response === 'VERY_DISAPPOINTED')?._count || 0;

  const score = Math.round((veryDisappointed / total) * 100);

  return {
    score,
    total,
    hasPMF: score >= 40,
    breakdown: {
      veryDisappointed,
      somewhatDisappointed:
        responses.find((r) => r.response === 'SOMEWHAT_DISAPPOINTED')?._count || 0,
      notDisappointed:
        responses.find((r) => r.response === 'NOT_DISAPPOINTED')?._count || 0,
    },
  };
}

When to Send the Survey#

Trigger after users experience core value:

Completed onboarding
Used key feature X times
Been active for Y days
Reached a milestone

Sample size:

Minimum: 40 responses for statistical significance
Ideal: 100+ responses
Segment by user type for deeper insights

Method 2: Retention Analysis#

Retention Curves#

Retention is the clearest signal of PMF.

                   RETENTION CURVES

100% ┤
     │ ╲
     │  ╲ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─  PMF (flattens)
 50% ┤   ╲
     │    ╲
     │     ╲_ _ _ _ _ _        No PMF (keeps dropping)
  0% ┤                 ╲ _ _ _
     └────┴────┴────┴────┴────
        D1   D7   D14  D30  D60

Retention SQL Queries#

Daily Retention Cohort:

-- Calculate D1, D7, D30 retention by signup cohort
WITH cohorts AS (
  SELECT
    id AS user_id,
    DATE_TRUNC('week', created_at) AS cohort_week
  FROM users
),
user_activity AS (
  SELECT
    user_id,
    DATE(created_at) AS activity_date
  FROM events
  WHERE event_type = 'session_start'
  GROUP BY user_id, DATE(created_at)
)
SELECT
  c.cohort_week,
  COUNT(DISTINCT c.user_id) AS cohort_size,
  COUNT(DISTINCT CASE
    WHEN ua.activity_date = DATE(c.cohort_week) + INTERVAL '1 day'
    THEN c.user_id
  END)::FLOAT / COUNT(DISTINCT c.user_id) * 100 AS d1_retention,
  COUNT(DISTINCT CASE
    WHEN ua.activity_date = DATE(c.cohort_week) + INTERVAL '7 days'
    THEN c.user_id
  END)::FLOAT / COUNT(DISTINCT c.user_id) * 100 AS d7_retention,
  COUNT(DISTINCT CASE
    WHEN ua.activity_date = DATE(c.cohort_week) + INTERVAL '30 days'
    THEN c.user_id
  END)::FLOAT / COUNT(DISTINCT c.user_id) * 100 AS d30_retention
FROM cohorts c
LEFT JOIN user_activity ua ON c.user_id = ua.user_id
GROUP BY c.cohort_week
ORDER BY c.cohort_week;

Retention Benchmarks by Category#

Category	Good D1	Good D7	Good D30
B2B SaaS	50%+	30%+	20%+
B2C App	40%+	20%+	10%+
E-commerce	15%+	8%+	3%+
Social	50%+	25%+	15%+
Gaming	40%+	15%+	5%+

Improving Retention#

Analyze drop-off points:

-- Find where users drop off
SELECT
  step,
  COUNT(DISTINCT user_id) AS users,
  COUNT(DISTINCT user_id)::FLOAT /
    FIRST_VALUE(COUNT(DISTINCT user_id)) OVER (ORDER BY step) * 100
    AS completion_rate
FROM onboarding_events
GROUP BY step
ORDER BY step;

Identify power users:

-- What do retained users do differently?
SELECT
  e.event_type,
  COUNT(DISTINCT CASE WHEN retained THEN e.user_id END) AS retained_users,
  COUNT(DISTINCT CASE WHEN NOT retained THEN e.user_id END) AS churned_users
FROM events e
JOIN (
  SELECT
    user_id,
    MAX(created_at) > NOW() - INTERVAL '30 days' AS retained
  FROM events
  GROUP BY user_id
) r ON e.user_id = r.user_id
WHERE e.created_at < e.user_created_at + INTERVAL '7 days'
GROUP BY e.event_type
ORDER BY retained_users DESC;

Method 3: Qualitative Signals#

Leading Indicators of PMF#

Signal	What to Look For
Word of mouth	Users referring without being asked
Organic growth	Signups without paid marketing
Usage depth	Users exploring beyond core features
Emotional connection	Users expressing love, not just utility
Pull vs. push	Users asking for features vs. you pushing adoption

User Interview Questions#

For power users:

What would you use if we didn't exist?
What problem does [Product] solve for you?
Tell me about the last time you used [Product]
Who else should be using this?

For churned users:

Why did you stop using [Product]?
What would have kept you?
What are you using instead?

Analyzing Qualitative Data#

Create a signal tracker:

interface PMFSignal {
  type: 'positive' | 'negative';
  category: 'word_of_mouth' | 'usage' | 'feedback' | 'churn';
  description: string;
  source: string;
  date: Date;
}

const signals: PMFSignal[] = [
  {
    type: 'positive',
    category: 'word_of_mouth',
    description: 'User shared product in industry Slack without asking',
    source: 'Slack notification',
    date: new Date('2024-01-15'),
  },
  // ... more signals
];

PMF Dashboard#

Key Metrics to Track#

interface PMFDashboard {
  // Sean Ellis Score
  pmfScore: number;
  pmfTrend: number; // change from last period

  // Retention
  d1Retention: number;
  d7Retention: number;
  d30Retention: number;
  retentionTrend: number;

  // Growth
  organicSignupRate: number;
  referralRate: number;
  nps: number;

  // Engagement
  dau: number;
  dauWauRatio: number; // stickiness
  avgSessionsPerUser: number;
}

Segmented Analysis#

PMF often exists in specific segments first:

-- PMF score by user segment
SELECT
  u.segment,
  COUNT(*) AS total,
  COUNT(CASE WHEN s.response = 'VERY_DISAPPOINTED' THEN 1 END)::FLOAT
    / COUNT(*) * 100 AS pmf_score
FROM pmf_surveys s
JOIN users u ON s.user_id = u.id
GROUP BY u.segment
ORDER BY pmf_score DESC;

Recommended Agents#

Phase	Agent	Purpose
Survey	frontend-expert	Survey implementation
Analytics	analytics-expert	Retention analysis
Research	research-expert	User interviews
Strategy	strategy-expert	PMF improvement plan

Action Plan Based on Score#

PMF Score < 25%: Major Pivot Needed#

Actions:

Talk to 20+ users immediately
Identify who (if anyone) is getting value
Consider pivoting or major product changes
Don't scale - you'll accelerate failure

PMF Score 25-40%: Getting Close#

Actions:

Double down on what's working
Identify friction points
Improve onboarding to core value
Test changes with specific segments

PMF Score 40%+: Ready to Scale#

Actions:

Document what makes you successful
Build repeatable acquisition channels
Start scaling team and marketing
Continue monitoring PMF as you grow

Deliverables#

Deliverable	Description
PMF survey	Implemented and deployed
PMF dashboard	Score, retention, trends
User research	Interview findings
Segment analysis	PMF by user type
Action plan	Improvement roadmap

Best Practices#

Survey regularly - PMF can change over time
Segment your data - PMF in one segment first
Combine methods - Survey + retention + qualitative
Don't fake it - Honest assessment is crucial
Act on feedback - Use "somewhat disappointed" insights
Be patient - PMF takes time to achieve

Common Pitfalls#

Surveying too early - Wait for users to experience value
Small sample size - Need 40+ responses minimum
Ignoring segments - Overall score masks segment differences
Premature scaling - Scaling without PMF accelerates failure
Vanity metrics - Downloads and signups don't equal PMF

Post-Launch - Iterate after launch
Retention - Improve retention
Metrics - Track KPIs
Acquisition - Scale after PMF