Source: github.com/dev-xo/remix-saas Core features: Remix 2.x + TypeScript Auth: cookie-based sessions + OAuth (GitHub, Google) Payments: Stripe subscriptions Database: Prisma + PostgreSQL (or SQLite for dev) UI: Tailwind CSS + shadcn/ui Email: Resend integration Organizations/teams Plan management Free / MIT licensed ---

Remix SaaS Review 2026: Free Remix Starter Kit

TL;DR

Remix SaaS is a solid free alternative to Epic Stack for Remix-based SaaS products. It includes auth, Stripe, multi-tenancy via organizations, and a clean project structure without Epic Stack's SQLite-first opinionation. Free and MIT licensed. Best for Remix developers who want PostgreSQL over SQLite and a lighter footprint than Epic Stack.

What You Get

Source: github.com/dev-xo/remix-saas

Core features:

Remix 2.x + TypeScript
Auth: cookie-based sessions + OAuth (GitHub, Google)
Payments: Stripe subscriptions
Database: Prisma + PostgreSQL (or SQLite for dev)
UI: Tailwind CSS + shadcn/ui
Email: Resend integration
Organizations/teams
Plan management
Free / MIT licensed

The Core Architecture

Remix SaaS follows Remix conventions closely — loaders, actions, and progressive enhancement:

// routes/_app.dashboard.tsx — loader pattern
import { json, type LoaderFunctionArgs } from '@remix-run/node';
import { useLoaderData } from '@remix-run/react';
import { requireUser } from '~/services/auth.server';
import { getOrganizationByUserId } from '~/services/organization.server';

export async function loader({ request }: LoaderFunctionArgs) {
  const user = await requireUser(request);
  const organization = await getOrganizationByUserId(user.id);

  return json({
    user,
    organization,
    plan: organization.subscription?.plan ?? 'free',
  });
}

export default function Dashboard() {
  const { user, organization, plan } = useLoaderData<typeof loader>();

  return (
    <div>
      <h1>Welcome, {user.name}</h1>
      <p>Organization: {organization.name}</p>
      <p>Plan: {plan}</p>
    </div>
  );
}

Authentication

// services/auth.server.ts — Remix session-based auth
import { createCookieSessionStorage, redirect } from '@remix-run/node';
import { prisma } from '~/utils/db.server';
import bcrypt from 'bcryptjs';

const sessionStorage = createCookieSessionStorage({
  cookie: {
    name: '__session',
    httpOnly: true,
    path: '/',
    sameSite: 'lax',
    secrets: [process.env.SESSION_SECRET!],
    secure: process.env.NODE_ENV === 'production',
  },
});

export async function requireUser(request: Request) {
  const session = await sessionStorage.getSession(request.headers.get('Cookie'));
  const userId = session.get('userId');

  if (!userId) throw redirect('/login');

  const user = await prisma.user.findUnique({ where: { id: userId } });
  if (!user) throw redirect('/login');

  return user;
}

export async function signIn(email: string, password: string) {
  const user = await prisma.user.findUnique({ where: { email } });
  if (!user || !user.passwordHash) return null;

  const valid = await bcrypt.compare(password, user.passwordHash);
  if (!valid) return null;

  return user;
}

Organization Management

// Multi-tenancy via organizations
export async function createOrganization(userId: string, name: string) {
  return prisma.organization.create({
    data: {
      name,
      slug: slugify(name),
      members: {
        create: {
          userId,
          role: 'owner',
        },
      },
    },
  });
}

export async function getOrganizationByUserId(userId: string) {
  const membership = await prisma.organizationMember.findFirst({
    where: { userId },
    include: {
      organization: {
        include: { subscription: true },
      },
    },
    orderBy: { createdAt: 'asc' }, // Primary org first
  });

  return membership?.organization ?? null;
}

Remix SaaS vs Epic Stack

Feature	Remix SaaS	Epic Stack
License	Free/MIT	Free/MIT
Database	PostgreSQL (Prisma)	SQLite (Drizzle)
Auth	Sessions + OAuth	Sessions + TOTP
UI	shadcn/ui	Custom
Testing	Basic	Full (Playwright + Vitest)
Email	Resend	Resend
Organizations	✅	❌ (user-centric)
Documentation	Minimal	Good
Maintenance	Community	Kent C. Dodds
Philosophy	Feature-rich	Production practices

Choose Remix SaaS when:

You need PostgreSQL (not SQLite)
You need organizations/multi-tenancy
You want shadcn/ui components

Choose Epic Stack when:

You want battle-tested production practices
SQLite + Litefs works for your scale
Testing is a priority

Limitations

Documentation: Minimal compared to Epic Stack or commercial alternatives
Testing: No comprehensive test setup (Epic Stack advantage)
Community: Smaller than Epic Stack (fewer tutorials)
Maintenance pace: Community-driven; can lag behind Remix releases
No i18n: Internationalization requires adding separately

Who Should Use Remix SaaS

Good fit:

Remix developers who want PostgreSQL over SQLite
Teams needing organizations/multi-tenancy with Remix
Developers familiar with Remix who want a starting point
Products where Epic Stack's SQLite approach doesn't fit

Bad fit:

Teams new to Remix (documentation gaps hurt beginners)
Products needing comprehensive testing from day one
Teams wanting commercial support or SLA

Stripe Billing for Organizations

Remix SaaS attaches subscriptions to organizations, not individual users — the correct B2B SaaS pattern where all org members share plan access:

// services/stripe.server.ts
export async function createCheckoutSession(orgId: string, priceId: string) {
  const org = await prisma.organization.findUniqueOrThrow({ where: { id: orgId } });
  return stripe.checkout.sessions.create({
    mode: 'subscription',
    customer: org.stripeCustomerId ?? undefined,
    line_items: [{ price: priceId, quantity: 1 }],
    success_url: `${process.env.APP_URL}/dashboard?checkout=success`,
    cancel_url: `${process.env.APP_URL}/pricing`,
    subscription_data: { metadata: { organizationId: orgId } },
  });
}

This means plan upgrades apply to the whole team. When a member checks whether they have access to a feature, the query is against the organization's subscription status — not their individual account.

Extending the Codebase

The service files (auth.server.ts, stripe.server.ts, organization.server.ts) contain business logic separately from route handlers. Common additions after initial setup:

Feature gating by plan: Load the subscription plan in the dashboard layout loader, pass it to child routes. Remix's nested layouts make plan-based access clean without prop drilling — every dashboard route has the plan available without an extra fetch.

User invitations: Create invite tokens, send via Resend, handle acceptance in a Remix action that creates an organizationMember record. The membership model is already in place.

Admin dashboard: Add a protected /admin route group with organization/user listings. The Prisma models are simple enough that a basic admin view takes 2-3 hours.

Why Remix for Multi-Tenant SaaS

Remix's loader/action pattern solves client-server state synchronization — a class of bugs that React Query, SWR, and Zustand exist to manage in Next.js. For SaaS where every page shows database state (organization data, subscription status, feature flags), Remix's server-rendered approach reduces the surface area for stale data bugs.

Every form in Remix works without JavaScript by default, which means the product remains functional when JS fails or loads slowly. For business-critical SaaS that customers depend on daily, this reliability characteristic matters.

Final Verdict

Rating: 3.5/5

Remix SaaS is a capable free foundation for Remix-based SaaS products. The organization system differentiates it from Epic Stack, and PostgreSQL over SQLite suits more deployment scenarios. The limitations (sparse documentation, smaller community, no testing setup) are real trade-offs. For Remix teams that need multi-tenancy and PostgreSQL, it's the best free option available.

Getting Started

# Clone the repository
git clone https://github.com/dev-xo/remix-saas.git my-app
cd my-app && npm install

# Configure environment
cp .env.example .env
# Required:
# DATABASE_URL=postgresql://...  (or file:./dev.db for SQLite)
# SESSION_SECRET=<random-32-char-string>
# STRIPE_SECRET_KEY=sk_test_...
# STRIPE_WEBHOOK_SECRET=whsec_...
# RESEND_API_KEY=re_...
# GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET (for OAuth)
# GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET (for OAuth)

# Push database schema
npx prisma db push

# Start development
npm run dev  # → localhost:3000

Setup takes 45-60 minutes. The Stripe configuration requires creating subscription plans and adding the price IDs to your configuration. GitHub OAuth is the quickest OAuth provider to set up for development — create an OAuth app in GitHub settings and add the credentials.

The Stripe Subscription Flow

// app/routes/api.checkout.ts — Remix action
import { type ActionFunctionArgs, redirect } from '@remix-run/node';
import { requireUser } from '~/services/auth.server';
import { stripe } from '~/services/stripe.server';

