Pick a SaaS Boilerplate Based on Your Business 2026

TL;DR

Most developers pick a boilerplate based on the tech stack. The better approach: pick it based on your business model. A B2B SaaS with organizations and seats needs Supastarter's multi-tenancy. A B2C subscription app with a landing page and PaymentSheet needs ShipFast's simplicity. A marketplace needs Stripe Connect — and almost no boilerplate ships with that. Match the boilerplate to the billing and user model, not just the framework.

Key Takeaways

B2C subscriptions (individual users paying monthly): ShipFast, Next SaaS Starter, T3 Stack
B2B SaaS (companies buying seats): Supastarter, Makerkit, Bedrock — multi-tenancy required
Usage-based billing: no boilerplate ships this pre-built — add Stripe Meters manually
Marketplace / two-sided: Stripe Connect — you'll customize any boilerplate significantly
Freemium: any starter with feature flags — add PostHog or LaunchDarkly
Open core (free OSS + paid features): T3 Stack or Epic Stack as the base

The Business Model Matrix

Business Model       → Required Features           → Best Boilerplate
─────────────────────────────────────────────────────────────────────
B2C subscription    → User auth, Stripe            → ShipFast, Next SaaS Starter
B2B per-seat        → Orgs, members, RLS           → Supastarter, Makerkit
B2B usage-based     → Stripe Meters, usage tracking → T3 Stack (add meters)
Marketplace         → Stripe Connect, escrow        → Build custom (or fork Epic Stack)
Freemium            → Feature flags, plan limits    → Any + PostHog
One-time purchase   → Simple checkout               → ShipFast (simpler billing)
Open core           → Public repo + auth gate       → T3 Stack or Epic Stack
Agency/services     → Multi-project dashboard       → Custom (no boilerplate fits)

Model 1: B2C Subscription

Characteristics:

Individual users (not companies) pay you directly
Credit card on file, monthly/annual billing
Users don't invite teammates
Support volume is critical (one bad experience = churn)

What you need from a boilerplate:

Clean auth flow (magic link, Google are highest converting)
Stripe subscriptions + webhooks
Email notifications
Fast landing page (conversion matters)
Basic dashboard

What you DON'T need:

Organizations or team management
Role-based permissions
Multi-tenant database isolation
Seat counting

Best choices:

// ShipFast: Stripe checkout in ~50 lines
import Stripe from 'stripe';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

// ShipFast's apiCheckout.ts — already written for you:
export const createCheckout = async (priceId: string, userId: string) => {
  const session = await stripe.checkout.sessions.create({
    line_items: [{ price: priceId, quantity: 1 }],
    mode: 'subscription',
    success_url: `${process.env.NEXT_PUBLIC_APP_URL}/dashboard?success=true`,
    cancel_url: `${process.env.NEXT_PUBLIC_APP_URL}/pricing`,
    client_reference_id: userId,
    customer_email: userEmail,
  });
  return session.url;
};

Recommendation: ShipFast for simplicity, Next SaaS Starter for free.

Model 2: B2B Per-Seat SaaS

Characteristics:

Companies (organizations) are your customers, not individuals
Admins invite team members (seats)
Billing is per seat × per month
Users have different roles (admin, member, viewer)

What you need:

Organization model (orgs own resources, not individual users)
Invitation system (invite by email, accept invite flow)
Role-based permissions (admin vs member)
Per-seat billing with Stripe
Row Level Security (data isolation between orgs)

What's wrong with B2C boilerplates for B2B:

// ❌ B2C pattern (data owned by user):
// Resources belong to individual users
const todos = await db.todo.findMany({
  where: { userId: session.user.id }
});

// ✅ B2B pattern (data owned by organization):
// Resources belong to the org, users are members
const todos = await db.todo.findMany({
  where: {
    organizationId: session.user.activeOrganizationId,
    // AND: user must be a member of this org (enforced by RLS or application logic)
  }
});

Building this from a B2C boilerplate takes 2-3 weeks. Supastarter ships it:

// Supastarter's organization model (pre-built):
// app/dashboard/settings/members/page.tsx

// Invite a member:
const { error } = await supabase.functions.invoke('send-invitation', {
  body: {
    email: inviteeEmail,
    organizationId: currentOrg.id,
    role: 'member', // 'admin' | 'member' | 'viewer'
  }
});

// RLS policy (pre-written by Supastarter):
// CREATE POLICY "members can read org resources"
// ON resources FOR SELECT
// USING (
//   organization_id IN (
//     SELECT organization_id FROM memberships
//     WHERE user_id = auth.uid()
//   )
// );

Recommendation: Supastarter ($299) or Makerkit ($299+) — the multi-tenancy foundation saves weeks.

Model 3: Usage-Based Billing

Characteristics:

