"Do we need an app?" is a question every growing product eventually asks. The answer used to be simple: if you wanted push notifications, offline mode or a home screen icon, you built native apps for iOS and Android. In 2026 the line is blurrier. Progressive web apps can be installed, work offline and send push notifications on all major platforms, while cross-platform frameworks have made native development cheaper. This guide compares the options honestly and gives a framework for choosing.
What a PWA is
A progressive web app is a website that uses modern web capabilities to behave like an app (MDN: Progressive web apps; web.dev: PWA). Three building blocks make it work:
- A web app manifest — name, icons, colors and display mode, so the browser can install it on the home screen or desktop.
- A service worker — a script that intercepts network requests, enabling offline use, caching and background features.
- HTTPS — required for service workers and most modern APIs.
The same codebase serves the website, the installed app on Android, iOS, Windows and macOS, and is indexed by search engines.
What PWAs can do in 2026
- Install to the home screen and desktop with their own window and icon.
- Work offline or on poor connections with cached content and queued actions.
- Push notifications, including on iPhone and iPad: since iOS and iPadOS 16.4, web apps added to the Home Screen can receive web push notifications and show badges (WebKit, 2023; MDN: Push API).
- Camera, microphone, geolocation, file pickers, sharing, clipboard and payments through standard web APIs.
- Distribution in app stores: on Android, a PWA can be packaged for Google Play as a Trusted Web Activity (Chrome: Trusted Web Activity); tools such as PWABuilder help package for several stores.
In the EU, Apple briefly planned to remove Home Screen web apps under the Digital Markets Act in early 2024, then reversed course and kept them (Apple: DMA and apps in the EU). The episode is a reminder that on iOS, web app capabilities depend on Apple's decisions.
Where native still wins
- Deep hardware and OS integration: Bluetooth Low Energy on iOS, NFC beyond basic reading, background location tracking, health and fitness data, widgets, watch apps.
- Background work on iOS: web apps have limited background execution and no background sync on Safari.
- Heavy graphics and performance-critical UI: games, complex video editing, AR.
- App store presence as a channel: if users search the App Store for apps in your category, being there matters.
- Discoverability of install: on iOS, users must add a web app via the Share menu; there is no install prompt.
Cross-platform native: the middle ground
If you need native capabilities but not two separate codebases, cross-platform frameworks are mature:
- Kotlin Multiplatform and Compose Multiplatform share business logic and, since Compose Multiplatform for iOS became stable in 2025, UI across Android and iOS (JetBrains, 2025; Kotlin Multiplatform). A natural fit if your backend is already on Kotlin, as in Spring Boot + Kotlin.
- React Native, with the New Architecture enabled by default since version 0.76 (React Native, 2024), lets web teams reuse React knowledge.
- Flutter offers a single UI toolkit with its own rendering engine.
Side-by-side comparison
| Criterion | PWA | Cross-platform native | Two native apps |
|---|---|---|---|
| Codebases | One (shared with website) | One for mobile + website | Two + website |
| Time to market | Fastest | Medium | Slowest |
| Typical cost | Lowest | Medium | Highest |
| Search engine visibility | Full | Only via separate website | Only via separate website |
| Push notifications | Yes (iOS after Home Screen install) | Yes | Yes |
| Offline | Yes, with service worker | Yes | Yes |
| Deep device APIs | Limited, especially on iOS | Most, via plugins | All |
| App store distribution | Optional (Android easiest) | Yes | Yes |
| Updates | Instant, no review | Store review (plus OTA for some code) | Store review |
Decision framework
Choose a PWA when:
- Your product is mostly content, catalog, forms, dashboards or ordering — e-commerce, booking, B2B portals, internal tools.
- Search traffic matters; every screen should be indexable.
- You want instant updates without app store review cycles.
- The budget favors one excellent product over three average ones.
Choose cross-platform native when:
- You need device capabilities PWAs can't reach on iOS, or reliable background behavior.
- Users expect to find you in app stores.
- You plan frequent, deep engagement: daily-use apps, field service, logistics apps with offline scanning.
Choose fully native when the app is the product and demands the best possible performance or platform-specific experience.
Many companies end up with a hybrid: a fast PWA for acquisition and occasional users, and a native app for the most engaged customers.
Making a PWA feel like an app
- Performance first. An installed app that responds slowly feels broken. Aim for good Core Web Vitals, especially INP; see Core Web Vitals in 2026.
- Design for offline. Decide which screens work offline, show clear connection status and queue actions safely.
- Ask for permissions in context. Request notification permission after a user action that makes the value obvious, not on first load.
- Guide iOS users to install with a short visual hint, since Safari has no install prompt.
- Keep it indexable. Server-render content and handle metadata properly, as described in Technical SEO for Next.js.
{
"name": "Acme Store",
"short_name": "Acme",
"start_url": "/?source=pwa",
"display": "standalone",
"background_color": "#ffffff",
"theme_color": "#0f172a",
"icons": [
{ "src": "/icons/192.png", "sizes": "192x192", "type": "image/png" },
{ "src": "/icons/512.png", "sizes": "512x512", "type": "image/png", "purpose": "any maskable" }
]
}
Offline strategies that work
Service workers let you choose a caching strategy per type of request:
| Content | Strategy | Why |
|---|---|---|
| App shell: HTML layout, CSS, JavaScript | Cache first, update in background | Instant start, even offline |
| Product images | Cache first with expiry | Rarely change, heavy to download |
| Catalog and prices | Network first, fall back to cache | Fresh data when online, something useful offline |
| Cart and orders (writes) | Queue offline, sync when online | Don't lose user actions on a bad connection |
| Payments and authentication | Network only | Never serve stale or cached responses |
Libraries such as Workbox implement these strategies so you don't write low-level service worker code by hand.
A rough cost comparison
For a typical commerce or booking product, our experience is that a well-built PWA costs roughly the same as a quality responsive website plus 15–30% for offline support, push notifications and installability. A cross-platform native app adds a separate mobile codebase, store publishing and release management; two fully native apps roughly double that again. Maintenance follows the same pattern: one web release pipeline versus two or three.
FAQ
Do PWAs work on iPhone? Yes. They can be added to the Home Screen, work offline and, since iOS 16.4, receive push notifications once installed.
Can a PWA be published in the App Store? Apple does not accept plain PWA wrappers without app-like value. Google Play accepts PWAs packaged as Trusted Web Activities.
Is a PWA cheaper than a native app? Usually significantly, because one codebase serves web and app, and updates ship without store reviews.
Can we start with a PWA and go native later? Yes, and it is often the smartest path: validate demand with the PWA, then invest in native where usage data justifies it.
Do PWAs work offline on iOS? Yes. Service workers and caching work in Safari and in Home Screen web apps, so cached screens and queued actions are available without a connection.
How do we measure whether users install the PWA?
Track the appinstalled event where supported and launches with a start_url parameter such as ?source=pwa, then compare engagement of installed and browser users.
Sources
- MDN. Progressive web apps and Push API.
- web.dev. Progressive Web Apps.
- WebKit (2023). Web Push for Web Apps on iOS and iPadOS.
- Apple. DMA and apps in the EU.
- Chrome for Developers. Trusted Web Activity.
- JetBrains (2025). Compose Multiplatform 1.8.0: iOS is stable.
- React Native (2024). React Native 0.76: New Architecture by default.