Best Expo React Native SaaS Boilerplates 2026

Building a SaaS that works on web, iOS, and Android used to mean maintaining three separate codebases. Expo changed that — one React Native codebase deploys to iOS, Android, and increasingly to web via Expo Web. In 2026, Expo Router v4 brings file-based routing that mirrors React Router and Next.js, making the mental model consistent across platforms.

The challenge: building a production-ready mobile SaaS still requires auth flows that work on mobile, in-app purchases (Apple/Google) OR web-based subscriptions (Stripe), push notifications, deep linking, and an API backend that serves both your mobile app and any web dashboard. These starters solve that complexity.

Quick Comparison

Starter	Price	Auth	Payments	Push Notifications	Backend	Platform
Launch (launchtoday.dev)	$199	Better Auth	Stripe	✅ Expo Push	Node.js	iOS + Android
React Native Boilerplate	$97–249	Custom	Stripe	✅	Supabase	iOS + Android
MobileBoilerplate	Free	Clerk	Stripe	✅	Supabase	iOS + Android
MakerKit React Native	$299	Supabase Auth	Stripe	✅	Supabase	iOS + Android + Web
Obytes Starter	Free	Custom	❌	❌	None	iOS + Android
Ignite (Infinite Red)	Free	❌	❌	❌	None	iOS + Android

The Mobile SaaS Tech Decision

Before choosing a starter, you need to decide on your payment strategy — it's the biggest architectural difference between mobile SaaS options:

Option A: Apple/Google IAP (In-App Purchases)

Required if your app's primary value is consumed on mobile
Apple takes 30% (15% for small developers)
More complex implementation (RevenueCat abstracts this)
Users expect it for pure mobile apps

Option B: Stripe on Web + Mobile

Works if users can also access your product on web
You keep 97% (Stripe 3%)
Simpler implementation
Against Apple's TOS if the app only has mobile value

Most developer SaaS tools use Option B (Stripe, web paywall, mobile app is a client). Most consumer apps use Option A. The starters below primarily cover Option B unless noted.

1. Launch (launchtoday.dev) — Best Modern Mobile SaaS Starter

Price: $199 | Stack: Expo + React Native + Better Auth + Stripe + Node.js

Launch is purpose-built for mobile SaaS founders. It ships with a complete backend (Node.js API), mobile client (Expo), and web dashboard — the three components most mobile SaaS products need.

What's included:

Better Auth for mobile session management (JWT + refresh tokens)
Protected routes with automatic redirect to login
Stripe subscriptions (web checkout flow, accessible from mobile)
Expo Push Notifications pre-configured
Deep linking setup with Expo Router
Onboarding flow screens
Dashboard with analytics
Supabase or Prisma + PostgreSQL (you choose)

// Launch's mobile auth pattern with Better Auth
// app/lib/auth.ts
import { createAuthClient } from 'better-auth/react';

export const authClient = createAuthClient({
  baseURL: process.env.EXPO_PUBLIC_API_URL,
});

// In your login screen:
export function LoginScreen() {
  const { signIn } = useAuthClient();

  const handleGoogleSignIn = async () => {
    await signIn.social({
      provider: 'google',
      // Expo-specific redirect for mobile OAuth
      callbackURL: Linking.createURL('/auth/callback'),
    });
  };

  return (
    <View>
      <Button onPress={handleGoogleSignIn} title="Sign in with Google" />
    </View>
  );
}

Push notifications pattern:

// Launch's Expo Push setup
// app/hooks/usePushNotifications.ts
import * as Notifications from 'expo-notifications';
import Constants from 'expo-constants';

export async function registerForPushNotifications() {
  const { status } = await Notifications.requestPermissionsAsync();
  if (status !== 'granted') return null;

  const token = await Notifications.getExpoPushTokenAsync({
    projectId: Constants.expoConfig?.extra?.eas?.projectId,
  });

  // Save token to your backend
  await api.post('/users/push-token', { token: token.data });
  return token.data;
}

Best for: Mobile SaaS founders who need a complete stack (backend + mobile + web) from a single purchase.

2. React Native Boilerplate (reactnativeboilerplate.com) — Best Commercial Kit

