Makerkit Review 2026: Premium SaaS Boilerplate

TL;DR

Makerkit is the highest-quality SaaS boilerplate in terms of code structure and testing. The plugin architecture is genuinely useful, and the multi-tenancy support is excellent. At $299+ (pricing varies by tier), it's worth it for teams that value code quality and long-term maintainability over time-to-launch. Not ideal for solo founders who need to ship in a week.

What You Get

Price: $149 (basic) to $599 (teams tier) — see makerkit.dev for current pricing

Core features:

• Next.js 14+ (App Router) + TypeScript (strict)
• Multi-tenancy: Organizations with roles and permissions
• Auth: Supabase Auth OR Firebase
• Payments: Stripe + Lemon Squeezy + Paddle
• Email: Nodemailer + Resend adapters
• UI: shadcn/ui + Tailwind
• Blog: MDX with full SEO
• i18n: Full internationalization
• Admin panel: Complete admin dashboard
• Testing: Vitest + Playwright configured
• Plugin system: Extend without forking

The Plugin Architecture

Makerkit's defining feature: a plugin system that lets you add functionality without modifying the core codebase.

# Add features via plugins (official plugins)
npx makerkit plugin:install @makerkit/plugin-ai-chatbot
npx makerkit plugin:install @makerkit/plugin-roadmap
npx makerkit plugin:install @makerkit/plugin-analytics

// plugins/ai-chatbot/index.ts — clean plugin interface
import type { MakerkitPlugin } from '@makerkit/core';

const aiChatbotPlugin: MakerkitPlugin = {
  name: 'ai-chatbot',
  routes: [
    {
      path: '/chat',
      component: () => import('./pages/ChatPage'),
    },
  ],
  navigationItems: [
    {
      label: 'AI Assistant',
      icon: BotIcon,
      href: '/chat',
      plans: ['pro', 'enterprise'],  // Feature gating built-in
    },
  ],
  hooks: {
    onUserCreated: async (user) => {
      // Initialize chat history for new user
      await createChatSession(user.id);
    },
  },
};

export default aiChatbotPlugin;

Why this matters: When Makerkit updates its core (new Next.js version, auth improvements), you pull updates without merge conflicts on feature code.

---

Code Quality

Makerkit has the highest code quality of any major boilerplate. Strict TypeScript, meaningful tests, proper separation of concerns:

// Domain-driven structure
// server/organizations/
//   services/
//     create-organization.service.ts
//     update-organization.service.ts
//   repositories/
//     organization.repository.ts
//   types.ts

// CreateOrganizationService — clean, testable, single responsibility
export class CreateOrganizationService {
  constructor(
    private readonly organizationRepository: OrganizationRepository,
    private readonly billingService: BillingService,
    private readonly emailService: EmailService
  ) {}

  async execute(input: CreateOrganizationInput, userId: string): Promise<Organization> {
    // Validate
    const validated = createOrganizationSchema.parse(input);

    // Create organization
    const org = await this.organizationRepository.create({
      name: validated.name,
      slug: await this.generateSlug(validated.name),
    });

    // Add creator as owner
    await this.organizationRepository.addMember(org.id, userId, 'owner');

    // Send welcome email
    await this.emailService.sendOrganizationCreated(userId, org);

    return org;
  }
}

This is maintainable code. Contrast with boilerplates that throw everything in /app/api/ route handlers.

---

Testing Setup

Makerkit ships with tests configured and working:

// suites/organizations/create-organization.spec.ts
import { describe, it, expect, vi } from 'vitest';
import { CreateOrganizationService } from './create-organization.service';

describe('CreateOrganizationService', () => {
  const mockRepo = {
    create: vi.fn().mockResolvedValue({ id: 'org_123', name: 'Acme', slug: 'acme' }),
    addMember: vi.fn().mockResolvedValue(undefined),
  };

  it('creates organization and adds creator as owner', async () => {
    const service = new CreateOrganizationService(mockRepo, mockBilling, mockEmail);

    const org = await service.execute({ name: 'Acme' }, 'user_123');

    expect(org.name).toBe('Acme');
    expect(mockRepo.addMember).toHaveBeenCalledWith('org_123', 'user_123', 'owner');
  });
});

You get tests you can actually run and extend — not just vitest config with no tests.

---

The Admin Panel