export async function action({ request }: ActionFunctionArgs) {
  const user = await requireUser(request);
  const formData = await request.formData();
  const priceId = formData.get('priceId') as string;

  // Get or create Stripe customer for this user's org
  const organization = await getOrganizationByUserId(user.id);
  const customerId = await getOrCreateStripeCustomer(organization);

  const session = await stripe.checkout.sessions.create({
    mode: 'subscription',
    customer: customerId,
    line_items: [{ price: priceId, quantity: 1 }],
    success_url: `${process.env.APP_URL}/dashboard?upgrade=true`,
    cancel_url: `${process.env.APP_URL}/pricing`,
    metadata: { organizationId: organization.id },
  });

  return redirect(session.url!);
}

The Remix action pattern — form submission handled server-side — is cleaner for Stripe redirects than API route approaches. No client-side JavaScript needed to initiate checkout.

Why Remix for SaaS in 2026

Remix's architecture has concrete advantages for SaaS dashboards:

Form actions without client-side state: User settings, profile updates, and plan changes can be forms that submit to Remix actions. No useState, no API calls, no loading spinners — the Remix progressive enhancement model handles success and error states automatically.

Nested layouts with parallel data loading: A SaaS dashboard typically has user data, organization data, and page-specific data loading simultaneously. Remix's nested route loaders run in parallel, eliminating the waterfall loading pattern that Next.js page components can fall into.

Error boundaries per route: Remix's error boundary system means a broken widget on your analytics page doesn't crash the entire dashboard. Each route has its own error boundary — failures are isolated.

The trade-off: React Server Components and the Next.js App Router provide better SEO optimization for marketing pages. Remix's strengths are concentrated in application dashboards with complex user interactions, not content-heavy marketing sites.

Key Takeaways

Remix SaaS is the best free MIT-licensed Remix boilerplate with multi-tenancy and PostgreSQL support
Organizations are built-in — the subscription attaches to an organization, not an individual user, enabling team billing
Remix's loader/action pattern eliminates client-side state for most CRUD operations — dashboards feel faster and simpler to build
Documentation is sparse compared to Epic Stack; plan to read source code when you hit edge cases
For teams committed to Remix over Next.js, this is the starting point to use

Remix SaaS in the Broader Ecosystem

Remix's position in the SaaS boilerplate space is specific. It's not the default choice — Next.js App Router has more boilerplates, more tutorials, and a larger community. Remix SaaS (and Epic Stack) represent a committed minority who prefer Remix's server model.

The case for Remix in 2026: full-stack progressive enhancement means your SaaS works without JavaScript. Server actions handle form submissions, redirects, and optimistic UI through Remix's built-in mechanisms rather than custom client-side state. For B2B SaaS dashboards — forms, tables, settings, data management — this model produces leaner code than equivalent React component state management.

The case against: React Server Components in Next.js App Router provide similar server-side data access with a larger ecosystem. The Remix-specific knowledge (loaders, actions, nested layouts) is a real onboarding cost for Next.js developers joining the team.

Remix SaaS is the right starting point if your team has made the Remix commitment. Otherwise, evaluate Epic Stack's more complete test setup and documentation before choosing the community-maintained Remix SaaS.

One practical consideration: Remix SaaS's multi-tenancy and organization billing model makes it suitable for B2B SaaS out of the box in a way that Epic Stack is not. Epic Stack's SQLite model works well for single-user or small-scale applications; Remix SaaS's PostgreSQL foundation and organization model scales naturally to multi-team B2B products. The architectural choice between the two maps to product requirements as much as it does to framework preference. Remix SaaS is the pragmatic starting point for B2B multi-tenant products; Epic Stack is the learning-focused foundation for developers who want to understand every architectural decision in their codebase.

Deploying Remix SaaS follows standard Remix deployment patterns. Fly.io is the recommended target (matching Epic Stack's deployment story), though Vercel with a Node.js adapter works for teams already using Vercel. The PostgreSQL database connects via a standard DATABASE_URL environment variable — Neon, Supabase, or a managed RDS instance are all viable. Database migrations run through Prisma's migrate deploy command during the build step. The production environment variables are identical to what any Remix + Prisma + Stripe application would need, which means existing deployment documentation from the Remix ecosystem applies directly. This is the practical benefit of a boilerplate built on mainstream patterns rather than custom abstractions — the debugging path when something goes wrong in production leads to answers that already exist in the community. Remix SaaS received updates in 2025 to keep Prisma and Stripe dependencies current, and the community around it remains active — a positive signal for a free boilerplate that depends on volunteer maintenance velocity.

Compare Remix SaaS with Epic Stack and other Remix starters in our best open-source SaaS boilerplates guide.

See our Epic Stack review for the production-practices-focused alternative.

See how multi-tenancy patterns compare in our multi-tenancy patterns guide.

The SaaS Boilerplate Matrix (Free PDF)