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

The ideal tech stack for solo developers building a mobile app in 2026.

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

Layer	Tool	Why
Framework	React Native + Expo	Cross-platform, one codebase, OTA updates
Navigation	Expo Router	File-based routing, feels like Next.js
UI	Tamagui or NativeWind	Consistent styling across platforms
Backend	Supabase	Auth, database, storage, real-time. All in one
State	Zustand	Simple, no boilerplate, works with React Native
Builds	EAS Build	Cloud builds without local Xcode/Gradle headaches
Analytics	PostHog	Privacy-friendly, generous free tier

The Stack By the Numbers (checked May 2026)

Here is where each piece actually stands today, pulled from the npm registry and the GitHub repos so you are not trusting a number I half remember.

Tool	Latest version	GitHub stars	npm downloads (last week)
React Native	0.85.3	126k	8.9M
Expo (SDK 56)	56.0.8	49.8k	5.5M
Expo Router	56.2.8	(part of expo)	3.3M
Tamagui	2.0.0	14k	208k
NativeWind	4.2.4	7.9k	1.2M
Zustand	5.0.14	58.1k	36M
Supabase JS	2.106.2	103k (monorepo)	19.8M

Two things jump out of that table. Zustand pulls 36 million downloads a week, which tells you the "skip Redux" advice is not a hot take anymore, it is the consensus. And React Native is still pre 1.0 by version number after more than a decade, which is a quirk of its release scheme, not a sign of instability. Version 0.85 is rock solid in production.

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 15 Android and 15 iOS builds a month on a low priority queue plus OTA updates for up to 1,000 monthly active users, which is genuinely enough to develop and ship a small app. When you outgrow it, the Starter plan is $19 a month with $45 of build credit and the Production plan is $199 a month with $225 of build credit and a 50,000 MAU ceiling (Expo pricing, checked May 2026). The old days of a flat cheap tier are gone, so budget for the free tier carrying you a long way and a real jump once you need priority builds.

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. The numbers back the momentum. React Native sits at 126k GitHub stars and roughly 8.9 million npm downloads a week, while the Expo package itself pulls about 5.5 million weekly downloads at 49.8k stars (GitHub and npm, checked May 2026). The current React Native release is 0.85.3 and the current Expo SDK is 56 (package version 56.0.8 on npm).

Expo Router is the navigation solution I'd use. It ships as its own npm package (currently 56.2.8, around 3.3 million weekly downloads per npm, checked May 2026) and 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 hit a 2.0 release (version 2.0.0 on npm) and sits at 14k GitHub stars with roughly 208k weekly downloads (GitHub and npm, checked May 2026). 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. It is on the 4.x line (currently 4.2.4) with about 1.2 million weekly downloads and 7.9k stars, so it pulls far more raw install volume than Tamagui even though Tamagui has the bigger star count (npm and GitHub, checked May 2026). 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. The project is enormous in open-source terms, 103k GitHub stars on the main monorepo, and the JavaScript client you actually install (@supabase/supabase-js, currently 2.106.2) pulls nearly 19.8 million npm downloads a week (GitHub and npm, checked May 2026). The free tier gives you a 500 MB Postgres database, 50,000 monthly active users on auth, and 1 GB of file storage, with the catch that a free project pauses after a week of inactivity and you can run at most two of them. When you outgrow that, the Pro plan is $25 a month and bumps you to 8 GB of included database disk, 100,000 included MAUs, and 100 GB of file storage with metered overages beyond (Supabase pricing, checked May 2026). For a solo app that is a long runway before you pay anything. 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. And this is not a niche choice anymore. Zustand is on version 5 (currently 5.0.14), sits at 58.1k GitHub stars, and pulls roughly 36 million npm downloads a week, which is more than React Native and Supabase combined (GitHub and npm, checked May 2026).

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, and it is genuinely generous. The free plan needs no credit card and resets monthly with 1 million product analytics events, 5,000 session replay recordings, 1 million feature flag requests, and 100,000 error tracking exceptions, plus one project with one year of data retention (PostHog pricing, checked May 2026). PostHog itself runs at 34.8k GitHub stars. 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.

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.
Set up Supabase. Create a project, define your core tables, and enable Row Level Security. Install @supabase/supabase-js and create a client instance.
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.
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.
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.

Sources

Every version number, star count, download figure, and price above was pulled live and checked on 2026-05-30. Pricing on hosted services moves, so confirm the current numbers before you budget.