Simple
Expo Kit

Simple Expo Kit (SEK) is a production-ready React Native boilerplate built on Expo that eliminates weeks of configuration. It comes pre-wired with authentication, payments, push notifications, databases, and strict TypeScript — giving you a working foundation in 15 minutes instead of 3+ days.

Think of it as a React Native starting point that handles all the infrastructure wiring so you can focus on your product. It's a scaffold, not a UI library or opinionated framework. You own the code, customize everything, and launch faster.

Also known as: Expo kit, React Native kit, Expo React Native scaffold, React Native boilerplate, Expo starter kit, production-ready React Native starting point.

You can. Most developers can. But the real question is: at what cost?

Setting up from scratch means:

• 3–5 days of configuration (Firebase auth, FCM, SHA-1 fingerprints, EAS credentials, RLS rules, revision cycles)
• Token debt — hundreds of API calls debugging Firebase config mismatches, Google Sign-In errors, and push notification failures
• Fragile setup — one SHA-1 mismatch breaks notifications; one wrong web-client-id breaks Google Sign-In; one RLS rule typo breaks your database
• Decision paralysis — Firebase vs. Supabase? NativeWind vs. Paper? RevenueCat vs. Stripe? This React Native kit compresses all of that into 15 minutes. Everything is pre-wired, pre-tested, and documented step-by-step. You're not paying for code you could write; you're paying for the confidence and time of a working Expo foundation so you can focus on your actual product instead of infrastructure debugging.

For context: Even at $20/hour, 8 hours of your own time debugging Firebase is $160. The Hobbyist plan ($29) pays for itself in hours, not days.

Context matters.

Hobbyist ($29): Personal projects or learning React Native. Compare this to 8 hours of your own time debugging Firebase auth. Even at $20/hour, that's $160. This starter kit saves you that time and gives you a working app scaffold.

Founders ($79): You're launching a real product. Your time is your scarcest resource. Saving 3 days to launch your React Native app faster is the difference between validating market fit today and "maybe next month." The ROI is speed to market, not code cost.

Agency ($199): White-label this into 5 client projects and you've made 10x ROI. Clients pay $5–10k for what you just delivered in hours instead of weeks. This Expo kit becomes your standard boilerplate.

The price floor isn't "can I build this myself?" It's "what's the cost of not launching?"

Hobbyist ($29/one-time)

• Personal projects and learning only
• Build one (1) production application
• Full access to all features
• Cannot be used for client work or commercial services
• Non-transferable

Founders ($79/one-time)

• Best for solo founders building multiple products
• Build unlimited B2C applications
• Full access to all features
• Cannot resell or white-label the source code
• Commercial use allowed for your own business
• Non-transferable (single person)

Agency ($199/one-time)

• Best for agencies, studios, and dev shops
• Build unlimited B2B and B2C applications
• Full access to all features
• Full white-label rights — can resell or distribute
• Can use for unlimited client projects
• Transferable (team use)

Pick based on: Are you building for yourself or others? Personal vs. commercial? Single person vs. team?

Expo + React Native lets you write once, deploy to iOS and Android simultaneously. Combined with this starter kit, you get:

• Single codebase — Ship to both App Store and Play Store from the same code
• Faster iteration — Expo Go for instant preview; Expo Prebuild for native access when you need it
• AI-friendly development — See the next question for why this matters
• Proven stack — Firebase, Supabase, RevenueCat — battle-tested in production apps
• Cost-effective — One developer, two platforms, one codebase The downside? You need to think in React Native patterns, not native iOS/Android. This kit removes the setup pain so you can focus on those patterns.

Simple Expo Kit is built for AI-assisted development:

