Progressive Web Apps promised to close the gap between web and native. In 2026, the technology has matured considerably. iOS Safari finally caught up on many PWA features. But the honest answer to whether PWAs are worth building depends heavily on what you are trying to build. Here is a clear-eyed assessment.
What PWAs Actually Give You
A Progressive Web App is a web application enhanced with specific browser APIs that enable native-app-like capabilities. The core technologies:
Service Workers intercept network requests and can return cached responses. This is the foundation of offline support. A service worker can cache HTML, CSS, JavaScript, images, and API responses. When the user is offline, the service worker returns cached content.
Web App Manifest is a JSON file that tells the browser metadata about your app: name, icons, theme color, and -- most importantly -- the display mode that controls whether the installed app shows browser chrome or not.
Background Sync queues actions taken offline (a form submission, a toggle) and replays them when connectivity returns. This is what makes offline-capable apps feel native rather than just broken.
Push Notifications allow the server to send notifications to the browser even when the site is not open, if the user grants permission.
These four capabilities cover most of what distinguishes a native app from a web page.
An Honest Assessment of Each Capability
Offline support is genuinely useful and works well in 2026 across all major browsers including Safari. For content-heavy applications (reading, note-taking, documentation), offline support provides real value. Users who lose connectivity do not see a blank screen -- they see the last cached version. For apps that involve filling out forms in areas with spotty connectivity, offline queuing with Background Sync is transformative.
The caveat: implementing offline support correctly is non-trivial. You need to decide what to cache (everything? only the shell? specific content?), handle cache invalidation (when content updates, the cache must too), and handle the edge cases (partial connectivity, expired caches).
Home screen installation works technically but has low real-world conversion. The browser shows an install prompt when certain criteria are met (HTTPS, service worker, manifest). Most users dismiss it. Studies show install prompt click-through rates of 2-5%. iOS Safari requires the user to manually select "Add to Home Screen" from the share menu, and many users do not know this is possible.
If installation is central to your retention strategy, native app distribution through the App Store and Play Store has significantly higher visibility and install rates.
Push notifications are heavily restricted, especially on iOS. iOS allows web push notifications only for PWAs that have been added to the home screen (not just open in Safari). Permission grant rates for push notifications are low across all platforms (10-20% typically). The reach of web push is much smaller than native push in practice.
Background sync works well but is limited to Chrome and Chrome-based browsers. Safari does not support the Background Sync API as of 2026. This is a significant limitation for any audience with iOS/macOS users.
Browser Support in 2026
iOS Safari has improved substantially. The historical excuse that "PWAs don't work on iOS" is no longer accurate for the core features:
- Service workers: supported since iOS 11.3
- Web App Manifest: supported (with some limitations on icon handling)
- Web push notifications for installed PWAs: supported since iOS 16.4
- Background sync: not supported on iOS (uses best-effort sync instead)
The iOS experience is still not identical to Android, but it is no longer broken. Users on iOS can install a PWA to their home screen and have a reasonable offline experience.
When PWAs Are Worth Building
Content-heavy apps where users consume content repeatedly. A documentation site, news reader, or research tool used frequently benefits from: fast load times (cached shell), offline reading, and optional home screen installation for power users. The effort is justified by the improved experience for users who return often.
Apps with intermittent connectivity. Field workers, delivery drivers, medical staff in areas with poor coverage -- these users benefit concretely from offline-capable apps. The alternative (a blank screen when connectivity drops) is genuinely worse for their workflow.
Cases where App Store distribution is not viable. Small B2B tools, internal company apps, apps targeting markets where Play Store or App Store penetration is low. A PWA reaches users via a URL with no store approval process and no 15-30% platform revenue cut.
Apps where the user base is desktop-heavy. PWAs on desktop (Chrome, Edge) have excellent support and feature parity. Installation adds a dedicated app window, taskbar/dock icon, and cleaner full-screen experience. For productivity tools used at a desk, PWA installation provides a genuinely native-feeling experience.
When Native Beats PWA
Hardware access. Native apps have access to hardware APIs that PWAs cannot touch: Bluetooth (limited Web Bluetooth support), NFC (emerging support but not universal), file system (Web File System Access API works in Chrome but not Safari), advanced camera controls, and ARKit/ARCore.
Game performance. Native apps can use Metal (iOS) or Vulkan (Android) directly for GPU-accelerated graphics. WebGL and WebGPU have improved but have higher overhead. Graphically intensive games belong in native apps.
App Store discoverability. The App Store and Play Store are how most users discover apps. PWAs are discovered via web search or direct links. If your acquisition strategy depends on being found in an app store, you need a native app or a React Native / Flutter app.
Deep OS integration. Shortcuts, widgets, Siri/Google Assistant integration, Apple Watch companions, background location tracking -- these require native SDKs.
Next.js PWA Setup
The next-pwa plugin adds service worker support to Next.js. It uses Workbox under the hood for precaching and runtime caching.
Install and configure:
// next.config.ts
import withPWA from "next-pwa";
const config = withPWA({
dest: "public",
disable: process.env.NODE_ENV === "development", // Disable in dev -- service workers complicate HMR
register: true,
skipWaiting: true,
});
export default config;
The manifest file goes in public/manifest.json:
{
"name": "My App",
"short_name": "App",
"description": "My progressive web app",
"start_url": "/",
"display": "standalone",
"background_color": "#ffffff",
"theme_color": "#000000",
"icons": [
{ "src": "/icon-192.png", "sizes": "192x192", "type": "image/png" },
{ "src": "/icon-512.png", "sizes": "512x512", "type": "image/png" }
]
}
Reference it from your root layout:
export const metadata: Metadata = {
manifest: "/manifest.json",
};
This covers the basics: service worker registration, manifest, and installability. For custom offline pages, runtime caching of API responses, and background sync, you need to extend the Workbox configuration or write custom service worker logic.
The Verdict
PWAs in 2026 are worth building for the right use cases. They are not worth building as a substitute for a native app when native-specific capabilities or app store distribution are important.
For content apps, tools used by users with connectivity constraints, desktop productivity tools, and cases where app store distribution is not the goal -- PWAs deliver real value with moderate implementation effort. For games, hardware-heavy apps, and anything where App Store/Play Store discovery is essential -- build native.
Keep Reading
- Next.js Performance Optimization: The Practical Guide for Production Apps -- performance optimization that complements PWA caching
- Web Accessibility in 2026: The Practical Guide for Developers -- accessible PWAs
- Next.js Caching in 2026: The Complete Guide to All Four Layers -- understanding the difference between Next.js caching and service worker caching
Pristren builds AI-powered software for teams. Zlyqor is our all-in-one workspace -- chat, projects, time tracking, AI meeting summaries, and invoicing -- in one tool. Try it free.
