How to Build a Waitlist Page for Your SaaS MVP

Most SaaS landing pages convert at 2-4%. A well-built waitlist page converts at 25-85%. That’s not a typo. When you remove the friction of “buy now” and replace it with “get early access,” people sign up at wildly higher rates.

Buffer famously validated their entire product with a two-page website. Page one described the product. Page two collected emails. They had 120,000 signups before writing serious product code. No features, no backend, no billing — just a waitlist.

If you’re working on a SaaS idea and haven’t validated it yet, a waitlist page is one of the fastest ways to gauge real interest. Not “that sounds cool” interest — “give me your email and tell your friends” interest.

Here’s how to build one that actually works.

Why Waitlists Convert So Much Better

A traditional landing page asks visitors to make a decision: buy, sign up, start a trial. That’s a lot of commitment from someone who just found you.

A waitlist page flips the psychology. Instead of “here’s our product, pay us,” it says “something is coming, and spots are limited.” Three things happen:

1. Lower barrier to entry. An email address costs nothing. There’s zero risk for the visitor.
2. Scarcity creates urgency. “Early access” implies that waiting too long means missing out.
3. Social proof compounds. When you display your signup count (“Join 2,847 others”), each new visitor sees evidence that real people care about this.

Dropbox used the same playbook — their waitlist hit 75,000 signups from a single explainer video. Robinhood collected 1 million emails before launch. These aren’t flukes. The mechanics just work.

The Minimal Page Structure

You don’t need a design system or a component library. A waitlist page has five elements:

1. Headline — What you’re building, in one sentence
2. Subheadline — Who it’s for and why they should care
3. Email capture form — One field, one button
4. Social proof — Signup count or logos
5. Brief description — 2-3 bullet points on what makes this different

That’s it. No pricing table, no feature comparison matrix, no testimonials carousel. Every element you add beyond these five gives visitors a reason to bounce instead of sign up.

Here’s what Buffer’s original page looked like in plain text:

Buffer — A Smarter Way to Share on Twitter Schedule your tweets to post at optimal times. Get more clicks and follows. [Enter your email] [Get Early Access] 3,217 people are already on the list.

Two sentences. One form. One social proof number. It worked because it was focused.

Building the Email Capture

You have two solid options for handling email collection: a managed service like ConvertKit (now Kit) or a code-first approach with Resend.

Option A: Kit (ConvertKit) — Zero Code

If you want to be collecting emails in 10 minutes:

1. Create a free Kit account (up to 10,000 subscribers)
2. Create a new form
3. Embed the form HTML on your page
4. Set up a welcome automation that sends a confirmation email

Kit handles deliverability, double opt-in, and unsubscribes. You focus on driving traffic.

Option B: Resend + Your Own API — Full Control

If you want to own the data and customize everything, here’s a simple Next.js API route that captures emails and sends a confirmation:

// app/api/waitlist/route.ts
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

// In production, replace with a real database
const subscribers: Set<string> = new Set();

export async function POST(request: Request) {
  const { email } = await request.json();

  if (!email || !email.includes('@')) {
    return Response.json(
      { error: 'Valid email required' },
      { status: 400 }
    );
  }

  if (subscribers.has(email)) {
    return Response.json(
      { message: 'You are already on the list!' },
      { status: 200 }
    );
  }

  subscribers.add(email);

  // Send confirmation email
  await resend.emails.send({
    from: '[email protected]',
    to: email,
    subject: 'You are on the list!',
    html: `
      <h2>Welcome to the waitlist</h2>
      <p>You are #${subscribers.size} on the list.</p>
      <p>We will let you know as soon as early access opens.</p>
    `,
  });

  return Response.json({
    message: 'You are in!',
    position: subscribers.size,
  });
}

And the form component:

// components/WaitlistForm.tsx
'use client';
import { useState } from 'react';

export function WaitlistForm() {
  const [email, setEmail] = useState('');
  const [status, setStatus] = useState<'idle' | 'loading' | 'success' | 'error'>('idle');
  const [position, setPosition] = useState<number | null>(null);

  async function handleSubmit(e: React.FormEvent) {
    e.preventDefault();
    setStatus('loading');

    const res = await fetch('/api/waitlist', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ email }),
    });

    const data = await res.json();

    if (res.ok) {
      setStatus('success');
      setPosition(data.position);
    } else {
      setStatus('error');
    }
  }

  if (status === 'success') {
    return (
      <div className="text-center">
        <p className="text-xl font-bold">You are in! 🎉</p>
        <p>You are #{position} on the waitlist.</p>
        <p className="text-sm mt-2 text-gray-500">
          Share with a friend to move up the list.
        </p>
      </div>
    );
  }

  return (
    <form onSubmit={handleSubmit} className="flex gap-2 max-w-md mx-auto">
      <input
        type="email"
        value={email}
        onChange={(e) => setEmail(e.target.value)}
        placeholder="[email protected]"
        required
        className="flex-1 px-4 py-2 rounded border"
      />
      <button
        type="submit"
        disabled={status === 'loading'}
        className="px-6 py-2 bg-black text-white rounded font-medium"
      >
        {status === 'loading' ? 'Joining...' : 'Get Early Access'}
      </button>
    </form>
  );
}

In production, swap that Set for a database table. Supabase, PlanetScale, or even a simple SQLite file — anything persistent. The point is: the code isn’t complicated. A waitlist backend is one table with an email column and a timestamp.

The Referral Loop

This is where waitlist pages get interesting. A basic page collects emails. A great page turns each signup into a distribution channel.