• Strictly typed TypeScript — Every component, hook, and API has explicit types. AI coding assistants like Cursor and Claude know exactly what data shapes and return types to expect
• Agents.md architecture guide — Plain-text rules formatted specifically for LLMs. Tell Claude: "Using Agents.md, design a new dashboard screen matching this Figma design" and it knows exactly how to structure code without breaking patterns
• Pre-configured patterns — Auth, payments, notifications, database queries—all follow consistent patterns. AI learns the style and extends it correctly
• No magic — Clean, readable code. No hidden decorators, middleware chains, or framework magic that confuses language models You can say things like:
• "Build a new feature form following Agents.md"
• "Refactor this component using our type patterns"
• "Generate the Firestore query for subscriptions" And Claude/Cursor will nail it because the codebase is AI-readable. This is why strict typing + documentation = faster shipping with AI.

SEK comes production-ready with:

Authentication (Pick one or both)

• Firebase Auth (Google, Email, and extensible to X, Instagram, GitHub, Apple)
• Supabase Auth (same providers, SQL-backed) Payments & Subscriptions
• RevenueCat pre-configured with paywall UI
• Works with App Store, Google Play, and Stripe (for web)
• Subscription tiers: monthly, yearly, lifetime Database & Backend
• Firestore (NoSQL) — Fast queries, real-time listeners
• Supabase Postgres (SQL) — RLS rules, scheduled functions, migrations
• Cloud Functions (Firebase) or Edge Functions (Supabase) for backend logic Push Notifications
• FCM (Firebase Cloud Messaging) fully configured
• Expo Push Notifications API as fallback
• Notification queue and scheduling baked in UI & Styling
• NativeWind (Tailwind CSS for React Native) with light/dark theme
• No heavy UI library — you own your design
• Material Design soft rounding, amber accents, Plus Jakarta Sans (customizable) Navigation & Routing
• Expo Router (file-based routing, like Next.js)
• Pre-built screens: onboarding, paywall, dashboard, CRUD examples Developer Experience
• TypeScript (strict mode)
• Example CRUD with Firebase and Supabase
• Preconfigured .env and environment setup
• CLI tools for Supabase migrations
• EAS Build ready for iOS/Android

Error 10 in React Native Google Sign-In is almost always one of two things:

1. SHA-1 fingerprint mismatch — Your development/release/production builds have different SHA-1 hashes. Firebase only recognizes the fingerprints you've uploaded.

2. Wrong web-client-id — You copied the full Google Client ID (111111111-xxxxxx.apps.googleusercontent.com) instead of just the prefix (111111111-xxxxxx).

Debug steps:

Find your SHA-1 using keytool (run this in your project root):

keytool -list -v -keystore android/app/debug.keystore \
  -alias androiddebugkey -storepass android -keypass android

Copy the SHA-1 fingerprint from the output.

Go to Firebase Console → Settings → General → Your Apps → Add Fingerprint and paste it.

Redownload google-services.json after adding the fingerprint.

In your .env, verify:

EXPO_PUBLIC_GOOGLE_WEB_CLIENT_ID=111111111-xxxxxx

(Just the prefix, not the full .apps.googleusercontent.com part)

In app.json, verify iosUrlScheme matches this pattern:

"iosUrlScheme": "com.googleusercontent.apps.111111111-xxxxxx"

If you bought this Expo React Native kit, the code is already configured correctly — just follow the setup guide exactly and Error 10 won't happen. This is one of those "follow the recipe" moments where one typo breaks everything.

Push notifications fail for one reason: SHA-1 fingerprint mismatch between your build and what Firebase knows about.

Here's the chain:

1. Firebase needs to know your app's SHA-1 to validate it
2. You run npx expo run:android and get a development SHA-1
3. You run eas build and get a different (EAS) SHA-1
4. If Firebase only has the development SHA-1, EAS builds won't receive notifications Fix:

Get your current build's SHA-1 (see previous question).

Add it to Firebase Console: Settings → Your Apps → Add Fingerprint

Redownload google-services.json after adding it.

Redeploy your app with the updated config.

Note on EAS builds: If you're using EAS for production builds, grab the SHA-1 from your EAS dashboard instead of running keytool locally.

