Best Boilerplates for Developer Tools SaaS 2026

Developer Tools Are a Distinct SaaS Category

Developer tools have a different buyer, different distribution, and different product requirements than B2C SaaS. The buyer is technical, evaluates the product through CLI or API before touching the dashboard, and makes decisions based on DX quality, documentation, and SDK ergonomics.

The boilerplate requirements follow from this: you need excellent API design, API key management, usage metering, clear documentation, and a developer-first landing page. The billing is often usage-based.

TL;DR

Best boilerplates for developer tools SaaS in 2026:

1. Midday v1 (free) — Production-grade monorepo architecture with background jobs, API-first design. Best technical foundation.
2. Makerkit ($299) — Usage-based billing via Stripe Meters, API key management, B2B features. Best for monetization.
3. T3 Stack (free) — Developer-audience credibility, tRPC API, TypeScript-first. Best DX for developer buyers.
4. OpenSaaS (free) — Wasp framework, background jobs, AI examples, most complete free option.
5. ShipFast ($199) — Fastest to launch, large community. Best for getting to market quickly.

Key Takeaways

• Developer tool buyers evaluate the API and SDK quality first, dashboard second
• Usage-based billing (Stripe Meters) is the dominant model for API products
• API key management is a required feature — most boilerplates need this added
• The T3 Stack has native credibility with developer audiences (they use the same stack)
• Developer-facing SaaS products benefit from open-source components or open documentation
• Rate limiting and usage analytics per API key are critical infrastructure

---

What Developer Tool SaaS Needs

Feature	Priority	Implementation
API key generation and management	Critical	Custom (few boilerplates include this)
Usage metering per key	Critical	Stripe Meters or custom DB counters
Rate limiting per API key	Critical	Upstash Redis + Ratelimit
Developer documentation	High	Mintlify, Fumadocs, or Nextra
SDKs (Node, Python)	High	OpenAPI codegen or manual
Webhook delivery	Medium	Svix or custom queue
Dashboard with usage graphs	Medium	Recharts or Tremor
CLI for configuration	Optional	Commander.js or oclif
Sandbox/test environment	Optional	Separate Stripe test mode

---

Boilerplate Evaluations

1. Midday v1 (Best Technical Foundation)

Price: Free | Tech: Next.js, Turborepo, Trigger.dev, Supabase, Upstash

Midday v1 is the production-grade open-source boilerplate from the Midday financial platform. It includes:

• Background job infrastructure (Trigger.dev) — essential for async API processing
• Rate limiting (Upstash) — built-in
• Monorepo (Turborepo) — clean separation of API, web dashboard, and shared packages
• Observability (OpenPanel, Sentry) — production monitoring from day one

What Midday lacks for developer tools: API key management and usage-based billing. These need custom implementation.

Best for: API products that need background processing and production-grade reliability from the start.

2. Makerkit (Best for Monetization)

Price: $299+ | Tech: Next.js 15, Supabase/PlanetScale, Stripe

Makerkit's enterprise tier includes:

• Usage-based billing via Stripe Meters — essential for API pricing
• Multi-tenant architecture — teams with separate billing
• API key management plugin — in the plugin marketplace
• Granular permissions — important for team API access control

For developer tools monetized on API usage (pay per call, pay per token, pay per request), Makerkit is the only boilerplate with native Stripe Meters support.

Best for: B2B developer tools with usage-based or team billing.

3. T3 Stack (Best Developer Credibility)

Price: Free | Tech: Next.js, tRPC, Drizzle, Tailwind CSS

The T3 Stack (create-t3-app) is used by the same developers who will buy your developer tool. This has a compound credibility effect:

• Technical buyers recognize and trust the stack
• GitHub, "View source" links are not embarrassing
• No suspiciously polished dashboard hiding an inferior codebase

T3 Stack adds:

• tRPC for type-safe API — strong pattern for internal tooling
• TypeScript throughout — developer audience expects it
• Clean, no-bloat architecture — easy to extend

What T3 lacks: billing, auth providers, background jobs. Add Clerk for auth, Stripe manually for billing, Trigger.dev for jobs.

Best for: Developer tools targeting engineering teams who will evaluate the codebase.

4. OpenSaaS (Best Free Complete Option)

Price: Free | Tech: Wasp, React, Node.js, Prisma