The mechanic is simple: after someone signs up, give them a unique referral link. For every friend who signs up through their link, they move up the waitlist or unlock rewards.

Harry’s (the razor company) used this exact strategy and collected 100,000 emails in a week. Their reward tiers looked like this:

Referrals	Reward
5	Free shaving cream
10	Free razor handle
25	Free premium set
50	Free shaving for a year

You don’t need physical products. For a SaaS waitlist, try:

• 3 referrals — Skip to the front of the line
• 5 referrals — Get 3 months free when you launch
• 10 referrals — Lifetime discount
• 25 referrals — Founding member status with input on the roadmap

The key is making the first tier easy to hit. Three referrals is doable. Most people will at least try. And each attempt sends 3+ new visitors to your page.

If you don’t want to build this yourself, tools like Waitlist.email, Viral Loops, or ReferralHero handle the referral tracking and reward management out of the box.

What to Measure

A waitlist page that collects emails but teaches you nothing is a missed opportunity. Track these numbers:

Conversion rate — What percentage of visitors enter their email? Below 15% means your copy or positioning needs work. Above 40% means you’re onto something real.

Referral rate — What percentage of signups share their referral link? If it’s under 10%, your incentives aren’t compelling enough.

Traffic source quality — Which channels send visitors who actually sign up? A Reddit post might drive 5,000 visitors with 2% conversion, while a targeted Twitter thread drives 200 visitors at 45%. Know where your real audience lives.

Email engagement — When you send updates to your waitlist, who opens them? High open rates (40%+) mean people are genuinely waiting. Low open rates mean they signed up on impulse and forgot about you.

Drop-off analysis — Are people landing on your page and leaving without scrolling? Use something like Plausible or Simple Analytics to see where attention drops. If everyone bounces before reaching the form, your headline isn’t working.

Real Examples That Worked

Buffer — Joel Gascoigne put up a two-page site. Page one: value proposition. Page two: email capture. He added a pricing page between them after a few days to test willingness to pay. The waitlist proved demand before a single feature existed.

Robinhood — Their waitlist showed each person their position in line (#42,583) and let them move up by referring friends. The position number created urgency. The referral mechanic created virality. One million signups before launch.

Superhuman — Rahul Vohra kept Superhuman invite-only for years, requiring a referral to even get on the waitlist. Artificial scarcity turned the product into a status symbol. Every early user became a recruiter.

The common thread: none of these teams built the product first. They built the waitlist, proved demand, and then built with confidence.

When You’re Ready to Go Beyond the Waitlist

At some point, your waitlist validates the idea and you start building the actual product. This is where most indie hackers lose momentum — they get bogged down wiring up authentication, setting up Stripe, handling webhooks, and managing user sessions.

If you’ve been exploring micro SaaS ideas to launch quickly, you know the goal is speed. Beag.io handles auth and Stripe payments in about 5 minutes, so you can skip the infrastructure grind and focus on the feature that makes your product worth the wait.

The Waitlist Launch Checklist

Before you push your page live, run through this:

• Headline clearly states what you’re building and for whom
• Email form works and sends a confirmation
• Social proof element is visible (even “Be the first to join” works at zero)
• Page loads fast — under 2 seconds on mobile
• You have analytics installed (Plausible, Simple Analytics, or similar)
• You’ve tested the signup flow on mobile
• Referral link system is working (if applicable)
• You have a plan to drive traffic on launch day (Reddit, Twitter, HN, communities)

Then ship it. You can always iterate on copy and design later. The first version just needs to capture emails and not break.

If you want to turn your side project into a real product with paying users, the waitlist is step one. It gives you an audience before you have a product, proof before you have code, and momentum before you have revenue.

Stop building in the dark. Put up a waitlist and let the numbers tell you what to do next.

---

FAQ

How many signups do I need before my idea is “validated”?

There’s no magic number, but context matters. 100 signups from a targeted audience (developers who use Next.js, freelance designers in the UK) is a stronger signal than 5,000 signups from a viral Hacker News post where most visitors will never return. Focus on the conversion rate and engagement quality. If 30%+ of your page visitors sign up and 40%+ open your follow-up emails, you have something real — regardless of total count.

Should I use a no-code tool or build my waitlist page from scratch?

If you can ship a custom page in an afternoon, do that — you’ll have full control over tracking, referral mechanics, and design. If frontend work isn’t your thing, tools like Carrd ($19/year), Typedream, or Framer can get a decent waitlist page live in under an hour. The page itself matters less than the positioning and distribution strategy behind it.

When should I start emailing my waitlist?

Immediately. Send a welcome email when they sign up. Then send an update at least every two weeks — share progress, ask for feedback, tease features. A waitlist that goes silent for three months is a dead waitlist. People forget why they signed up. Regular updates keep them warm and give you a direct feedback channel before you launch.

Can I charge money on a waitlist page?

Yes, and you should consider it. Adding a “Pay $10 to reserve your spot” or “Pre-order at 50% off” option gives you the strongest validation signal there is: someone giving you money for something that doesn’t exist yet. Just be transparent about timelines and offer refunds if you don’t ship. This is exactly what the fake door test is designed to do.

What’s the best way to drive traffic to a waitlist page?

Go where your audience already hangs out. For developer tools, that’s Hacker News, specific subreddits, Dev.to, and Twitter/X. For B2B SaaS, try LinkedIn posts and targeted communities on Slack or Discord. Paid ads can work but start small ($50-100) to test conversion before scaling spend. The highest-converting traffic almost always comes from communities where you’re already a known, contributing member — not a stranger dropping links.