Makerkit includes a complete admin dashboard:

• User management (view, impersonate, ban)
• Organization management
• Subscription management
• System metrics

// /admin/users/[id]/page.tsx — impersonate for support
async function AdminUserPage({ params }) {
  const user = await adminGetUser(params.id);

  return (
    <AdminLayout>
      <UserDetails user={user} />
      <ImpersonateButton userId={user.id} />  // Login as this user to debug issues
      <UserActivity userId={user.id} />
      <UserSubscription userId={user.id} />
    </AdminLayout>
  );
}

Customer support teams need this. Most boilerplates don't ship it.

---

The Not-So-Good

1. Price vs Value Assessment Depends on Tier

The basic tier ($149) gives you less than ShipFast. The teams tier ($599) gives you more but costs twice as much. The plugin system's value compounds over time, not immediately.

2. Learning Curve is Higher

The domain-driven architecture, plugin system, and service layer patterns are more sophisticated than other boilerplates. A junior developer might find it overwhelming. An experienced developer will appreciate it.

3. Supabase or Firebase — Both Have Lock-In

You choose your auth/database provider at setup. Both options create significant lock-in.

---

Who Should Buy Makerkit

Good fit:

• Teams of 2-5 developers building B2B SaaS
• Founders with software engineering backgrounds who value code quality
• Products expected to grow significantly (the architecture scales better)
• Long-term projects where maintainability matters

Bad fit:

• Solo founders who need to validate quickly (overhead isn't worth it at idea stage)
• B2C products (single-user billing, the complexity is unnecessary)
• Founders new to React/Next.js (the patterns require experience to navigate)

---

Final Verdict

Rating: 4.5/5

Makerkit is the best boilerplate for teams. The code quality, plugin architecture, and admin panel are genuinely superior. If you're building a product you plan to grow for years, the investment in code quality pays off. For a solo founder validating an idea, it's overkill.

---

---

Getting Started with Makerkit

# Clone the repo (you receive access after purchase)
git clone https://github.com/makerkit/next-supabase-saas-kit my-app
cd my-app && pnpm install

cp apps/web/.env.example apps/web/.env.local
# Configure Supabase URL and keys, Stripe, Resend, and Google OAuth
# Makerkit uses a monorepo structure (pnpm workspaces)

cd apps/web
pnpm run dev  # → localhost:3000

Makerkit uses a monorepo structure — the apps/ directory contains the web application, and packages/ contains shared utilities, UI components, and the plugin system. The first run takes longer than simpler starters because there's more to configure, but the documentation is comprehensive and the setup scripts reduce manual steps.

---

The i18n System

Makerkit's internationalization is built-in from the start, not bolted on:

// Translation usage throughout the app
import { useTranslation } from 'react-i18next';

export function BillingSection() {
  const { t } = useTranslation('billing');
  
  return (
    <div>
      <h2>{t('title')}</h2>
      <p>{t('description', { plan: currentPlan })}</p>
      <button>{t('upgrade_button')}</button>
    </div>
  );
}

// public/locales/en/billing.json
{
  "title": "Billing & Subscription",
  "description": "You're on the {{plan}} plan.",
  "upgrade_button": "Upgrade Plan"
}

Every user-facing string goes through i18n — this means you can ship a second language by adding a translation file rather than touching component code. For B2B SaaS targeting multiple markets, this saves weeks of work compared to boilerplates where i18n is left as an exercise.

---

Makerkit vs Supastarter

Both are premium B2B SaaS boilerplates at similar price points. Key differences:

Feature	Makerkit	Supastarter
Price	$149-599	$299
Plugin system	✅	❌
Testing	✅ Vitest + Playwright	❌
i18n	✅	✅
Payment providers	Stripe + Lemon + Paddle	Stripe only
Auth backends	Supabase OR Firebase	Supabase only
Code style	Domain-driven, services	Feature-based

Makerkit's advantage is long-term maintainability — the plugin system and service architecture make it easier to update without breaking customizations. Supastarter is simpler to start with and deploy but doesn't scale as gracefully when the product grows.

---

When Makerkit's Complexity Pays Off

Makerkit makes sense when at least two of these are true:

• Team size: 2+ developers working in the codebase simultaneously. The service architecture and separation of concerns prevent stepping on each other's work.
• Time horizon: Building something you plan to maintain for 2+ years. The initial complexity investment pays off in maintainability.
• Product scope: The product will grow significantly beyond MVP. Makerkit's plugin system lets you add features without accumulating technical debt.
• Enterprise requirements: Selling to enterprise buyers who will ask about multi-tenancy and audit logs. Makerkit handles both.

For a solo founder validating an idea over 30 days, the overhead is unjustified. For a team shipping a product they plan to grow into a company, Makerkit's architecture is the right foundation.

---

Key Takeaways

• Makerkit has the highest code quality of any major SaaS boilerplate — strict TypeScript, domain-driven architecture, and real tests
• The plugin system is unique: add features via plugins without forking the core, making Makerkit updates easier to apply
• i18n is built-in from the start — every string is translatable, saving weeks for multi-market products
• Pricing ($149-599) reflects the quality; the basic tier gives less than ShipFast, the teams tier gives the most comprehensive B2B foundation available
• Best for 2+ person teams building a serious B2B SaaS product they plan to grow for years
• Skip for quick idea validation — the architecture overhead doesn't pay off at pre-PMF stage

---

Billing Configuration in Depth

Makerkit's billing layer is one of its strongest differentiators from other premium boilerplates. Rather than hardcoding Stripe, Makerkit abstracts billing behind an interface that supports Stripe, Lemon Squeezy, and Paddle. The practical benefit: switching payment processors doesn't require touching your billing UI or business logic.

// makerkit/packages/billing/src/types.ts
// The billing adapter interface — same code regardless of processor:
export interface BillingAdapter {
  createCheckoutSession(params: CheckoutParams): Promise<{ url: string }>;
  createPortalSession(params: PortalParams): Promise<{ url: string }>;
  getSubscription(customerId: string): Promise<Subscription | null>;
  handleWebhook(event: WebhookEvent): Promise<void>;
}

The billing configuration file (config/billing.config.ts) is where you define your plans, features, and pricing. This declarative approach means non-developers can read the billing configuration and understand what customers get at each tier — a meaningful operational advantage as your team grows.

Metered billing is supported but requires the Enterprise plugin tier. Per-seat billing (where the subscription price scales with the number of organization members) is supported natively and is one of the areas where Makerkit surpasses ShipFast — ShipFast requires manual implementation of per-seat billing logic that Makerkit ships pre-built.

Multi-Tenancy Architecture

Makerkit's organization model is well-designed for B2B SaaS. Each user can belong to multiple organizations, each organization can have multiple plans, and permissions cascade from organization role through feature flags.

The ownership model follows standard B2B patterns: one user creates the organization and is automatically the owner; the owner can invite team members as admins or standard members; resource visibility is controlled by organization membership, not by individual user IDs. Row-level security in Supabase is pre-configured to enforce this — queries that hit the database without an organization filter return no results for rows belonging to other organizations.

The one architectural decision teams frequently want to change: Makerkit defaults to organization-scoped billing (the organization pays, not the individual user). For consumer SaaS where individual users pay separately, the organization abstraction adds complexity you don't need. Makerkit handles this with a personal account mode where each user's personal account is treated as an organization of one — but the conceptual overhead remains.

Documentation and Community

Makerkit's documentation is the best-maintained of any premium SaaS boilerplate. The docs site covers every major feature with TypeScript examples and explains the architectural reasoning, not just how to use things. The Discord community has the creator Giancarlo Buomprisco actively answering questions, which is unusual for a solo-maintained product at this price point.

Breaking changes are documented in the changelog, and the plugin system means most breaking changes don't require touching your custom code. When Next.js 15 shipped, Makerkit updated the core kit and plugins separately — teams could update on their own schedule rather than taking one large migration.

For teams coming from a simpler boilerplate (ShipFast, T3 Stack), the Makerkit codebase requires a ramp-up period of roughly one week before productivity normalizes. The service layer patterns, plugin architecture, and monorepo structure are unfamiliar at first. After that ramp-up, teams consistently report faster feature development than they had with flatter architectures — the separation of concerns pays off.

---

Compare Makerkit with ShipFast and Supastarter in our ShipFast vs Makerkit vs Supastarter comparison.

See our Supastarter review for the simpler B2B alternative at a comparable price.

Browse best SaaS boilerplates 2026 for the full comparison including Enterprise Boilerplate.