Customers pay per API call, per GB processed, per message sent, per seat-hour
Complex billing that varies month to month
Need accurate usage tracking + metering

The bad news: no boilerplate ships usage-based billing pre-built. Stripe Meters (the modern Stripe solution) is too new and too specific to be in generic starters.

What to do:

// Add Stripe Meters to any boilerplate:
import Stripe from 'stripe';
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

// Track usage event:
export async function trackApiCall(customerId: string) {
  // Report usage to Stripe Billing Meter:
  await stripe.billing.meterEvents.create({
    event_name: 'api_call',
    payload: {
      stripe_customer_id: customerId,
      value: '1', // 1 API call
    },
  });
}

// Create usage-based subscription:
await stripe.subscriptions.create({
  customer: customerId,
  items: [{
    price: 'price_api_calls_per_unit', // Price with billing_scheme=per_unit
  }],
});

// In your API route:
export async function POST(req: Request) {
  const user = await getUser(req);
  await trackApiCall(user.stripeCustomerId);
  // ... handle actual API request
}

Starting boilerplate for usage-based: T3 Stack — clean foundation, add meters yourself. Don't pay $299 for Supastarter's multi-tenancy if you don't need it.

Model 4: Marketplace / Two-Sided

Characteristics:

Buyers and sellers (or creators and consumers)
You take a platform fee
Payments flow through you to sellers
Stripe Connect required for payouts

The reality: No major boilerplate ships Stripe Connect pre-built. It's complex, highly variable, and requires understanding of connected accounts vs standard accounts.

// Stripe Connect setup (you'll add this yourself):
const account = await stripe.accounts.create({
  type: 'express', // or 'standard', 'custom'
  country: 'US',
  capabilities: {
    card_payments: { requested: true },
    transfers: { requested: true },
  },
});

// Payment with platform fee:
const paymentIntent = await stripe.paymentIntents.create({
  amount: 5000,              // $50.00 total
  currency: 'usd',
  application_fee_amount: 500, // $5.00 platform fee (10%)
  transfer_data: {
    destination: seller.stripeAccountId,
  },
});

Recommendation: Start with T3 Stack or Epic Stack (clean, customizable), add Connect yourself. Budget 2-3 weeks for the Connect integration — it's complex regardless of boilerplate.

Model 5: Freemium

Characteristics:

Free tier with feature limits (3 projects, 100 API calls/month)
Upgrade prompt when limits hit
Need to enforce limits reliably

// Feature gate pattern in any boilerplate:
// middleware or server action check

export async function checkProjectLimit(userId: string) {
  const user = await db.user.findUnique({
    where: { id: userId },
    include: { projects: true, subscription: true },
  });

  const plan = user?.subscription?.plan ?? 'free';
  const limits = {
    free: 3,
    pro: 100,
    enterprise: Infinity,
  };

  if (user!.projects.length >= limits[plan as keyof typeof limits]) {
    throw new Error('PLAN_LIMIT_EXCEEDED');
  }
}

// In your tRPC/API route:
export const createProject = protectedProcedure
  .input(createProjectSchema)
  .mutation(async ({ ctx, input }) => {
    await checkProjectLimit(ctx.session.user.id);
    return ctx.db.project.create({ data: input });
  });

Any boilerplate supports this pattern. The sophistication is in your limit enforcement logic, not the boilerplate.

Recommendation: ShipFast (add limit checks manually) or Makerkit (has plan configuration built-in).

Quick Reference: Business Model → Boilerplate

You're building...                    Get this boilerplate:

Simple B2C subscription              ShipFast ($199) — fast
Simple B2C, no budget                Next SaaS Starter (free)
B2B with teams and orgs             Supastarter ($299) — multi-tenancy
B2B, complex features               Makerkit ($299+) — plugin system
Usage-based billing                  T3 Stack (free) + add Stripe Meters
Marketplace/two-sided                T3 Stack or Epic Stack (free) + Stripe Connect
Dev tool / API product               T3 Stack + tRPC
Content + SaaS hybrid                Makerkit (blog built-in) or T3+Contentlayer
Full open source                     Open SaaS (free, Wasp) or T3 Stack

Need multi-language from day 1:      Supastarter (i18n built-in)
Team is Rails/Python:                Laravel Spark, Wave, or djaodjin
Team is SvelteKit:                   SvelteShip or Indie Kit
Enterprise (SOC2, SSO, audit log):   Bedrock ($499+)

The 15-Minute Evaluation Framework

Before buying any boilerplate, answer these 5 questions:

Who pays? (individual users or companies/teams) → Individual = need simple Stripe subscriptions → Teams = need multi-tenancy
How do they pay? (monthly flat / per seat / per usage) → Flat = any boilerplate → Per seat = needs seat counting + billing → Usage = add Stripe Meters manually
What's the launch timeline? → < 1 week = ShipFast (fastest) → 1-4 weeks = any major boilerplate → 1+ month = build what you need
What's the long-term complexity? → Simple = free boilerplate, grow later → Complex from day 1 = invest in Supastarter/Makerkit foundation
What's your team's framework expertise? → Strong Next.js = ShipFast/Supastarter → Strong Remix = Epic Stack/SaaSrock → Strong SvelteKit = SvelteShip/Indie Kit

Common Mistakes When Matching Boilerplate to Business Model

Buying for a B2B product when you haven't validated B2B customers. The most expensive mistake is buying Supastarter ($299) or Makerkit ($299+) before validating that companies (not individuals) will pay for your product. If your first 10 customers turn out to be individuals using personal credit cards, not companies paying team invoices, you've bought multi-tenancy you don't need. Validate the customer type before paying for enterprise architecture.

Assuming "multi-tenancy" means the same thing across boilerplates. Supastarter's multi-tenancy uses Supabase Row Level Security. Makerkit's uses application-level middleware. Bedrock's uses a combination of both. The user experience of multi-tenancy is similar; the implementation and security model differ significantly. For products with strict data isolation requirements (healthcare, finance, legal), Supabase RLS is the strongest isolation guarantee.

Underestimating usage-based billing complexity. Stripe Meters (the Stripe solution for usage-based billing) is a relatively new product and its SDKs, documentation, and community resources are less mature than Stripe Subscriptions. Building usage-based billing correctly requires: metered events at the correct granularity, period end reconciliation, handling of late events (events that arrive after a billing period closes), and customer-facing usage dashboards. None of this is in any boilerplate as of 2026. Plan for 1-2 weeks of Stripe Meters integration regardless of which boilerplate you start from.

Choosing a marketplace boilerplate that doesn't exist. No commercial boilerplate ships Stripe Connect pre-built. This is not a gap in the market — it's a reflection of the complexity and variability of marketplace payment requirements. Accept that you'll be adding Connect yourself regardless of which foundation you choose, budget 2-3 weeks for it, and pick the foundation with the best multi-tenancy and data model for your marketplace type.

The Decision in Practice

In practice, most founders are building either a B2C tool or a B2B product — the intermediate cases (usage-based, marketplace) are real but less common for a first SaaS launch. The 15-minute framework above works for most decisions. For the cases where the framework produces ambiguity, these tiebreakers apply:

When B2C vs B2B is unclear: Build for B2C first. B2C boilerplates are simpler, faster to set up, and you can add multi-tenancy later when you have enterprise customers asking for it. Adding multi-tenancy to a B2C codebase is a 2-3 week refactor. Starting with B2B architecture when you only have B2C customers is 2-3 weeks of complexity you carry forever.

When budget is the constraint: T3 Stack (free) gives you the best foundation for the lowest total cost. The $299 commercial boilerplates save approximately 10-20 days of setup time. If your time is worth less than $15-30/hour, the free option is the better financial decision. If your time is worth more, paying for the setup time savings is almost always correct.

When framework preference is split: Default to Next.js. The Next.js boilerplate ecosystem is dramatically larger than every alternative combined. Switching to TanStack Start, Remix, or SvelteKit because of personal preference means trading a larger boilerplate selection for a smaller one. Make that trade when the technical advantages of the alternative framework are concrete and necessary, not when they're theoretical.

Making the Final Decision

Your business model determines your boilerplate more reliably than your tech preferences. The concrete test: identify the hardest feature your business model requires, and check which boilerplate ships it closest to production-ready.

For B2B with teams, the hardest feature is multi-tenancy (Supastarter ships it). For marketplace, the hardest feature is Stripe Connect (no boilerplate ships it, budget for custom work). For usage-based billing, the hardest feature is metered billing (budget for custom Stripe Meters work regardless of boilerplate). For B2C subscription, the hardest feature is a polished billing UI (ShipFast ships it).

The boilerplate that ships the hardest feature closest to production-ready is almost always the right choice, even if it means accepting trade-offs on simpler features that you can build yourself.

For the complete landscape of available boilerplates across all these models, see the best SaaS boilerplates 2026 guide. For the detailed cost analysis of each option including total cost of ownership, see the true cost of SaaS boilerplates analysis. For free alternatives that eliminate the license fee while still providing strong foundations, see the free open-source SaaS boilerplates guide. For the broader question of when to buy vs build from scratch, see the buy vs build SaaS analysis.

Every SaaS boilerplate makes architectural decisions that become increasingly expensive to reverse as your codebase grows. The best time to evaluate whether a boilerplate's decisions match your product requirements is before you've written any custom business logic on top of it.

Find the right boilerplate for your business model at StarterPick.

The SaaS Boilerplate Matrix (Free PDF)