Price: ~$79-$99 (check the creator's site for current pricing) Core features: SvelteKit + TypeScript Auth: Lucia Auth Payments: Stripe (one-time or subscriptions) Email: Resend Database: Prisma + PostgreSQL UI: Tailwind (minimal components) SEO basics ---

Indie Kit Review 2026: Minimal SvelteKit SaaS Kit

TL;DR

Indie Kit is a lean SvelteKit SaaS starter designed for solo developers who want to ship quickly without unnecessary complexity. Smaller feature set than SvelteShip, lower price (~$79-$99), and a refreshingly minimal codebase. Best for indie hackers who want to read and understand every line before customizing.

What You Get

Price: ~$79-$99 (check the creator's site for current pricing)

Core features:

SvelteKit + TypeScript
Auth: Lucia Auth
Payments: Stripe (one-time or subscriptions)
Email: Resend
Database: Prisma + PostgreSQL
UI: Tailwind (minimal components)
SEO basics

The Minimalist Philosophy

Indie Kit's value proposition is simplicity. The codebase is intentionally small:

indie-kit/
├── src/
│   ├── routes/
│   │   ├── (auth)/
│   │   │   ├── login/
│   │   │   └── signup/
│   │   ├── (app)/
│   │   │   └── dashboard/
│   │   └── api/
│   │       ├── webhooks/
│   │       └── checkout/
│   ├── lib/
│   │   ├── auth.ts          ← 80 lines
│   │   ├── stripe.ts        ← 60 lines
│   │   └── email.ts         ← 40 lines
│   └── server/
└── prisma/schema.prisma

The auth module is 80 lines. The Stripe module is 60 lines. You can read the entire codebase in 30 minutes and understand exactly what it does.

Clean SvelteKit Patterns

// src/hooks.server.ts — auth in 25 lines
import { lucia } from '$lib/auth';
import type { Handle } from '@sveltejs/kit';

export const handle: Handle = async ({ event, resolve }) => {
  const sessionId = event.cookies.get(lucia.sessionCookieName);

  if (!sessionId) {
    event.locals.user = null;
    event.locals.session = null;
    return resolve(event);
  }

  const { session, user } = await lucia.validateSession(sessionId);

  if (session?.fresh) {
    const cookie = lucia.createSessionCookie(session.id);
    event.cookies.set(cookie.name, cookie.value, { path: '.', ...cookie.attributes });
  }

  if (!session) {
    const blankCookie = lucia.createBlankSessionCookie();
    event.cookies.set(blankCookie.name, blankCookie.value, { path: '.', ...blankCookie.attributes });
  }

  event.locals.user = user;
  event.locals.session = session;
  return resolve(event);
};

<!-- src/routes/(app)/dashboard/+page.svelte -->
<script lang="ts">
  import type { PageData } from './$types';

  let { data } = $props<{ data: PageData }>();
</script>

<h1>Welcome back, {data.user.email}</h1>

{#if data.isPro}
  <ProFeatures />
{:else}
  <UpgradePrompt />
{/if}

// src/routes/(app)/dashboard/+page.server.ts
import { redirect } from '@sveltejs/kit';
import type { PageServerLoad } from './$types';

export const load: PageServerLoad = async ({ locals }) => {
  if (!locals.user) redirect(302, '/login');

  const subscription = await getActiveSubscription(locals.user.id);

  return {
    user: locals.user,
    isPro: subscription?.status === 'active',
  };
};

One-Time vs Subscription Payments

Indie Kit supports both models — useful for info products or lifetime licenses:

// src/routes/api/checkout/+server.ts
export const POST: RequestHandler = async ({ request, locals }) => {
  if (!locals.user) return json({ error: 'Unauthorized' }, { status: 401 });

  const { mode } = await request.json();

  const sessionConfig = mode === 'payment'
    ? {
        mode: 'payment' as const,
        line_items: [{ price: env.STRIPE_LIFETIME_PRICE_ID, quantity: 1 }],
      }
    : {
        mode: 'subscription' as const,
        line_items: [{ price: env.STRIPE_MONTHLY_PRICE_ID, quantity: 1 }],
        subscription_data: { trial_period_days: 14 },
      };

  const session = await stripe.checkout.sessions.create({
    customer: locals.user.stripeCustomerId,
    ...sessionConfig,
    success_url: `${BASE_URL}/dashboard?success=true`,
    cancel_url: `${BASE_URL}/pricing`,
  });

  return json({ url: session.url });
};

This flexibility is useful for indie products that sell both subscriptions and lifetime deals.

Limitations

No blog included (add Svelte content or write MDX yourself)
No admin panel
Minimal UI components (you build most UI yourself)
Small community (harder to find specific answers)
Less documentation than larger boilerplates

Indie Kit vs SvelteShip

Feature	Indie Kit	SvelteShip
Price	~$79-99	~$149
Blog	❌	✅
UI components	Minimal	Skeleton UI
Codebase size	Small (easy to read)	Medium
Svelte 5 runes	Varies	✅
One-time + subscription	✅	Subscription only

Indie Kit for minimalism and lower cost; SvelteShip for more complete feature set.

Who Should Buy Indie Kit

Good fit:

Solo developers who want to read and own every line of code
Info product creators (courses, ebooks) needing one-time payment support
SvelteKit developers building their first SaaS
Budget-conscious founders

Bad fit:

Teams needing admin panel or blog out of the box
Products with complex UI requirements
Teams who need community support resources

Final Verdict

Rating: 3/5

Indie Kit delivers exactly what it promises: a minimal, readable SvelteKit foundation for solo developers. The low price and clean codebase are genuine strengths. The limited features mean more building on your own — appropriate for developers who see that as a feature, not a limitation.

Getting Started

After purchase, clone and configure the environment variables:

git clone https://your-indie-kit-repo.git my-app
cd my-app && npm install

cp .env.example .env
# Required environment variables:
# DATABASE_URL=postgresql://...
# LUCIA_SECRET=<openssl rand -base64 32>
# STRIPE_SECRET_KEY=sk_test_...
# STRIPE_WEBHOOK_SECRET=whsec_...
# RESEND_API_KEY=re_...

npx prisma db push
npm run dev  # → localhost:5173

Initial setup takes 15-20 minutes — faster than most boilerplates because the codebase is small. Create a PostgreSQL database (Neon or Supabase free tier works), configure one Stripe product, and add a Resend API key. The documentation walks through each step clearly.

Deploying Indie Kit

Indie Kit is a SvelteKit app, which deploys well to Vercel, Netlify, or Fly.io.

Vercel (recommended):

npm install -g vercel
vercel --prod
# Set environment variables in Vercel dashboard

Fly.io (for Docker-based deployment):

fly launch
fly secrets set DATABASE_URL=postgresql://...
fly secrets set LUCIA_SECRET=your-secret
fly deploy

For database, Neon's free tier (0.5GB, serverless) is the easiest starting point. The Prisma connection string works directly — no special adapter needed. Add ?pgbouncer=true&connection_limit=1 to the connection string for Vercel's serverless environment to avoid connection pool exhaustion.

Indie Kit vs LaunchFast SvelteKit

Two SvelteKit SaaS starters at similar price points with different philosophies:

Feature	Indie Kit	LaunchFast
Price	~$79-99	~$149
Auth	Lucia (simple)	Auth.js (flexible)
Blog	❌	✅ MDX
Admin	❌	✅
One-time payments	✅	❌
Svelte 5	Partial	✅
Codebase size	Minimal	Medium

The right choice depends on your product. Indie Kit's support for one-time payments is unique and valuable for info products, tools, and lifetime license models. LaunchFast is more complete out of the box but costs more and ships more code you'll need to remove.

When to Extend Indie Kit

Indie Kit's minimal surface area means you'll add features in the first month. Prioritize based on your product:

Blog: Add @sveltejs/enhanced-img and a content/ directory with markdown files. SvelteKit's file-based routing handles the URL structure automatically. Basic blog takes three to four hours.

OAuth providers: Lucia supports additional OAuth providers through its adapter system. Adding GitHub OAuth after the initial Google setup takes 20 minutes — just add the provider config and callback route. The existing pattern in src/lib/auth.ts is the template to follow.

Admin panel: For data visibility, add a protected /admin route group and query Prisma directly. Indie Kit doesn't scaffold this, but the flat codebase makes it straightforward to add — you're not fighting an existing admin abstraction.

Email sequences: The Resend integration in src/lib/email.ts sends transactional emails. For sequences (onboarding, dunning), add a scheduled function via Vercel Cron or a simple PostgreSQL-backed job table with a cron endpoint.

The pattern holds: Indie Kit's simplicity accelerates feature addition because you're building on readable code, not modifying around existing abstractions.

Key Takeaways

Indie Kit costs $79-99 and delivers a clean, minimal SvelteKit foundation — auth, Stripe, and email in under 200 lines total
The real value is readability: you can trace every request from frontend to database in 30 minutes
Supports both one-time and subscription payments — uncommon in this price range and valuable for info products
No blog, admin panel, or multi-tenancy — plan to add them, or choose a more complete starter
Best fit: solo developers who want to own their codebase deeply, not configure a framework
Deploys to Vercel or Fly.io with standard SvelteKit adapter setup; Neon or Supabase free tier handles the database at zero cost while validating
SvelteKit 2 with Svelte 5 support is evolving rapidly — verify the kit tracks upstream Svelte releases before committing
At $79-99, Indie Kit is priced below most competitors in the SvelteKit space, making it accessible for developers who want a clean starting point without overcommitting budget before validating an idea

Compare Indie Kit with other SvelteKit starters on StarterPick.

See our SvelteShip review for the more feature-complete SvelteKit alternative.

Browse best SaaS boilerplates for indie hackers for the full comparison.

Limitations and When to Skip Indie Kit

Indie Kit's minimal philosophy is a genuine strength for experienced developers, but there are clear cases where the minimalism becomes a liability rather than an asset.

If you need an admin panel from day one. Indie Kit ships no admin infrastructure. Building a basic admin panel from scratch — user list, subscription management, impersonation — takes 3-5 days on top of Indie Kit's foundation. If your product needs admin capabilities at launch, you will spend a significant portion of your first week building plumbing rather than product. A more complete starter like Svelteship or a Next.js boilerplate with built-in admin saves that week.

If you are building B2B multi-tenant SaaS. Indie Kit has no organization management, team invitations, or multi-tenancy. These are 2-3 weeks of non-trivial work to build correctly — role-based access control, organization switching, per-organization billing. If your product is a team tool from day one, Indie Kit's foundation needs substantial augmentation before you can build the differentiated features.

If the Svelte 5 migration is unfinished when you start. SvelteKit 2 and Svelte 5 (Runes API) are significant changes from Svelte 4. Indie Kit's Svelte 5 support is described as "partial" in 2026. Starting a new project on a partially-migrated boilerplate means some code follows the old Svelte 4 reactive patterns and some uses Runes — a split that creates confusing inconsistencies in a codebase you intend to maintain for years. Verify the migration status before starting.

If community support is important to your workflow. Indie Kit has a small user base compared to ShipFast or T3 Stack. When you hit an unusual problem — a Stripe webhook edge case, a SvelteKit middleware timing issue — you are unlikely to find a Stack Overflow answer specific to Indie Kit. You are working directly with SvelteKit and Lucia documentation, which is fine for experienced developers but harder for developers who rely on community patterns.

For the full comparison of SvelteKit boilerplates, see the best SvelteKit SaaS boilerplates guide. For solo developers considering whether SvelteKit or Next.js is the right choice for their first SaaS product, the best SaaS boilerplates guide covers both ecosystems side-by-side.

The boilerplate that works best is the one your team can productively extend. Documentation quality, community activity, and the clarity of the codebase architecture matter as much as the feature list when you're making the decision for a product you'll maintain for years.

Indie Kit's straightforward configuration means less time fighting abstractions and more time building features. For solo founders who value pragmatic simplicity over architectural elegance, it's the fastest path from template to production.

Compare Indie Kit with other SvelteKit starters on StarterPick.

See the best SvelteKit SaaS boilerplates guide for the full SvelteKit comparison.

Browse the best SaaS boilerplates guide for the complete cross-framework comparison.

The SaaS Boilerplate Matrix (Free PDF)