Product
Building an app in 2026: our stack and what's still hard
Read this post in: Español
You can get an app’s screens on a phone in an afternoon now. AI coding tools write the components, the navigation and the API calls faster than you can review them. We build Quini that way, with coding agents in the loop every day. And the part that takes the time is still the same: getting code to real phones safely, sending notifications people trust, keeping accounts secure and getting through store review.
Here’s the stack we actually run, and where the hours really go.
The stack
Quini is a prediction-pool app. Friends make picks on matches, and the leaderboard updates from official results while the games are on. It runs on iOS, Android and the web.
| Layer | What we use |
|---|---|
| Mobile app | Expo SDK 54 on React Native 0.81, with Expo Router |
| Builds and updates | EAS Build and EAS Update |
| Backend | Strapi 4 on PostgreSQL |
| Marketing site | Astro |
| Web app | Next.js |
| In-app purchases | RevenueCat, plus Stripe for web checkout |
| Errors and analytics | Sentry, Amplitude and Firebase Analytics |
One codebase ships to both stores. That alone used to be the hard part. It isn’t anymore.
Over-the-air updates: easy to send, easy to break
With Expo, a JavaScript-only change doesn’t need a store review. Our flow: push to main, CI runs the tests, the build goes to a preview channel that TestFlight and Play Internal pick up, we check it on a real phone, and then one command tags it for production. Real users get the new bundle within about a minute.
The trap is native code. An update can only land on a binary that has every native piece it needs. So we pin the runtime version by hand instead of deriving it from the app version. Any native change, like a new library, a new permission or a plugin edit, means a new store build and a new runtime. If it didn’t, a fresh update could land on an old binary that can’t run it.
One more rule we learned the hard way: our release script waits for the exact CI run behind the tag and fails if that job didn’t succeed. A pushed tag isn’t a release.
Push notifications: the setup is the easy part
Wiring up push takes an hour. Making it reliable takes longer. Our backend sends through Expo’s push service in batches of 100, which is Expo’s per-request limit, and retries each batch on its own so one bad request doesn’t sink the rest. The web gets its own web-push path.
The harder question isn’t technical. A pool app lives on timely alerts: picks closing, a match starting, the leaderboard moving. Send too many and people turn them off for good. Every notification has to be one somebody would be annoyed to miss.
Auth: the part not to hand-roll
Our accounts run through the backend’s user system, with short-lived access tokens and refresh tokens. The detail that matters most came from thinking about lost phones. When someone signs out, we kill the session on the server too, so a refresh token can’t outlive the sign-out on a phone that got lost or handed down.
That’s the general lesson. Use a proven auth system and spend your own time on the edges: sessions, password resets, and what happens when a device changes hands.
Store review: plan for it like a deadline
Apple’s review is still the step you can’t speed up with better code. One of our builds was rejected because content the reviewer could see, the name of a featured pool, carried a trademarked tournament name. The trigger wasn’t our interface copy. It was content inside the app.
So we built a switch on the server. Before every iOS submission we flip it, and within about 30 seconds every client shows trademark-safe names, with no deploy. After approval we flip it back. It’s a small feature that only exists because review is part of the product.
Two smaller habits help too. The store version number goes up by one on every submission, and build numbers increment on the build service, so nobody edits them by hand.
What we’d tell anyone starting now
- Let AI write the screens. It’s good at it. Review everything it touches in release, auth and payments.
- Decide your update rules on day one. Know which changes can go over the air and which need a store build.
- Treat notifications as a promise. Fewer, timelier, never noise.
- Use proven auth and payments. Your users won’t thank you for a custom login.
- Put store review on the calendar. Read the guidelines for whatever your users can create, not just what you wrote.
If you want to see where all this ends up, here’s how Quini works, and what a quiniela is if the word is new to you.
FAQ
What stack does Quini use?
Expo SDK 54 and React Native 0.81 for the iOS and Android app, Strapi 4 on PostgreSQL for the backend, Astro for the marketing site and Next.js for the web app. Purchases run on RevenueCat and Stripe.
Can you update a React Native app without the App Store?
Yes, for JavaScript-only changes, using over-the-air updates like EAS Update. Anything native, like a new library or permission, still needs a new store build.
Is building an app with AI tools enough in 2026?
It’s enough for the screens. Releases, notifications, auth and store review still need deliberate decisions from people who’ll own the results.
Quini is free to try, and your group’s pool runs itself: picks lock on time and the leaderboard updates live. Download Quini and set up your first pool.