Price: $97 (Basic) / $249 (Pro) | Stack: Expo + Supabase + Stripe + NativeWind

A commercial React Native SaaS starter with three tiers:

Basic ($97): Auth, navigation, basic API integration
Standard ($149): + Stripe billing, push notifications
Pro ($249): + RevenueCat (IAP), advanced analytics, multi-tenancy

The Pro tier's RevenueCat integration is worth highlighting — RevenueCat abstracts Apple/Google IAP into a single API, handling receipt validation, subscription tracking, and entitlements. It's the correct way to implement IAP:

// RevenueCat integration (Pro tier)
import Purchases, { PurchasesOffering } from 'react-native-purchases';

// Initialize (in app root)
Purchases.configure({
  apiKey: Platform.OS === 'ios'
    ? process.env.REVENUECAT_IOS_KEY!
    : process.env.REVENUECAT_ANDROID_KEY!,
  appUserID: userId,
});

// Check entitlements
const customerInfo = await Purchases.getCustomerInfo();
const isPremium = customerInfo.entitlements.active['premium'] !== undefined;

// Purchase a subscription
async function purchaseSubscription(offering: PurchasesOffering) {
  const { customerInfo } = await Purchases.purchasePackage(
    offering.monthly! // or .annual
  );
  return customerInfo.entitlements.active['premium'] !== undefined;
}

3. MobileBoilerplate — Best Free Option

Price: Free | Stack: Expo + Clerk + Stripe + Supabase

MobileBoilerplate is a 100% free Expo starter that covers the essentials without charging for the template. The trade-off: Clerk's free tier limits (10,000 MAU) and Supabase's free tier limits apply — but for getting to market, both are generous.

// MobileBoilerplate: Clerk auth in Expo
// components/AuthProvider.tsx
import { ClerkProvider, useAuth } from '@clerk/clerk-expo';
import * as SecureStore from 'expo-secure-store';

// Expo-specific token cache for Clerk
const tokenCache = {
  getToken: (key: string) => SecureStore.getItemAsync(key),
  saveToken: (key: string, value: string) =>
    SecureStore.setItemAsync(key, value),
};

export function AuthProvider({ children }: { children: React.ReactNode }) {
  return (
    <ClerkProvider
      publishableKey={process.env.EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY!}
      tokenCache={tokenCache}
    >
      {children}
    </ClerkProvider>
  );
}

4. MakerKit React Native — Best for Web + Mobile

Price: $299 | Stack: Expo + Next.js + Supabase + Stripe (monorepo)

MakerKit's React Native starter is unique: it's a Turborepo monorepo with both the Next.js web app and Expo mobile app sharing auth, API clients, and UI logic. If you're building a SaaS that needs web AND mobile, this is the most architecturally sound starter.

MakerKit monorepo structure:
  apps/
    web/          # Next.js SaaS app
    mobile/       # Expo React Native app
  packages/
    core/         # Shared auth, API client, types
    ui/           # Shared component library (NativeWind)
    database/     # Shared Supabase client + queries

Both apps use the same Supabase auth session, same subscription state, same user model. One user account, multiple surfaces.

5. Obytes Starter — Best Free Foundation

Price: Free (MIT) | Stack: Expo Router + NativeWind + Zustand + React Query

Obytes is the most popular free Expo starter for structuring mobile apps well, even though it's not SaaS-specific. No billing, no auth backend — but excellent architecture patterns for Expo Router navigation, NativeWind styling, React Query data fetching, and Zustand state management.

Use Obytes as a foundation and add your own auth (Better Auth or Supabase) and billing. The developer experience tooling (testing, linting, CI) is the best of any free starter.

Expo Router v4 Pattern (All Starters Benefit From)

Expo Router v4's file-based routing makes mobile navigation as clean as Next.js:

// app/(auth)/_layout.tsx — Auth group
import { Redirect, Stack } from 'expo-router';
import { useAuth } from '~/hooks/useAuth';

export default function AuthLayout() {
  const { user } = useAuth();

  // Redirect authenticated users away from auth screens
  if (user) return <Redirect href="/(app)/dashboard" />;

  return (
    <Stack>
      <Stack.Screen name="login" options={{ title: 'Sign In' }} />
      <Stack.Screen name="signup" options={{ title: 'Create Account' }} />
    </Stack>
  );
}