The kit includes everything pre-wired for FCM. The common mistake is skipping the SHA-1 step or forgetting to redownload google-services.json after adding a new fingerprint.

When you run eas credentials and it fails or hangs, it's usually one of these:

Not logged in — Run eas login first and authenticate with your Expo account.

Project not initialized — Run eas build:configure to initialize the project in your Expo account.

Google Service Key in wrong location — Save it as admin/google-service-key.json (in the admin folder, not root).

Using an outdated key — If your Firebase service account key is older than 30 days, generate a fresh one from Firebase Console → Settings → Service Accounts → Generate New Private Key.

Step-by-step: The kit includes detailed setup docs that walk you through this in order. If you follow them exactly, you won't hit these snags.

You can use both, but you typically pick one for each layer:

Database: Firebase is NoSQL; Supabase is SQL with Postgres. Pick what fits your data model.

Auth: Firebase Auth or Supabase Auth—both support the same providers. Pick whichever database you chose (or mix them).

Notifications: The Expo kit uses Supabase to queue push notification data (with Postgres crons for scheduling). You can replace it with Firebase Cloud Functions, but Supabase makes scheduled notifications trivial.

Row-Level Security: Supabase makes RLS dead simple with SQL policies. Firebase requires Cloud Functions for equivalent security.

Bottom line: The React Native scaffold supports both. Use Supabase if you want SQL + RLS simplicity. Use Firebase if you're all-in on NoSQL. The code doesn't force you into either.

Absolutely. NativeWind is just styling (Tailwind CSS for React Native). Your component logic is entirely separate.

You can:

• Keep NativeWind and override design tokens (colors, spacing, fonts live in one place)
• Swap it out for React Native Paper, NativeBase, or hand-coded Stylesheet
• Use Tamagui or Dripsy if you prefer
• Build fully custom UI — the kit doesn't lock you into any component library The only things that are locked in are auth, payments, and routing — those are the hard parts. UI is your playground.

Yes. The kit abstracts database calls into separate services. Migrating providers means:

1. Update your .env keys with Supabase credentials
2. Rewrite the firebaseDB.ts / supabaseDB.ts utility files
3. Migrate your data (one-time cost, not recurring)

It's not effortless, but the React Native starter kit structure makes it predictable. The hard part is data migration, not code refactoring.

RevenueCat is pre-configured, which supports:

• iOS: App Store in-app purchases and subscriptions
• Android: Google Play Billing System
• Web: Stripe (via RevenueCat's Stripe integration)

If you want pure Stripe without RevenueCat, you can replace the paywall logic. But RevenueCat is included because it handles subscription state, entitlements, and trial logic—stuff Stripe alone doesn't do.

The Expo kit comes with:

• Step-by-step setup documentation (Getting Started guide + detailed Firebase, Supabase, and EAS guides)
• Troubleshooting for common errors (SHA-1 mismatches, Google Sign-In failures, EAS credentials, FCM issues)
• Real blog posts showing exact error messages and fixes
• Email support — contact us if you're blocked

If you follow the guides exactly, you won't get stuck. The documentation is written by someone who's built this stack in production.

Updates are not included. When Expo SDK 56+ launches or significant revisions happen, buying a new license is recommended (but optional if you're not hitting new features or security patches).

Why? The React Native kit price is one-time, not a subscription. You own the version you buy. New versions are improvements, not requirements. We don't force upgrades — you decide if new features are worth it.

Yes. If the SEK doesn't work for you or doesn't deliver on what's promised, we offer a 30-day money-back guarantee. No questions asked.

It depends on your license:

• Hobbyist ($29): Personal use only. Cannot be used for client work.
• Founders ($79): Client projects allowed. You can build apps for clients and keep the code. Cannot resell the kit itself.
• Agency ($199): Unlimited client projects. Full white-label rights—you can resell or distribute the Expo kit as part of your service.

No subscription. You buy once, own that version forever. When new versions drop (e.g., updated to Expo SDK 56, new features, security patches), they're available as separate purchases if you want to upgrade.

This is different from subscription pricing because:

• You're never forced to upgrade
• You can stay on stable versions indefinitely
• New versions are opt-in, not required Think of it like buying a book—you own it. New editions are sold separately.

No, it is developed for serious development, which is not possible with Expo Go, because of it's limitations. It fully supports Expo Prebuild for when you need to:

• Drop into native Android/iOS modules
• Customize native code
• Compile for App Store and Google Play You can start with development builds or use EAS Build for production builds.

Yes. The entire React Native codebase is:

• Strictly typed (TypeScript) so Claude, Cursor, and Antigravity know the shape of your data
• Documented with Agents.md — architecture guidelines formatted specifically for LLMs
• Pre-configured with clean patterns so AI doesn't break established structure

You can say:

• "Using Agents.md as context, design a new dashboard screen matching this Figma design"
• "Build a form for collecting user preferences, following our type patterns"
• "Generate the Firestore query for active subscriptions"

And Claude/Cursor will nail it because the React Native starter kit supports vibe-coding.

Without the Expo scaffold:

• 3–5 days of configuration (Firebase, FCM, SHA-1, EAS, RLS rules, testing)
• Debugging time — Firebase config errors, Google Sign-In failures, notification routing
• Decision-making — Firebase vs. Supabase? RevenueCat vs. Stripe? NativeWind vs. Paper? With the starter kit:
• 15 minutes to extract, follow setup docs, configure keys, and run npx expo start
• Zero debugging for core infrastructure — everything works out of the box
• Decisions made — you get a proven stack, you can customize from there Time saved: 3–5 days per project. That's 40+ hours, or $800–$2000 at typical rates. The kit pays for itself on the first use.

Yes. All plans include full access to the source code. You can modify everything.

Resale restrictions:

You cannot resell, redistribute, or white-label. Use it as your standard Expo scaffold for yourprojects. If you want to please request a redistribution license via support channel.

Most React Native boilerplates give you code. This kit gives you:

• Production-ready wiring — Auth, payments, notifications, database, all connected
• Detailed setup documentation — Step-by-step guides for Firebase, Supabase, EAS
• Troubleshooting for real errors — Error 10, FCM failures, SHA-1 mismatches (not just theory)
• AI-ready structure — Strictly typed, documented patterns, Agents.md for LLMs
• Proven stack — Firebase, Supabase, RevenueCat, NativeWind (not experimental)
• Support — Email support and regular documentation updates Other boilerplates might have 80% of this. This kit is 100% + docs + support.

Completely. The kit uses NativeWind for styling (Tailwind CSS for React Native). You can:

• Change colors, fonts, spacing, and radius globally
• Replace the entire design system
• Add your branding immediately
• Ship custom UI from day one Nothing is locked in aesthetically. Only the architecture (auth, payments, routing) is structured.

Email us. We're here to help — seriously. The goal is for you to launch faster, not to get stuck on infrastructure.

You can also:

• Check the setup guides (Getting Started, Firebase, Supabase)
• Review the blog posts on common errors
• Look at the Agents.md architecture guide in the kit If that doesn't answer it, reach out directly.

1. Buy the license that fits your use case (Hobbyist, Founders, or Agency)
2. Download the React Native kit (ZIP file with source code)
3. Follow Step 1 (Getting Started guide) — extract, install dependencies, set up .env
4. Follow Step 2 (Firebase setup) — configure Firebase project, download keys, add SHA-1 fingerprints
5. Follow Step 3 (Supabase setup) — push database schema and RLS rules
6. Run npx expo run:ios or npx expo run:android and watch your app come to life

The whole process takes 15 minutes if you follow the docs. Seriously.

30-day money-back guarantee. If it doesn't deliver, we refund it. No gotchas.