What is a Progressive Web App?
A Progressive Web App, or PWA for short, is a web application that behaves like a native app. Under the hood it is simply HTML, CSS and JavaScript — the same technologies used to build every modern website. What sets a PWA apart is a few extra layers that let it do things that used to be reserved for apps from the App Store or Play Store: it can be installed on the home screen, work without internet, send push notifications and run full-screen without a browser bar around it.
The term was introduced by Google around 2015 to signal that the web had become technically mature enough to compete with native — not in every respect, but for a large share of what average apps do. A typical example: you open a webshop in Chrome or Safari on your phone. An "Add to home screen" option appears in the menu. Tap it, and an icon appears on your home screen that opens in a full-screen window — no browser bar, no address bar. To the user it feels exactly like a regular app, while technically you are still running a website.
A PWA is a website with a few standard building blocks on top that let it be installed as an app, work offline and send push notifications. One codebase, running anywhere a modern browser is installed.
The three technical pillars
A PWA rests on three pillars. The Service Worker is a piece of JavaScript that runs in the background, separately from the page. It intercepts network requests, stores pages and assets in a local cache, and serves them again later — even without a connection. It is also the channel for incoming push notifications. The manifest is a small JSON file describing the app's name, icon, colours and start screen; after installation, the operating system treats the PWA as a regular application. And HTTPS is a hard requirement: service workers simply don't work over plain HTTP — a sensible security measure given the access they have to network traffic.
What is a native app?
A native app is an application built specifically for one operating system, using the programming language and tools prescribed by that system's manufacturer. For iOS, that in practice means Swift (or the older Objective-C), built with Xcode and released through the App Store. For Android, it means Kotlin (or the older Java), built with Android Studio and released through the Play Store.
Native apps run directly on the operating system, with no browser in between. They have full access to everything the device can do: camera, microphone, GPS, NFC, Bluetooth, biometric authentication (Face ID, Touch ID), HealthKit health data, payments via Apple Pay or Google Pay, contact lists and calendars. Anything a user has to grant permission for through system dialogues can be called by a native app once that permission has been given.
Distribution goes through the official stores. Apple manually reviews every iOS app before it appears; Google does the same for Android, though somewhat more leniently. A user searches the store, reads reviews, sees the star ratings and then downloads the app. For brands with a broad audience, a presence in the App Store is a channel in its own right: a route to discoverability and trust that works differently on the web.
The price of that depth
That depth comes with a price tag in development effort. A truly native app for both iOS and Android means, in principle, two separate codebases in two different languages, built by specialists in each platform. A feature you want to offer in both apps has to be built twice, tested twice and maintained twice. On top of that comes the overhead of the App Store process: review times, regular updates to keep up with SDK requirements, and annual developer account fees.
For a fuller look at app development strategy, including when your own mobile app pays off, how the process runs and what is involved, see our app development service page.
Cross-platform as a middle ground
Between "pure PWA" and "two separate native apps" sits a third category: cross-platform native. With frameworks such as React Native, Flutter or .NET MAUI, you write a single codebase that compiles to both an iOS and an Android app, and that runs on the device itself as native code, not as a web page.
A React Native app appears in the App Store, gets its own icon and has access to the same hardware APIs as pure Swift or Kotlin. The difference is that the logic and screens are written in JavaScript, and a bridge translates those instructions into native components on the device. For most organisations this is the practical middle path: one team, one codebase, an App Store presence and native behaviour. We cover this trade-off in more depth on our page about building a React Native app.
Comparison across six dimensions
The choice between a PWA and native is rarely clear-cut. It depends on which dimensions matter most to you. Below are six that tend to be decisive in practice.
1. Offline capabilities
On paper, a PWA can work offline perfectly well: the service worker stores pages and data locally and serves them when there is no connection. In practice, that takes design discipline: which pages are precached, how pending changes are stored temporarily, and what you show when something is unavailable.
A native app has more built-in tools for offline scenarios: a local SQLite database, file system access and background synchronisation via OS services. For apps where offline is a genuine first-class scenario, such as field service, shipping or warehouses without coverage, that difference can be decisive. For an average app where offline is a nice-to-have, the PWA approach is more than sufficient.
2. Push notifications
Historically, this is where the biggest difference between the two worlds lay, and for a long time it worked against PWAs. Native apps have sent push notifications through Apple's and Google's central push services since the very beginning. For PWAs this was also possible on Android for a long time, but not on iOS, until Apple added web push support in iOS 16.4 (early 2023) for PWAs installed on the home screen.
Web push has been possible on iPhone and iPad since then, but with conditions: the PWA must be installed first (regular Safari tabs don't receive push), the user must give explicit permission, and the available functionality remains more limited than on Android or in a native app. If push is central to your product (chat applications, real-time alerts, transactional confirmations), native is often still the more predictable choice.
3. App Store distribution
A native app or a cross-platform native build appears in the App Store and Play Store. That gives you a discovery channel, star ratings and reviews, and an installation flow that feels familiar to many users. For B2C brands with mass reach, that presence is sometimes essential: a brand with "no app in the store" can feel unfinished to some audiences.
You distribute a PWA via your own URL. That is faster, freer and involves no review process, but it lacks the star-rating system and the natural discoverability of the stores. Some stores do now accept PWAs as a wrapper (Microsoft Store does so generously, Google Play via Trusted Web Activities, the Apple App Store not yet), but that remains a separate step.
4. Hardware access
Native apps have full access to everything the device offers: camera with advanced settings, biometric sensors, HealthKit and Google Fit, NFC for contactless payments or access passes, Bluetooth Low Energy for wearables and IoT, AR frameworks for augmented reality. PWAs have gained a lot of ground in recent years through web APIs (Web Bluetooth, Web NFC, WebRTC for camera access, Web Share), but coverage depends on the platform and is considerably more limited on iOS than on Android.
For an app that needs access to Apple Pay, HealthKit or a specific sensor that isn't available via web APIs, the choice automatically falls on native or cross-platform native. For an app that only needs to take a photo with the camera and read the location, a PWA is perfectly fine these days.
5. Performance
The performance gap between PWAs and native apps has narrowed considerably. For most apps (displaying content, filling in forms, browsing lists, confirming transactions), a well-built PWA is hardly, if at all, noticeably slower. For heavy graphics scenarios, intensive animations or complex interaction patterns, native (and cross-platform native) remain faster, because they talk directly to the device's graphics layer. A nuance: the first time a user opens a PWA before the service worker has been able to cache anything, it feels like a website. Only after installation does the user experience the "app feel".
6. Development cost and maintenance
This is often the deciding factor for SMEs and scale-ups. A PWA is essentially one codebase that runs on anything with a modern browser. Changes are available to everyone immediately: no review, no update to roll out, no old versions lingering on devices. A native app for two platforms requires two builds, two test suites, two release tracks. Cross-platform native brings those costs back down to one codebase, but adds its own complexity: a bridging layer, platform-specific exceptions, framework upgrades. Maintenance is ongoing with every approach.
| Dimension | PWA | Native / cross-platform |
|---|---|---|
| Offline | Possible via service worker | Deeply built into the OS |
| Push on iOS | Since iOS 16.4, with restrictions | Fully supported from day one |
| App Store | No native distribution | App Store and Play Store |
| Hardware | Limited on iOS | Full access |
| Codebase | One, for all platforms | One (cross-platform) or two (native) |
| Updates | Rolled out immediately | Via store review |
iOS limitations for PWAs
The biggest asterisk in any PWA story remains Apple. On Android, PWAs have worked almost fully for years: web push, background sync, install banners offered by the browser itself, generous web APIs for hardware. On iOS, Apple has always been more restrictive. A few concrete points:
- No automatic install prompt: where Android browsers can show a banner, an iOS user has to open the share menu manually and choose "Add to Home Screen". Many audiences never find that route without help.
- Limited storage: iOS imposes tighter quotas on what a PWA may store locally, and clears storage for rarely used PWAs without warning.
- Web push only from iOS 16.4: push notifications on iPhone and iPad have been available since March 2023, for PWAs installed on the home screen. Before that, push on iOS was simply not possible for years, which was a dealbreaker for many use cases.
- No access to certain sensors: NFC for reading, a number of Bluetooth profiles, Apple Pay outside Safari: Apple reserves this functionality for native apps.
- Safari as the only rendering engine: on iOS, every browser runs on WebKit under the hood. A PWA in Chrome on iPhone is still technically a Safari PWA.
Apple's reluctance is not a technical accident but a commercial calculation. A strong PWA ecosystem makes the App Store less essential as a channel, and with it the commission Apple charges on store transactions. That tension largely determines how far iOS PWA support goes.
Always test your use case specifically against iOS before choosing a PWA strategy. What works effortlessly on Android may lack the one feature that is essential to your product on iPhone.
When should you choose a PWA?
Not every app needs to be native. A PWA comes out strongly as soon as one of the following patterns applies:
- Content-heavy products: news, magazines, knowledge bases, documentation portals. The primary tasks are reading, navigating and searching, areas where a well-built PWA is every bit as good as a native app.
- Web-first organisations: you already have a strong website and a team with experience in JavaScript and modern web stacks. A PWA on top of the existing platform is a natural extension without starting a second team.
- Broad reach, low installation barrier: you want everyone who clicks your link to have something useful straight away. No hurdle to the App Store, no mandatory installation, and if the user returns often, you offer "Add to Home Screen".
- Need for rapid iteration: you change the UI regularly, add features and don't want to lose weeks to App Store review. You can roll out a PWA the same day.
- Wanting to avoid App Store restrictions: if your product doesn't fit Apple's or Google's guidelines (some categories around finance, gambling and content), or you don't want to pay a commission for commercial reasons, a PWA offers a legitimate way out.
- Simple hardware needs: your product needs only the camera, location and notifications, not deeper hardware integrations.
A common borderline case is the customer portal. An authenticated environment where a customer views their file, pays an invoice or reschedules an appointment can almost always work excellently as a PWA: installable for those who use it daily, simply accessible via the browser for those who rarely open it. We cover that specific choice between a customer portal as an app or as a responsive site separately in our guide to customer portal app versus responsive website.
When should you choose native?
On the other hand, there are patterns where native (cross-platform or not) is by far the strongest choice:
- Daily use with strong retention ambitions: your app sits on the home screen and is opened regularly. The icon, the push notifications and the presence in app switchers are marketing tools in themselves.
- Hardware-heavy features: AR, advanced camera controls, HealthKit, NFC payments, biometric authentication as core functionality, intensive Bluetooth integrations with wearables. These are areas where native is the only route, especially on iOS.
- App Store presence as a marketing channel: you expect installs from organic store searches or invest in App Store advertising. For some audiences, "not being in the store" is the same as "not existing".
- Performance-critical: games, real-time graphics apps, video editing, audio production. Not the average business app, but the scenario where every frame counts.
- Branding and feel: you want a brand experience that stands out from the web. Animations, gestures, custom typography — everything the web can do too, but which in native often comes out a touch more refined, without compromise.
- Distribution through app stores as a trust signal: in healthcare, finance or certain B2B segments, "we're in the App Store" sends a formal signal that a random URL doesn't.
If you end up on the native side without wanting to maintain two separate codebases from day one, React Native is often the starting point. One JavaScript codebase, two platform builds, and when a specific feature needs to go deeper, it can be supplemented with a platform-specific component. For less app-heavy products with a strong web origin, building a PWA on top of an existing Single Page Application is often a logical evolution — that SPA architecture lends itself well to adding a service worker and a manifest.
Hybrid strategies
The choice doesn't have to be binary. A common pattern: the entire product is available through a PWA for occasional users and search traffic, while a native app is offered to heavy daily users, with features that only work natively. On Android, you can also publish a PWA to the Play Store in a thin wrapper via a Trusted Web Activity — under the hood it remains the PWA, but the user downloads it like any other app.
Cost and maintenance
With a PWA, you're essentially paying for one codebase that runs on all modern browsers and operating systems. The work lies in building features, designing offline behaviour and setting up the service worker and manifest. Maintenance is largely limited to what you'd do for any high-quality website anyway — keeping up with modern JavaScript, tracking browser quirks, and occasionally debugging a service worker bug.
With two separate native apps, the build effort almost doubles: every feature twice, testing on two platforms, releasing on two stores. Cross-platform native sits somewhere between a PWA and pure native in terms of cost — one codebase, but with platform-specific attention for the parts that differ per OS, plus the App Store overhead.
Maintenance is ongoing with every approach. Apple and Google update their platforms every year; old APIs expire; iOS and Android versions force periodic upgrades. For every quote, ask explicitly about the handover: what does the codebase look like, how is it documented, and what would it take for another team to pick it up?
App Store economics and commissions
One aspect that often gets overlooked in technical comparisons is the commercial model of Apple and Google. Both stores charge a commission on transactions made through in-app purchases or subscriptions — historically 30 per cent, reduced to 15 per cent for smaller developers and for subscriptions after the first year. For products that run entirely on store transactions, that is not a marginal cost but a structural part of the revenue model.
A PWA sidesteps those commissions, because transactions go through your own web payments — Mollie, Stripe, Adyen or your own merchant account. That is one of the reasons some content, gaming and news platforms actively invest in PWAs. On the other hand, App Store presence is a marketing asset in its own right: the "verified publisher" signal, reviews and visibility in search results. For B2C brands with mass reach, that is rarely something you can ignore.
Common mistakes when choosing
- Choosing native because it feels more serious: a content-heavy app that nobody uses offline, built as two native versions — double the cost without double the value.
- Choosing a PWA and forgetting to design it as an app: a mobile website with "Add to home screen" bolted on never feels like an app. A real PWA needs app-level attention to navigation, gestures, offline states and notifications.
- Not testing on iOS up front: building a PWA that works beautifully on Android, only to discover at delivery that a critical feature is missing on iPhone. Test early, not late.
- Overestimating App Store presence: putting an app in the store doesn't mean anyone will find it. Without serious App Store Optimisation and channel investment, the icon stays invisible.
- Not budgeting for maintenance: the build is a one-off investment, while maintenance is ongoing. If you only budget for the build, you'll find out later that the app has disappeared from the store because an SDK has expired.
- Letting the app and website diverge: data models that drift apart, features that exist on the web but not in the app (or vice versa). Both channels should run on the same architecture.
None of these mistakes is exotic, and all of them are avoidable by asking the right questions at the start — about target audience, frequency of use, hardware needs, distribution strategy and maintenance capacity. If you want to explore the broader background of modern web technology, our page on web development as a service is a logical next step.
Frequently asked questions
What is the difference between a PWA and a regular website?
A regular website runs in a browser and stops as soon as you close the tab. A PWA is a website with a service worker and a manifest added, which makes it installable on the home screen, able to work offline and able to send push notifications.
Can a PWA do the same things as a native app?
Almost, but not quite. On Android the overlap is close, especially for content- and transaction-oriented apps. On iOS there are still important limitations — certain hardware APIs, push scenarios and storage quotas. For functionality that requires deep hardware access or explicit App Store distribution, native is still needed.
Does a PWA work on iPhone?
Yes. Safari has supported the building blocks for years, and since iOS 16.4 it also supports web push (provided the PWA is installed on the home screen). Installation is still manual via the share menu, though, and some web APIs that work on Android remain reserved for native apps on iOS.
Can a PWA be published in the App Store?
On the Microsoft Store and Google Play, yes, usually via a wrapper format. On the Apple App Store, not directly — there you need to release a (cross-platform) native app to have a presence.
Is React Native a PWA?
No. React Native builds a genuine native app that appears in the App Store and Play Store and uses native UI components, written in JavaScript. A PWA is a website with a service worker and manifest. Both use JavaScript, but they are different deployment models.
Which form should you choose if you're unsure?
Start with a PWA if your audience is broad and your hardware needs are limited; plan a native or cross-platform extension once frequency of use justifies it. The reverse works less well.