Progressive Web Apps (PWAs) were once hailed as the next big thing in web and mobile technology. Offering native-like experiences from the browser, with offline functionality, push notifications, and device hardware access, they promised to democratize app development and reduce dependency on native app stores. But nearly a decade after the term was coined, enthusiasm has tempered, and a nuanced, sometimes divided, reality has taken shape.
While some organizations thrive with PWAs, others have hit performance walls, UX limitations, and platform gatekeeping. This article takes a comprehensive, current look at what PWAs offer today, the real-world challenges they face, and why — for all their technical elegance — PWAs may never fully replace native applications.
What Are Progressive Web Apps?
A Progressive Web App is essentially a modern website enhanced with capabilities that make it behave like a native mobile or desktop application. PWAs can be added to a device’s home screen, work offline through service workers, and access features like push notifications and background sync.
At their core, PWAs consist of three components:
- A Service Worker: A JavaScript file that intercepts network requests, enabling offline caching and background tasks.
- A Web App Manifest: A JSON file that defines metadata such as the app’s name, icons, colors, and how it should launch.
- HTTPS security: To ensure data integrity and safe interactions.
PWAs are built using familiar web technologies — HTML, CSS, and JavaScript — and run within a browser container. What distinguishes them is how they progressively enhance functionality on devices and browsers that support advanced APIs.
A Brief History
The term "Progressive Web App" was coined by Google engineers Alex Russell and Frances Berriman in 2015. The concept quickly gained traction, positioned as a solution to the fragmentation between mobile web and native app experiences. Early adopters included Twitter (Twitter Lite) and Starbucks, whose PWA success stories were widely publicized.
Tangible Benefits of PWAs
PWAs offer several clear, measurable advantages:
Faster Development Cycles
A single PWA codebase can serve users on both mobile and desktop, dramatically reducing the overhead associated with maintaining separate native apps for iOS, Android, and desktop. Development frameworks like Workbox and tools such as Vite and PWA Builder have further lowered the technical entry barriers.
Offline Capabilities
Service workers allow for sophisticated caching strategies, enabling apps to load content offline or on poor networks. This is particularly valuable for markets with unreliable internet infrastructure or use cases requiring offline-first functionality.
Installation Without App Stores
PWAs can be added to a device’s home screen directly from a browser, sidestepping app store policies, commissions, and approval processes. This appeals to developers seeking distribution independence and faster iteration cycles.
Smaller Footprint and Faster Load
PWA packages are typically lighter than native apps, which can exceed 100 MB. Twitter Lite, for example, reduced its size to under 1 MB, leading to significant data savings and quicker load times — metrics that translate into better retention and engagement.
Criticisms and Limitations of PWAs
Despite these benefits, PWAs have not achieved the universal adoption that early advocates anticipated. An increasing number of developers, product managers, and tech writers have voiced valid concerns — and some outright disillusionment — about the limitations and trade-offs of PWAs.
Fragmented API Support
While Chrome, Edge, and Opera have aggressively implemented PWA standards, other platforms — most notably Apple's Safari — have been hesitant. iOS PWAs still lack access to essential APIs like Bluetooth, NFC, and even reliable push notifications in some cases. Web App Manifest properties are only partially supported on Apple devices, leading to inconsistent UX.
This uneven support undermines one of the core promises of PWAs: write once, run everywhere. Developers often find themselves building workaround solutions for different platforms, negating the simplicity benefit.
Poor Native Feature Parity
Despite advances in the Web APIs (such as WebRTC, WebXR, and File System Access API), PWAs still can't match native apps for deep OS-level integrations. Features like advanced camera controls, background location tracking, and seamless biometric authentication remain native-only or heavily restricted in web environments.
This is especially problematic for applications in healthcare, fintech, or AR/VR — areas where hardware access and privacy compliance are critical.
User Perception and Discoverability
Many users still perceive web apps as inferior to native apps. App stores function not only as distribution channels but also as discovery engines. Without a native app presence, a PWA risks being overlooked, particularly as app store algorithms and editorial lists drive significant organic traffic.
Platform Gatekeeping
Apple has strategically limited PWA capabilities on iOS. Safari remains the only browser engine allowed on iPhones and iPads, and Apple has been slow to implement key APIs. While developers can now offer home screen installation and basic offline functionality, critical features like reliable push notifications only became available in 2023 — and still fall short compared to Android’s Web Push.
This behavior has drawn scrutiny for anti-competitive practices, especially as Apple has a vested interest in preserving its lucrative App Store ecosystem.
Performance Ceiling
PWAs running in browser containers inherently incur performance overhead compared to native apps compiled for specific hardware architectures. While frameworks like React, Vue, and Svelte have made frontend rendering efficient, native SDKs like SwiftUI or Jetpack Compose maintain an edge in GPU-intensive tasks such as gaming, AR, or complex animations.
Criticisms From The Field
The past two years have seen a surge in reflective criticism about PWAs’ true capabilities and market position. Notable articles like "Why Progressive Web Apps Are a Terrible Idea" (StackDiary) and "The Illusion of the Progressive Web App" (Medium) have highlighted developer frustrations and limitations in adoption.
Some of the key arguments:
- False Universality: Despite claims, PWAs are not universal. Platform-specific gaps continue to demand fragmented code and testing.
- Compromised User Experience: Subtle UI differences, missing native controls, and occasional performance hiccups create a second-rate feel on some devices.
- Security Complications: While HTTPS is required, managing service worker cache versions and ensuring offline data integrity introduces new vectors for subtle security risks.
- Dependency on Browser Vendors: Unlike native SDKs controlled by OS providers, PWA functionality hinges on browser implementations — making developers vulnerable to strategic shifts by Google, Apple, or Microsoft.
- Discovery Deficit: The absence of an equivalent, centralized app discovery platform outside app stores diminishes PWA visibility and user acquisition opportunities.
Compelling PWA Use Cases
Despite the limitations, PWAs remain viable for specific scenarios where their strengths align with user needs.
E-Commerce in Emerging Markets
Starbucks and Alibaba succeeded by targeting regions with limited data infrastructure and lower-spec devices. Their PWAs deliver fast, lightweight, installable experiences without mandatory app store downloads.
Enterprise Internal Tools
PWAs are increasingly favored for internal dashboards, CRM systems, and B2B applications. The ability to deploy updates instantly, manage installations outside app stores, and work offline makes PWAs a practical fit for controlled enterprise environments.
Media and News Platforms
Sites like Forbes and The Washington Post use PWAs to enable offline reading, reduce data consumption, and improve load times — features that significantly enhance mobile news consumption.
Essential PWA Code Snippets
For a PWA to function minimally, it requires a service worker and a manifest file. Below is a basic example:
manifest.json
{
"name": "Sample PWA",
"short_name": "PWA",
"start_url": "/",
"display": "standalone",
"background_color": "#ffffff",
"theme_color": "#333333",
"icons": [
{
"src": "icon.png",
"sizes": "512x512",
"type": "image/png"
}
]
}service-worker.js
self.addEventListener('install', event => {
event.waitUntil(
caches.open('v1').then(cache =>
cache.addAll([
'/',
'/index.html',
'/styles.css',
'/app.js'
])
)
);
});
self.addEventListener('fetch', event => {
event.respondWith(
caches.match(event.request)
.then(response => response || fetch(event.request))
);
});These represent a minimal offline caching strategy and install prompt configuration.
The State of PWA Support (2025 Update)
As of mid-2025, PWAs enjoy relatively strong support on Android, Windows, and desktop Chrome. iOS has belatedly enabled more Web Push and service worker APIs, but inconsistencies and restrictions persist. Firefox maintains solid support but lacks adoption in mobile.
Advanced capabilities like background sync, native file system access, and AR interfaces remain experimental or partially supported, with a clear gap compared to native SDKs.
Final words
Progressive Web Apps deliver meaningful advantages in select contexts: rapid deployment, offline functionality, and cross-platform codebases. They have matured technically since their introduction, offering robust tools and libraries to facilitate development.
However, the notion of PWAs universally replacing native apps is no longer credible. Platform fragmentation, API limitations, and strategic resistance from major vendors — particularly Apple — curb their potential. For businesses, choosing between PWA and native should hinge on concrete use case demands rather than trends or philosophical ideals.
PWAs have secured a permanent, if bounded, role in the digital landscape. As a hybrid solution bridging mobile and web, they excel in narrow scenarios but fall short in delivering the deep, polished experiences native apps command.
Both the promise and the illusion of the Progressive Web App now coexist — and developers must navigate both with clear-eyed pragmatism.