OpenSaaS provides auth, Stripe billing, admin dashboard, background jobs, and an AI example in a single free template. For developer tools:

• Background jobs (PgBoss) handle async API operations
• Admin dashboard tracks usage and manages users
• Stripe billing handles credit packs or subscriptions
• AI examples provide patterns for AI-powered developer tools

Best for: AI-powered developer tools where budget is a constraint.

---

API Key Management: Building It Yourself

Most boilerplates lack API key management. The pattern:

// lib/api-keys.ts
import { db } from './db';
import { createHash, randomBytes } from 'crypto';

export async function generateApiKey(userId: string, name: string) {
  const rawKey = `sk_live_${randomBytes(32).toString('hex')}`;
  const hashedKey = createHash('sha256').update(rawKey).digest('hex');

  await db.apiKey.create({
    data: {
      userId,
      name,
      hashedKey,
      prefix: rawKey.slice(0, 12),  // Show prefix in dashboard: sk_live_abc...
    },
  });

  return rawKey;  // Return once — never stored in plaintext
}

export async function validateApiKey(rawKey: string) {
  const hashedKey = createHash('sha256').update(rawKey).digest('hex');
  const apiKey = await db.apiKey.findUnique({
    where: { hashedKey },
    include: { user: true },
  });

  if (!apiKey || apiKey.revokedAt) return null;

  // Update last used:
  await db.apiKey.update({
    where: { id: apiKey.id },
    data: { lastUsedAt: new Date() },
  });

  return apiKey.user;
}

// middleware for API routes:
export async function apiKeyMiddleware(req: Request) {
  const key = req.headers.get('Authorization')?.replace('Bearer ', '');
  if (!key) return new Response('Missing API key', { status: 401 });

  const user = await validateApiKey(key);
  if (!user) return new Response('Invalid API key', { status: 401 });

  return user;
}

---

Rate Limiting with Upstash

import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';

const ratelimit = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(100, '1m'),  // 100 requests per minute
  analytics: true,
});

export async function POST(req: Request) {
  const apiKey = req.headers.get('Authorization')?.replace('Bearer ', '');
  const user = await validateApiKey(apiKey!);
  if (!user) return new Response('Unauthorized', { status: 401 });

  const { success, limit, remaining, reset } = await ratelimit.limit(user.id);

  if (!success) {
    return new Response('Rate limit exceeded', {
      status: 429,
      headers: {
        'X-RateLimit-Limit': limit.toString(),
        'X-RateLimit-Remaining': remaining.toString(),
        'X-RateLimit-Reset': reset.toString(),
      },
    });
  }

  // Process request...
}

---

Usage Metering with Stripe Meters

For pay-per-use API pricing:

import Stripe from 'stripe';

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

export async function reportUsage(customerId: string, quantity: number) {
  await stripe.billing.meterEvents.create({
    event_name: 'api_requests',
    payload: {
      stripe_customer_id: customerId,
      value: quantity.toString(),
    },
  });
}

// In your API route, after processing:
await reportUsage(user.stripeCustomerId, 1);

This requires Stripe Meters to be configured in your Stripe dashboard. Makerkit handles this natively; other boilerplates require manual Stripe Meters setup.

---

Documentation Stack for Developer Tools

Developer tools live and die by documentation quality:

Tool	Best For	Price
Mintlify	Modern API docs, AI search	Free tier + $150/mo
Fumadocs	Next.js-native docs, free	Free (self-hosted)
Nextra	Simple MDX docs site	Free (self-hosted)
Scalar	API reference from OpenAPI spec	Free tier
Readme.io	Full developer hub	$99/mo+

For most developer tools: Fumadocs (free, Next.js) for docs + Scalar (free) for API reference.

---

Recommended Stack by Developer Tool Type

Developer Tool Type	Recommended Boilerplate	Add
API product (usage-based)	Makerkit	Stripe Meters (built-in)
AI API wrapper	Midday v1	API keys + Stripe Meters
CLI SaaS	T3 Stack	Clerk auth + custom billing
VS Code extension backend	OpenSaaS	API endpoints
Developer analytics tool	Midday v1	Custom analytics DB
SDK with dashboard	ShipFast	API key management

Methodology

Based on publicly available information from each boilerplate's documentation, pricing pages, and community resources as of March 2026.

---

Building a developer tool? StarterPick helps you find the right SaaS boilerplate based on your features, billing model, and audience.