if your team starts more than one React Native app a year, a starter template pays for itself the second time you use it. Start from create-expo-app, add only the decisions you make every time (TypeScript, routing with an auth gate, styling, a mobile-safe Supabase client, env validation, CI, EAS profiles and an AI rules file), make the app's identity configurable instead of hard-coded, publish it as a template repo, and treat it like a product with its own CI and upgrade schedule.

The first three days of every new React Native project look the same: set up TypeScript, pick a router, wire styling, configure the backend client, fight environment variables, write the same CI workflow again. None of it is the product. All of it is easy to get subtly wrong.

A starter template turns those three days into one command. More importantly, it turns your team's hard-won decisions into the default.

Template, boilerplate or starter?

The words get used interchangeably, so let's be precise:

  • A boilerplate is a full project you clone and then edit. Often big, often opinionated about features.
  • A template is a project designed to be copied as a starting point, with the app's identity left to fill in.
  • A starter is the friendly name for either.

This guide is about the second kind: small, configurable and owned by your team.

Rule one: only include decisions you make every time

The temptation is to include everything. Resist it. Every feature in a template is a feature someone has to delete in every project that doesn't need it.

A good test: would you add this in the first day of almost every project? If yes, it belongs. If "it depends", document it as an optional add-on instead.

Here's what usually passes the test.

The core of the template

my-starter/ ├── app/ # Expo Router routes only │ ├── _layout.tsx # root stack + auth gate │ ├── (auth)/sign-in.tsx │ └── (app)/(tabs)/ │ ├── _layout.tsx │ ├── index.tsx │ └── settings.tsx # includes account deletion entry point ├── src/ │ ├── components/ # a few shared primitives (Button, Screen, Text) │ ├── features/ # empty, with a README explaining the pattern │ └── lib/ │ ├── env.ts # validated environment variables │ ├── supabase.ts # mobile-safe client │ └── query.ts # TanStack Query client ├── supabase/ │ ├── migrations/ # profiles table with RLS │ └── functions/delete-account/ ├── .github/workflows/ci.yml ├── AGENTS.md # rules for AI coding tools ├── app.config.ts # identity from env, not hard-coded ├── eas.json # development / preview / production └── README.md # "first 15 minutes" guide 

A few of these deserve a closer look.

Configurable app identity

Hard-coded names and bundle identifiers are the most common template mistake: every new project starts with a find-and-replace and at least one missed spot. Use a dynamic config that reads identity from environment variables:

// app.config.ts import type { ExpoConfig } from 'expo/config'; const name = process.env.APP_NAME ?? 'Starter App'; const slug = process.env.APP_SLUG ?? 'starter-app'; const bundleId = process.env.APP_BUNDLE_ID ?? 'com.example.starter'; const scheme = process.env.APP_SCHEME ?? 'starterapp'; const ios = { bundleIdentifier: bundleId, }; const android = { package: bundleId, }; const config: ExpoConfig = { name, slug, scheme, version: '1.0.0', ios, android, plugins: ['expo-router'], }; export default config; 

A new project now changes four values in one .env file. Nothing else needs renaming.

Validated environment variables

Expo only inlines EXPO_PUBLIC_ variables that are referenced directly, and a missing one fails at runtime, often far from the cause. Validate them at startup so a misconfigured project fails loudly on the first launch:

// src/lib/env.ts import { z } from 'zod'; export const env = z .object({ EXPO_PUBLIC_SUPABASE_URL: z.string().url(), EXPO_PUBLIC_SUPABASE_ANON_KEY: z.string().min(1), }) .parse({ EXPO_PUBLIC_SUPABASE_URL: process.env.EXPO_PUBLIC_SUPABASE_URL, EXPO_PUBLIC_SUPABASE_ANON_KEY: process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY, }); 

A database that's secure from the first migration

Ship one migration that creates a profiles table with Row Level Security enabled and policies in place. It does two jobs: it gives new projects a working pattern to copy, and it makes "RLS on every table" the default rather than a lesson learned later.

An AI rules file

Most teams now build with AI coding agents, and the agent's first question is always "how is this project built?" Answer it once, in the template, so every project inherits it:

# AGENTS.md  ## Stack Expo (managed, development builds), TypeScript strict, Expo Router, NativeWind, Supabase (client in src/lib/supabase.ts), TanStack Query. ## Rules - Install native packages with `npx expo install`, never plain npm install. - New screens: route file in app/, logic in src/features/<feature>/. - New tables: enable RLS in the same migration, with policies using (select auth.uid()). - Never put secrets in EXPO_PUBLIC_ variables. ## Before finishing a task Run `npx tsc --noEmit`, `npx expo lint` and `npx expo-doctor`. 

Tools differ in which file name they read (AGENTS.md, CLAUDE.md and others), so keep one source of truth and link or copy it for the tools your team uses. The payoff is large: AI-generated code in every new project starts out following your conventions.

CI from commit one

# .github/workflows/ci.yml name: CI on: [pull_request] jobs: check: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-node@v4 with: node-version: 20 - run: npm ci - run: npx tsc --noEmit - run: npx expo lint - run: npx expo install --check - run: npx expo-doctor 

When CI exists from the first commit, nobody has to argue about adding it later.

A "first 15 minutes" README

The README is the template's onboarding. It should answer, in order: how to create a project from the template, which four identity values to set, how to connect Supabase, how to run a development build, and where the optional add-ons are documented.

Publishing the template

The simplest way is a GitHub template repository: mark the repo as a template, and anyone on the team can click "Use this template" to create a new project with clean history.

You can also point create-expo-app at your template, so starting a project is one command:

npx create-expo-app@latest my-new-app --template <your-template-package-or-repo-url> 

Check the current create-expo-app documentation for the template sources it supports (npm packages and repository URLs are the common options).

Keeping the template alive

A template that falls behind the current Expo SDK starts every project with an upgrade. Treat it like a product:

  • Give it its own CI that creates a project from the template and runs the checks, so a broken template is caught before anyone uses it.
  • Upgrade it first. When a new Expo SDK is released, upgrade the template within a month or two, then use it as the reference for upgrading your existing apps.
  • Keep native settings in config plugins, never in hand-edited ios/ and android/ folders, so upgrades stay mechanical.
  • Keep a short changelog, so teams know what changed since they started their project.
  • Move optional features out: payments, analytics, push notifications and chat as documented add-ons, not built-ins.

What to leave out

  • Example screens mixed into real code (put them in a separate examples branch or folder).
  • More than one way to do anything: one styling approach, one data-fetching library, one state solution.
  • Features "most apps will probably need someday".
  • Anything that needs a paid account just to run the template.

The template checklist

  1. Created from current create-expo-app, on the latest Expo SDK.
  2. Strict TypeScript, Expo Router with an auth gate.
  3. App identity configurable from environment variables.
  4. Validated environment variables.
  5. Mobile-safe Supabase client and a migration with RLS.
  6. Account deletion entry point in settings.
  7. AGENTS.md (or your tools' equivalent) with stack, rules and checks.
  8. CI that type-checks, lints and checks dependencies.
  9. eas.json with development, preview and production profiles.
  10. A README that gets someone running in 15 minutes.

Conclusion

A good React Native starter template is small, opinionated in the right places and easy to keep current. It removes the repetitive first days of every project, and more importantly, it makes your team's best decisions, from security rules to AI coding conventions, the starting point instead of something each project has to rediscover.

What's the first thing you add to every new React Native project? If it's not in your template yet, maybe it should be. Tell us in the comments.