// app/(app)/_layout.tsx — Protected app group
export default function AppLayout() {
  const { user } = useAuth();

  // Redirect unauthenticated users to login
  if (!user) return <Redirect href="/(auth)/login" />;

  return <Tabs>{/* Your tab navigation */}</Tabs>;
}

Choosing Your Expo SaaS Starter

Best overall (paid): Launch — complete backend + mobile + web stack in one purchase.

Best for IAP (Apple/Google payments): React Native Boilerplate Pro — RevenueCat integration is production-ready.

Best free: MobileBoilerplate — Clerk + Stripe without paying for the template.

Best web + mobile monorepo: MakerKit React Native — shared auth and API logic across Next.js and Expo.

Best architecture foundation: Obytes Starter — add your own backend, but the mobile architecture patterns are excellent.

How to Evaluate Expo SaaS Starters

Evaluating mobile SaaS starters requires testing beyond what a README describes. The patterns that break silently in mobile apps — OAuth on real devices, push notification registration with EAS, deep link handling across iOS and Android — are hard to see in a screenshot or demo video.

Test OAuth on a real device, not the simulator. Mobile OAuth has a different flow than web OAuth. The app opens a browser, the user authenticates, and the browser redirects back to the app via a custom URL scheme. This flow works consistently in simulators but breaks on real devices when the URL scheme isn't registered correctly in the native build configuration. Before committing to a starter, either test it on a real device or verify that the app.json/app.config.ts includes the correct scheme configuration for each OAuth provider.

Check push notification token registration. Expo Push Notifications require an EAS project ID in Constants.expoConfig.extra.eas.projectId. Starters that use a placeholder value (your-project-id-here) or omit this configuration entirely will fail silently — the notification permission will be granted but no token will be registered. Verify the push notification setup handles the EAS project ID correctly and shows an appropriate error when it's not configured.

Verify the payment flow on both platforms. If the starter uses Stripe (web checkout) rather than RevenueCat (native IAP), verify that the checkout URL opens in the correct browser context and that the return URL scheme redirects back to the app after payment. If using RevenueCat, verify that the apiKey is platform-specific (iOS and Android have separate keys) and that entitlement checking works correctly for free and paid users.

Check deep link configuration. Expo Router v4's file-based routing makes deep links easier to implement, but the native URL scheme and associated domain configuration still require manual setup. A starter that doesn't include example deep link configuration for both platforms leaves you writing the most error-prone mobile setup step yourself.

What These Starters Have in Common

The starters in this guide vary significantly in price, stack, and feature completeness. Despite these differences, they converge on several architectural patterns that reflect lessons from building mobile SaaS at production scale:

Better Auth or Clerk for authentication rather than building custom JWT management. Both handle token storage in Expo SecureStore (not AsyncStorage, which is not encrypted), refresh token rotation, and the mobile-specific OAuth flow. The session management patterns they provide are significantly more secure than what most developers build themselves.

Stripe for payments rather than native IAP unless the product requires it. The 30% Apple/Google commission is significant, but Stripe's implementation complexity is dramatically lower than RevenueCat for most developer tools. Products where users can access the service on web (and therefore aren't required to use IAP by Apple's guidelines) almost always use Stripe.

Expo Router v4 for navigation. The file-based routing matches the mental model from Next.js and React Router v7, reducing the cognitive overhead of switching between web and mobile contexts in a monorepo setup.

Supabase or a custom Node.js API for the backend, with shared types between the mobile client and the server. The type-sharing is the highest-value feature of any mobile+web monorepo — database schema changes propagate to TypeScript errors in both the mobile and web clients simultaneously.

For the web-side of a mobile+web SaaS, the best SaaS boilerplates guide covers the Next.js foundations that pair well with Expo. For a monorepo structure that formally connects a Next.js web app with an Expo mobile app, the best monorepo boilerplates guide covers T3 Turbo and MakerKit's React Native offering in depth. For the financial and time-cost analysis of building mobile SaaS infrastructure from scratch vs buying a starter, see the buy vs build SaaS guide.

Browse all React Native and Expo boilerplates at StarterPick.

The SaaS Boilerplate Matrix (Free PDF)