If you already have a working web app, the instinct to "just build a mobile app too" is understandable — customers ask for it, competitors have it, and it feels like the obvious next step. But "build a mobile app" isn't one project, it's several different possible projects with very different costs, timelines, and outcomes. The right path depends on what your users actually need from a mobile experience, not just whether an app icon exists on their home screen.
This is a practical walkthrough of the real options available to a business that already has a functioning web app and backend, what actually carries over from that existing work, and how to decide which path fits your budget, timeline, and how "native" the experience genuinely needs to feel.
Start With a Progressive Web App
Before committing to a separate native codebase, it's worth seriously considering a Progressive Web App. A PWA is your existing web app enhanced with a service worker for offline caching, a web app manifest so it can be "installed" to a home screen with its own icon, and (on supported platforms) push notification support — all running through the browser engine rather than as a distinct app store submission.
The appeal is cost and speed: you're extending the app you already have rather than starting a second codebase. There's no app store review process, no separate release cadence to manage, and updates go live the moment you deploy, exactly like a normal web deployment. For a lot of businesses — especially B2B tools, internal dashboards, or consumer apps where the core value is content or transactions rather than device integration — a well-built PWA covers the actual need at a fraction of the cost of a native build.
The honest limitations: iOS support for PWA features (particularly push notifications and background sync) has historically lagged behind Android and has only become reasonably usable in more recent iOS versions, so test on real devices before promising push notifications to iOS users. A PWA also can't access certain native device APIs — deep Bluetooth integration, advanced camera controls, background location tracking — and it won't appear in app store search results, which matters if app store discovery is part of your growth strategy. If none of those limitations apply to your use case, a PWA is very often the right first step, and sometimes the only step you need.
React Native and Reusing What You've Already Built
If a PWA doesn't cover the need — usually because of app store presence, deeper native features, or a UI that needs to feel truly native rather than "installed browser tab" — React Native is the next logical option, particularly if your web frontend is already built in React or your team is comfortable with the ecosystem. It compiles to genuinely native iOS and Android UI components rather than rendering inside a web view, so performance and feel are much closer to a fully native app than a PWA can offer.
What Actually Carries Over
This is the part businesses tend to underestimate in a good way: if your web app is built on a proper REST or JSON:API backend — the kind of architecture we cover in designing a REST API that scales — the backend itself needs little to no rework for mobile. Your authentication endpoints, your business logic, your data validation, your database models: none of that cares whether the client requesting it is a browser or a mobile app. A well-designed API is client-agnostic by nature. If you built your web app as a Laravel API with a separate Vue or React frontend (the hybrid architecture we discuss in Laravel vs Next.js), you're in an even better position, because that API was already built to be consumed by more than one frontend.
What also often carries over: shared TypeScript types or validation schemas between frontend and backend, business logic that lives in composables or hooks rather than tightly coupled to DOM rendering, and any state management patterns your team already understands.
What Has to Be Rebuilt
The entire UI layer has to be rebuilt. React Native shares React's component model and a lot of its mental model, but it does not share HTML and CSS — there's no DOM, no CSS files, styling is done with a JavaScript-based subset of CSS via StyleSheet objects, and layout uses Flexbox exclusively. Web components don't port over directly; they get rebuilt against React Native's own component primitives (View, Text, ScrollView, and so on).
Navigation is also a rebuild. Web routing (URLs, browser history, deep links via a router library) doesn't map directly onto mobile navigation patterns — stack navigators, tab bars, modal presentation, gesture-based back navigation. Libraries like React Navigation handle this, but it's genuinely different work, not a port.
Finally, anything that touches native device capability — camera access, push notification registration, biometric login, background location, secure local storage for tokens — has to be implemented against React Native's native modules or a community package, and tested on real devices, because simulators don't always reflect real-world permission prompts and hardware behavior.
When Fully Native Makes Sense
React Native covers the large majority of business apps well, but there are cases where writing separately in Swift/SwiftUI for iOS and Kotlin for Android is the right call: apps with extremely demanding performance requirements (heavy real-time graphics, complex animations, AR/VR), apps that need to push the absolute latest platform-specific APIs the moment they ship, or apps where a slight difference in feel from platform conventions is unacceptable to the target audience. This is a smaller slice of real-world business apps than founders often assume, and it comes with a meaningfully higher cost — effectively two separate codebases to build and maintain instead of one shared React Native codebase. Unless there's a concrete reason pulling you toward fully native, cross-platform is usually the more defensible choice for a business app.
Push Notifications
Push notifications are one of the clearest wins of going beyond a plain web app, and they're worth planning for deliberately rather than bolting on late. On the backend, this typically means integrating with Apple Push Notification service and Firebase Cloud Messaging (which also covers Android), storing device tokens against user accounts, and building a notification service that can target a user, a segment, or a broadcast. On the product side, get specific about what actually warrants a push notification versus an in-app notification — over-notifying users is one of the fastest ways to get an app uninstalled or notifications disabled entirely, which defeats the purpose of having built the capability.
Designing for Offline and Spotty Connectivity
Mobile users are on trains, in elevators, in basements — connectivity that a web app on a home or office Wi-Fi connection never has to think about. A mobile app that simply shows a spinner or an error screen the moment a request fails feels broken in a way users won't tolerate for long. Realistic handling means: caching recently fetched data locally so the app has something to show immediately on open, queueing write operations (form submissions, status updates) when offline and syncing them once connectivity returns, and designing the UI to clearly show what's synced versus pending rather than pretending everything succeeded. This is also where idempotent API design matters a lot — a retried request after a dropped connection should never create a duplicate record on the backend, which ties directly back into how the API itself is designed.
App Store Submission: A Realistic Timeline
Budget real time for this — it's a common place where launch dates slip. Apple's App Store review typically takes anywhere from one to a few days per submission, but first-time submissions and apps handling anything sensitive (payments, health data, user-generated content) get closer scrutiny and can bounce back for clarification, which restarts the clock. Google Play's review is generally faster but not instant, and Google has been tightening review scrutiny on new developer accounts and certain app categories.
Both platforms have guidelines that are worth reading before development starts, not after submission — things like requirements around account deletion, privacy policy disclosures, in-app purchase rules if you sell anything digital through the app, and design conventions each platform expects. Rejections are usually fixable, but each round trip costs days. Plan the submission step as its own phase with buffer time, not as an afterthought tacked onto the end of a development sprint.
Ongoing Maintenance Cost
A mobile app is not a one-time build the way a website update sometimes feels like it is. iOS and Android both ship OS updates roughly annually with new SDK requirements that apps eventually must target to stay listed and functional. Third-party libraries need version bumps. Apple and Google both periodically change store policies that require app updates to remain compliant. Unlike a web app, you can't force every user onto the latest version instantly — which is exactly why backward compatibility in your API matters so much once a mobile app exists; older app versions will keep hitting your API in the wild for months or years after a new version ships, sometimes indefinitely, and the API has to keep serving them without breaking.
A Decision Framework
If budget and timeline are tight and your core need is "customers should be able to use this on their phone," start with a PWA and see how far it actually gets you before assuming you need more. If app store presence, deeper native integration, or a genuinely native feel matters and your team has React experience, React Native is very likely the right target — it reuses your existing backend entirely and shares a substantial amount of engineering knowledge with your web team. Reserve fully native development for cases with a concrete, specific technical reason to need it, because the ongoing cost of two native codebases is real and compounds over years, not just at initial launch.
Whichever path fits, the foundation is the same: a backend API that's stable, well-documented, and versioned in a way that doesn't break older app installs when it evolves. If you want help assessing which path actually fits your product, reach out and we'll talk through the specifics rather than a generic recommendation.
