Best Tech Stack for Building a Mobile App as a Solo Developer

I've shipped two mobile apps as a solo developer. The first one used Flutter because everyone on Reddit said it was the future. The second one used React Native with Expo. Guess which one I still maintain? The React Native one. Not because Flutter is bad, but because I already know JavaScript, and maintaining a Dart codebase alongside my web projects was an unnecessary context switch.

The stack you choose for a mobile app matters more than for a web app because you're stuck with it. Rewriting a mobile app is painful, and your users notice when things change under the hood. Here's what I'd use if I were starting a mobile app today.

The Recommended Stack

Why This Stack Works for Solo Developers

One language. One codebase. Two platforms. That's the entire argument for React Native with Expo, and it's a compelling one when you're the only developer.

Expo in particular has gotten incredibly good. Three years ago, you'd "eject" from Expo the moment you needed a native module. Now, Expo's config plugins handle almost everything without ejecting. Camera, push notifications, in-app purchases, biometrics. They all work within the managed workflow. I haven't ejected a project in over a year.

The build situation is what really sold me. Before EAS Build, I needed a Mac to build iOS apps, had to manage Xcode versions, and spent hours debugging Gradle issues on Android. Now I push code and EAS builds both platforms in the cloud. The free tier gives you enough builds for development, and the paid tier is $15/month, which is nothing compared to the time you save.

Framework: React Native + Expo

Expo is no longer just a nice wrapper around React Native. It's effectively the recommended way to build React Native apps in 2026. The React Native team at Meta works closely with the Expo team, and the new architecture (Fabric renderer, TurboModules) is fully supported in Expo.

Expo Router is the navigation solution I'd use. It brings file-based routing to React Native, which means your navigation structure mirrors your file system. If you've used Next.js, the mental model is identical. app/(tabs)/home.tsx creates a tab called "home." It's that simple. Before Expo Router, setting up React Navigation with nested stacks and tabs was an error-prone process that I got wrong at least once per project.

The Flutter question. Flutter is a great framework with beautiful widgets and excellent performance. But unless you're already a Dart developer, learning a new language for mobile when you could use JavaScript/TypeScript is a tough sell for a solo developer. The React/React Native ecosystem is simply larger, and you can share code between your web and mobile apps.

UI: Tamagui or NativeWind

Styling React Native apps used to be painful. StyleSheet.create is verbose, and achieving consistent designs across iOS and Android required constant tweaking.

Tamagui solves this with a universal design system that works on both web and native. If you ever want to share components between a web app and your mobile app, Tamagui makes that possible. It's opinionated, which I consider a feature for solo developers. Fewer decisions means faster shipping.

NativeWind (Tailwind for React Native) is the alternative if you already think in Tailwind classes. It compiles Tailwind utilities to React Native StyleSheet objects, so performance is native. I've used both, and I slightly prefer Tamagui for its built-in components, but NativeWind is great if you want to stay close to web Tailwind.

Backend: Supabase

For mobile backends, Supabase is the pick. Here's why it beats the alternatives for a solo developer.

Authentication with social login (Google, Apple, GitHub) works out of the box. Apple requires Apple Sign-In if you offer any other third-party login, and Supabase handles that without extra configuration. I wasted an entire day implementing Apple Sign-In manually once. Never again.

Real-time subscriptions are useful for features like chat, live updates, or collaborative features. Supabase wraps PostgreSQL's LISTEN/NOTIFY in a clean API. You subscribe to database changes and your mobile app updates automatically.

The database is just PostgreSQL, which means you can run raw SQL, use views, set up Row Level Security for per-user data isolation, and do everything else Postgres supports. No proprietary query language, no vendor lock-in on your data layer.

Why not Firebase? Firebase is fine, but Firestore's query limitations frustrate me. No joins, limited filtering, and complex queries require denormalized data structures that feel hacky. Supabase gives you a relational database, which is almost always what you actually need.

What I'd Skip

Redux. Zustand does everything Redux does with a fraction of the code. For a solo mobile app, you don't need middleware, sagas, or the Redux DevTools ecosystem. Zustand's create function gives you a store in five lines. Redux gives you the same store in thirty lines plus three files.

Detox for testing. E2E testing on mobile is incredibly slow and flaky. For a solo developer, manual testing on real devices plus unit tests with Jest is a better use of your time. Add E2E testing when you have a team to maintain the test suite.

Custom native modules. Stay in the Expo managed workflow as long as physically possible. The moment you eject, you take on the maintenance burden of Xcode and Gradle build configurations. That's hours per month you won't get back.

Analytics overkill. PostHog's free tier is enough for most solo apps. Don't set up Mixpanel, Amplitude, and Firebase Analytics all at once. One tool, used properly, gives you all the insights you need.

Getting Started

Here's what I'd do in my first weekend.

1. Create the project. Run npx create-expo-app@latest --template tabs to get a tabbed app with Expo Router pre-configured. Install Tamagui or NativeWind for styling.

2. Set up Supabase. Create a project, define your core tables, and enable Row Level Security. Install @supabase/supabase-js and create a client instance.

3. Implement auth. Add Google and Apple sign-in using Supabase Auth. Test on your physical device, not the simulator. Auth flows behave differently on real hardware.

4. Build one screen. Your app's main screen. The one thing it actually does. Get it pulling real data from Supabase and displaying it. Don't touch settings, profile, or onboarding yet.

5. Deploy a test build. Run eas build --profile development to create a build you can install on your phone and share with testers. Getting the build pipeline working early saves you from nasty surprises at launch time.

The best mobile app stack is the one that lets you ship to both platforms without doubling your workload. This combination does exactly that. Ship first, optimize later. Your users care about what the app does, not what framework it's built with.