JavaScript mobile app development: React Native, Capacitor and web apps compared
JavaScript mobile app development means building iPhone and Android apps in JavaScript or, more often today, TypeScript, instead of Swift and Kotlin. There are three main routes: React Native, which drives the phone's own interface components from JavaScript; Capacitor, which packages a web app as a store app with native plugins; and installable web apps that never go through a store. This guide compares them, explains the App Store rules that apply to JavaScript apps and shows how to choose.
Why build mobile apps with JavaScript
The case is practical. JavaScript is the language of the web, so a company with a web team, a web app or a Node.js backend can reuse people, code and tooling. One codebase serves iPhone and Android, and sometimes the browser as well. Business logic, validation rules and API types can be shared between the app and the server. The case against is equally practical: the newest platform features arrive in Swift and Kotlin first, some features can only be written natively, and an extra layer between your code and the phone is one more thing to keep up to date.
The three routes compared
| React Native (often with Expo) | Capacitor | Installable web app (PWA) | |
|---|---|---|---|
| How the interface is drawn | Native platform components, controlled from JavaScript | Your web app inside a native web view | The browser engine, installed to the home screen |
| Feel | Close to native | Like a good web app; depends on the web code | Like a website with an icon |
| Reuse of an existing web app | Logic and types, not the screens | Most of it | All of it |
| Device features | Broad, through native modules | Broad, through plugins | Limited to what the browser allows |
| App Store and Google Play | Yes | Yes | No store needed; can be wrapped later |
| Good fit | Consumer and business apps that should feel native | Companies with a strong web app that need store presence and device access | Internal tools, simple customer apps, a first version |
NativeScript is a fourth, smaller option that also drives native components from JavaScript. For the wider picture, including Flutter, Kotlin Multiplatform and .NET, see our guide to mobile app development frameworks.
React Native and Expo
Mobile app development with React means React Native for most teams: it lets you write components in React, the same model web teams use, and renders them as real iOS and Android views. React itself, the library, runs in the browser; React mobile app development reuses its components, state and hooks, but swaps HTML elements for native views such as View and Text, so web screens are not copied over unchanged. What does carry over is the business logic, the data layer, TypeScript types and the team's knowledge of React. Expo is a framework and set of services on top of it that handles project setup, native configuration, builds and store submission, and it is the usual starting point for new React Native apps.
The framework went through a long rebuild. React Native's New Architecture became the default in version 0.76 in October 2024, replacing the old asynchronous bridge with direct, type-safe access to native code and support for modern React features. With version 0.82 React Native runs entirely on the New Architecture; the project named 0.81 and Expo SDK 54 as the last versions that allow the legacy one. An app still on the old architecture therefore has a migration ahead before it can take further updates.
Release pace matters for maintenance. The React Native releases page (read 11 November 2026) lists the project's support status:
| Version | Release date | Support on 11 November 2026 |
|---|---|---|
| 0.89 | 7 December 2026 (planned) | Future |
| 0.88 | 15 October 2026 | Active |
| 0.87 | 11 August 2026 | Active |
| 0.86 | 9 June 2026 | End of cycle |
| 0.85 and older | 6 April 2026 and earlier | Unsupported |
The project commits to maintaining the latest three minor series, which with a new minor version roughly every two months means an app that is not updated for half a year falls out of support. A maintenance plan for a React Native app should include an upgrade every few months, not only bug fixes.
Capacitor and web-based apps
Capacitor, from the team behind the Ionic framework, takes a web app built with any framework and runs it in a native shell for iOS and Android, with plugins for the camera, files, push notifications and other device features, and the option to write your own native code where a plugin is missing. Its strength is reuse: a company with a capable web app can reach the stores without rebuilding the screens. Its weakness is that the result is only as fast and as native-feeling as the web code inside it, so lists, gestures and transitions need care on older phones.
Installable web apps
A progressive web app is a website with a manifest and a service worker that people can add to their home screen and use offline. On iPhone the gap with store apps has narrowed: WebKit announced on 16 February 2023 (read 11 November 2026) that iOS and iPadOS 16.4 would bring Web Push to Home Screen web apps. Limits remain: users must add the app to the home screen themselves, there is no store listing to be found through, and device access stops at what the browser offers. For internal tools and first versions, that is often enough; our mobile app development page starts every project with exactly this question.
The App Store rules that matter for JavaScript apps
Apple reviews the app, not the language, but two guidelines in the App Review Guidelines (read 11 November 2026) hit JavaScript apps more often than native ones:
- 4.2 Minimum Functionality. An app should include features, content and interface that elevate it beyond a repackaged website. A Capacitor shell around an existing site, with nothing a browser could not do, is the classic rejection.
- 2.5.2 Self-contained apps. Apps may not download, install or execute code that introduces or changes features or functionality. Over-the-air updates, which JavaScript frameworks make easy, are fine for fixes within the reviewed app; new features go through review.
Guideline 4.7 separately allows HTML5 and JavaScript mini apps and mini games inside an app, with the host app responsible for their content and privacy. Store rules on payments, privacy details and account deletion apply as for any app; we publish our own apps on the App Store and follow the same rules there.
When JavaScript is the wrong choice
- Platform extensions. Home screen widgets, Live Activities and Apple Watch apps are built with Apple's own frameworks; a JavaScript app can include them, but they are written natively.
- Heavy graphics and media. Games, advanced camera work and real-time audio or video processing belong in native code or a game engine.
- Day-one platform features. New iOS and Android features appear in Swift and Kotlin first, and JavaScript support follows later.
- A team that already writes Swift and Kotlin. Then the shared-language argument disappears; see native mobile app development.
How to choose
- Start from the users. Staff with a link, or the public finding you in a store? Weekly or daily use?
- List the device features. Camera, location in the background, Bluetooth, widgets, payments. Check each against the route.
- Look at what you already have. A strong web app points to Capacitor; a React web team points to React Native; nothing yet leaves the choice open.
- Plan the upkeep. Framework upgrades, store policy changes and new OS versions every year. Budget for them from the start.
- Keep the backend separate. A clean API means the app can be rebuilt in another technology later without touching the server; see Node.js app development.
How we work
We build mobile apps in TypeScript with React Native and Expo when one codebase fits, in Swift and Kotlin when native fits, and as web apps when no store is needed, and we write the reasons for the choice into the scope. Widgets, Watch apps and other extensions are written natively alongside a cross-platform app. The code is in your company's repository and the store accounts are in your company's name. See cross-platform app development for the service, the Java guide for the Android-native alternative and app development cost for what drives the price.
Questions people ask
Can you build a mobile app with JavaScript?
Yes. React Native turns JavaScript or TypeScript components into native iPhone and Android interface elements, Capacitor packages a web app into a native app with access to device features through plugins, and an installable web app runs from the browser without a store. All three are used for real products; they differ in how native the result feels and which device features they reach.
Is React Native still a good choice?
For many apps, yes. It is maintained by Meta with an active release schedule: the React Native releases page lists 0.88 as the latest version, released on 15 October 2026, with 0.89 planned for 7 December 2026, and the project supports the latest three minor series. Since version 0.82 it runs only on its New Architecture, which removed the old bridge between JavaScript and native code.
What is the difference between React Native and Capacitor?
React Native draws the interface with the platform's own native components, controlled from JavaScript. Capacitor shows your web app, written with any web framework, inside a native web view, and adds native features through plugins. React Native usually feels closer to a native app; Capacitor lets one web codebase serve the browser and the stores with fewer changes.
Will Apple accept an app built with JavaScript?
Yes, if the app itself meets the App Review Guidelines. Two rules matter most for JavaScript apps. Guideline 4.2 expects features and interface that go beyond a repackaged website. Guideline 2.5.2 forbids downloading code that introduces or changes features or functionality, so updates delivered outside the store must stay within what was reviewed.
Should we use JavaScript or TypeScript for a mobile app?
TypeScript. It is JavaScript with types, it runs everywhere JavaScript does, and it catches a whole class of mistakes before the app runs. React Native and Expo both support it fully, and the types can be shared with a Node.js backend.
Sources
- React Native, Releases overview (read 11 November 2026)
- React Native blog, The New Architecture is here, 23 October 2024 (read 11 November 2026)
- React Native blog, React Native 0.82, 8 October 2025 (read 11 November 2026)
- Apple, App Review Guidelines, 2.5.2, 4.2 and 4.7 (read 11 November 2026)
- WebKit, Web Push for Web Apps on iOS and iPadOS, 16 February 2023 (read 11 November 2026)
- Capacitor documentation (read 11 November 2026)