Fact-checked by Grok 2 weeks ago

Progressive web app

A progressive web app (PWA) is a built using standard web technologies such as , CSS, and , but enhanced with modern to deliver a reliable, fast, and engaging comparable to native platform-specific apps. PWAs combine the broad reach of the —accessible via any on any device—with app-like features including offline access, push notifications, and seamless installation to a device's , all from a single codebase. PWAs are defined by several key characteristics that distinguish them from traditional websites. They are progressive, progressively enhancing functionality based on the capabilities of the user's and ; responsive, adapting layouts and interactions to various screen sizes and orientations; connectivity-independent, enabling offline use or low-bandwidth operation through caching strategies; app-like, offering immersive standalone modes without chrome; safe, requiring secure delivery to protect user data; and discoverable, allowing indexing by search engines for easy access. These principles ensure PWAs work reliably across diverse environments while prioritizing user privacy and performance. At their core, PWAs rely on essential web standards for advanced functionality. A Web App Manifest, a JSON-based file, provides like app name, icons, and display preferences to enable installation and customization. Service Workers, event-driven scripts running in the background, intercept network requests to enable caching, offline support, and features like background synchronization. Additionally, PWAs must be served over to ensure security and access to powerful APIs. The term "Progressive Web App" was coined in 2015 by developer Alex Russell and designer Frances Berriman to describe web experiences that harness emerging capabilities like service workers and app manifests, evolving from earlier web standards to close the gap between web and native apps. Since then, PWAs have gained widespread adoption, with benefits including faster load times—reducing bounce rates by up to 123% when improving from 10 to 1 second—higher user engagement (e.g., 65% more pages per session on Twitter's PWA), and cross-platform efficiency without separate native builds. Examples include , which saw a 60% increase in core engagements after implementing a PWA, demonstrating their impact on business metrics like traffic and retention.

History

Predecessors

The development of progressive web apps built upon earlier efforts to enhance web applications with offline functionality and cross-device adaptability. In the late and early 2010s, HTML5 introduced the Application Cache API (AppCache), which allowed developers to specify resources for offline use by creating a cache manifest file linked to an HTML document via the manifest attribute. This enabled web apps to load resources from the when offline, providing a basic offline experience for users, but it was limited to static resource caching without advanced control over network requests. However, AppCache suffered from significant reliability issues and browser inconsistencies that hindered its adoption. Updates to the cache required changes to the , but the process was all-or-nothing: if even one resource failed to download during an update, the entire cache update would abort, leaving the app in its previous state and potentially serving stale content indefinitely—a problem sometimes referred to as the "zombie cache" where the cache becomes stuck and unresponsive to updates. Browser support varied widely; for instance, allocated up to 20% of available disk space shared with other storage APIs, while imposed a strict 5 MB limit per , leading to unpredictable behavior across platforms. These flaws, including fragility to network errors and lack of fine-grained control, made AppCache unreliable for production web apps and prompted its deprecation in favor of more robust mechanisms like service workers. Parallel to these technical advancements, design principles emerged to address the growing diversity of devices. Responsive web design, coined by Ethan Marcotte in 2010, emphasized fluid grids, flexible images, and CSS media queries to create layouts that adapt seamlessly to varying screen sizes, laying the foundation for cross-device compatibility in web applications. Complementing this, the mobile-first approach, popularized by Luke Wroblewski in 2009, advocated designing for smaller screens and touch interactions before scaling up to larger desktops, ensuring optimal performance and usability on mobile devices where bandwidth and processing power were constrained. These methodologies shifted web development toward device-agnostic experiences, influencing the progressive enhancement strategies central to PWAs. In 2015, Google launched the (AMP) project as an open-source initiative to accelerate content loading on mobile devices, particularly for news articles and static pages. AMP pages used a restricted subset of , minimal CSS, and sandboxed executed in iframes to achieve sub-second load times by preloading resources via Google's cache, but this came at the cost of limited interactivity, as custom JavaScript and complex dynamic features were heavily curtailed to prioritize speed over full app-like functionality. While AMP improved delivery, its focus on read-only, non-interactive pages highlighted the need for technologies that could support richer, app-like experiences without such compromises.

Introduction and Early Adoption

The term "Progressive Web App" (PWA) was coined by Alex Russell, a developer, and designer Frances Berriman on June 15, 2015. They introduced the concept to describe web applications that leverage —starting with basic functionality and progressively adding advanced features—to provide reliable, fast, and engaging experiences comparable to native apps, while remaining accessible via standard web URLs without app store barriers. This vision aimed to bridge the gap between the open web and closed native ecosystems, prioritizing inclusivity for users on low-end devices or slow networks. Building on foundational web technologies like , Google outlined the initial technical framework for PWAs later in 2015. The proposal centered on integrating two key APIs: Service Workers, which enable background scripting for caching, offline access, and push notifications; and the Web App Manifest, a file that defines app metadata for installation, icons, and splash screens to mimic native app behavior. These elements allowed developers to create web apps that felt native-like, with the "app shell" model ensuring rapid loading of core while deferring non-essential content. Early adoption gained momentum in 2017, highlighted by 's launch of Twitter Lite as a PWA in April. This lightweight version loaded in under three seconds on networks, resulting in a 65% increase in pages per session, a 75% increase in tweets sent from web users, and up to 70% data savings compared to the native app, demonstrating PWAs' potential for emerging markets with limited bandwidth. Similarly, released its PWA that year, allowing users to curate and read personalized news magazines offline by caching articles and media. The W3C began formalizing PWA-enabling technologies in 2016 through its Web Applications Working Group, advancing specifications for Service Workers and related APIs to ensure cross-browser interoperability. This effort, incubated partly via the Web Incubator Community Group, focused on standardizing components like caching strategies and parsing to support reliable web app experiences.

Recent Developments

In 2023, Apple introduced support for push notifications in Progressive Web Apps (PWAs) on with the release of 16.4 and Safari 16.4, allowing developers to send real-time alerts to users who have added the PWA to their and granted permission. This feature marked a significant step forward, though it is limited to confirmed domains and requires explicit user opt-in. In the , compliance with the () led to reversals of planned PWA restrictions in 17.4, maintaining home screen web app support. Subsequent 18.1 updates, as of 2024, enabled third-party browsers to create PWAs for the iPhone home screen using their own engines, improving installation prompts and under DMA requirements, particularly in the . However, PWAs continue to face limitations, such as a 50 MB cache storage quota and restricted background processing due to battery and privacy policies. From 2024 onward, PWAs have increasingly integrated with through the Web Neural Network (WebNN) API, a W3C standard that enables on-device processing without relying on cloud services. This API allows PWAs to leverage for tasks like image recognition and directly in the browser, reducing latency and enhancing privacy in applications such as personalized content recommendation. In parallel, connectivity has advanced via the Web and WebUSB APIs, which permit PWAs to interface with smart devices like sensors and peripherals over or USB connections. For instance, developers can use Web to enable PWAs to read data from wearables or control systems, fostering seamless ecosystems in 2024-2025 deployments. Google reinforced PWA adoption on in by expanding Trusted Web Activities (TWAs), allowing developers to package PWAs for distribution in the Store with full-screen experiences and integration of native features like Play Billing for in-app purchases. These updates eliminated the need for a service worker fetch handler during installation and introduced richer install prompts with screenshots and descriptions from the web app manifest, streamlining the path from web to store-listed app. Performance advancements in PWAs have narrowed the gap with native apps, particularly through refined caching strategies in service workers. On devices, PWAs benefit from APIs such as Cache Storage and Background Fetch that optimize resource management and reduce data usage, enabling smooth rendering and minimal latency. These gains make PWAs viable alternatives for resource-constrained environments, though they remain browser-dependent.

Definition and Characteristics

Core Principles

Progressive Web Apps (PWAs) are built on the principle of , ensuring that the application functions effectively in any by providing a baseline experience that gracefully degrades on older or less capable devices while progressively adding enhanced features on modern ones. This approach prioritizes universal accessibility, allowing users to access core content and functionality regardless of their or device limitations, thereby democratizing the experience. Reliability forms a foundational pillar of PWAs, emphasizing fast loading times and seamless offline functionality to maintain usability under varying network conditions. By leveraging technologies like service workers, PWAs can cache essential resources, enabling instant loading and operation without an internet connection, which eliminates frustrations such as slow performance or complete inaccessibility during poor connectivity. Safety is non-negotiable, with PWAs mandating delivery over to protect against man-in-the-middle attacks and ensure . This secure not only safeguards user interactions but also unlocks advanced web essential for PWA capabilities. Discoverability is equally critical, as PWAs use standard URLs that allow them to be indexed by search engines, making them easily findable through conventional web searches rather than app stores. Re-engageability enhances user retention by mimicking native app behaviors, such as sending push notifications to alert users to updates or new , and prompting installations to the for quick access. These mechanisms foster ongoing interaction, bridging the gap between and native experiences while keeping the app lightweight and updateable without manual intervention.

Key Features

Progressive web apps (PWAs) deliver user-centric features that emulate native applications while leveraging technologies, grounded in the core principles of for reliability and accessibility. Installability enables users to add PWAs to their home screens or app launchers via prompts, resulting in icons that launch the app in standalone windows free of chrome such as address bars. This feature fosters an app-like permanence and convenience, allowing direct device access without navigating through a , which improves re-engagement and reduces friction in daily use. Responsiveness ensures PWAs adapt fluidly across devices and screen sizes through CSS and flexible layouts, providing a seamless transition between , tablet, and desktop environments. Users benefit from a consistent, optimized viewing experience regardless of device, eliminating the need for separate versions and enhancing on diverse . Engagement is bolstered by background synchronization, which queues and completes updates opportunistically when connectivity returns, ensuring content remains fresh without interrupting user workflows. Additionally, splash screens deliver a polished, native-style launch , mimicking installed apps to create an immediate sense of reliability and professionalism upon opening. These elements heighten user retention by offering uninterrupted interactions and a responsive feel even in variable network conditions. Linkability allows PWAs to be shared effortlessly via standard URLs, supporting to specific content and integration with social sharing mechanisms, in contrast to native apps often confined to app stores. This inherent web characteristic promotes discoverability through search engines and easy dissemination among users, broadening reach without installation barriers.

Technical Foundations

Web App Manifest

The web app is a JSON-based that provides developers with a centralized place to define for a , enabling features such as prompts, app icons, and display preferences in supporting browsers. It is typically named manifest.json and linked to the document using a <link> element with rel="manifest" and the href attribute pointing to the file's location, such as <link rel="manifest" href="/manifest.json">. This manifest plays a crucial role in making progressive web apps (PWAs) installable by supplying the necessary information for the browser to present the app as a native-like experience on the user's device. The manifest consists of a single JSON object with top-level keys known as members, including required and recommended properties for app identity and behavior. Essential members include name, a full human-readable for the app; short_name, a concise version for in limited spaces like home screens; and icons, an array of image resources specifying sources (src), sizes (e.g., 192x192 pixels), types (e.g., or ), and purposes (e.g., "any" for general use or "maskable" for adaptive icons). Other key members are start_url, the URL launched when the app opens (relative to the manifest's ); display, which controls the mode such as "fullscreen" (no browser chrome), "standalone" (app-like without ), or "minimal-ui" (reduced browser ); scope, defining the set of URLs navigable from the start URL to prevent ; theme_color, a CSS color for elements like the ; and background_color, a fallback color shown while the app loads. For example, a basic manifest might appear as: 
json
{
  "name": "My Progressive Web App",
  "short_name": "MyPWA",
  "icons": [
    {
      "src": "/icons/icon-192.png",
      "sizes": "192x192",
      "type": "image/png",
      "purpose": "any maskable"
    }
  ],
  "start_url": "/",
  "display": "standalone",
  "scope": "/",
  "theme_color": "#000000",
  "background_color": "#ffffff"
}
To trigger installability, the manifest must meet specific validation criteria enforced by browsers: it must be served over HTTPS, parse as valid JSON without errors, include a valid name or short_name, a start_url within the site's scope, and at least one icon of 192x192 pixels or larger with appropriate format support. Upon meeting these criteria—along with complementary requirements like a registered service worker—browsers like Chrome and Firefox will parse the manifest and offer an install prompt to users, allowing the PWA to be added to the home screen or applications folder. On , support for the web app manifest has evolved gradually but remains partial compared to other platforms. Since iOS 11.3 in 2018, has provided basic PWA capabilities using Apple-specific meta tags like <link rel="apple-touch-icon"> for icons and startup images, bypassing the full manifest for metadata. Icons support from the web app manifest was added in Safari 15.4 ( 15.4, March 2022), with further properties like name, modes, and added or enhanced in Safari 16.4 ( 16.4, March 2023). In 2024, EU regulations under the led to temporary adjustments in PWA support on 17.4, which were resolved to maintain prior functionality. As of 18 (2024) and 18 (2025), advanced features like scope validation remain limited when adding sites to the via the Share menu. This adaptation allows users to install PWAs manually, but without automatic prompts, relying on these meta tags for broader .

Service Workers

Service workers are event-driven scripts that run in the background, separate from the main thread, enabling web applications to intercept and handle network requests even when the page is not active. They function as a programmable between the app, the , and the network, allowing developers to resources, manage offline functionality, and perform background tasks without impacting the . This architecture ensures that service workers operate independently of the document's lifecycle, persisting across sessions and enabling progressive web apps (PWAs) to deliver reliable, app-like experiences. The lifecycle of a service worker begins with registration, typically initiated via the navigator.serviceWorker.register() method, which loads a file defining the worker's behavior and associates it with a specific scope, often aligned with the web app manifest's start URL to define operational boundaries. Upon successful registration, the service worker enters the "installing" phase, triggered by the install event, where developers can precache essential assets using the Cache API to prepare for offline use. Once installed, the activate event fires, allowing cleanup of outdated caches from previous versions to prevent storage bloat and ensure smooth updates. This controlled lifecycle manages concurrency, with only one active service worker per scope at a time, facilitating seamless version transitions in PWAs. Core use cases for service workers in PWAs revolve around enhancing reliability through network interception and background synchronization. For caching, service workers listen for fetch events to implement strategies such as cache-first, which serves resources from the local cache before attempting a network request, or network-first, which prioritizes fresh data from the server while falling back to cache if offline; these are achieved via the Cache API's caches.open() and caches.match() methods. Additionally, service workers handle events from servers to deliver notifications, enabling real-time updates without user interaction, as seen in the push event listener that can trigger display of custom notifications. Error handling in service workers focuses on graceful degradation for offline scenarios, where failed network requests during a fetch event can return fallback responses from the or generate custom error pages to maintain usability. For instance, if no cached resource matches a request, the worker can respond with a default offline page, ensuring the PWA remains functional rather than failing entirely. This approach, combined with the worker's event-driven nature, supports robust offline-first architectures in PWAs. 
javascript
// Example: Basic service worker registration
if ('serviceWorker' in [navigator](/page/Navigator)) {
  [navigator](/page/Navigator).serviceWorker.register('/[sw](/page/SW).js')
    .then(registration => console.[log](/page/Log)('[SW](/page/SW) registered'))
    .catch(error => console.[log](/page/Log)('[SW](/page/SW) registration failed'));
}

// Example: Install [event](/page/Event) for caching
self.addEventListener('[install](/page/Install)', [event](/page/Event) => {
  [event](/page/Event).waitUntil(
    [caches](/page/Cache).open('[v1](/page/V1)').then([cache](/page/Cache) => [cache](/page/Cache).addAll(['/index.html', '/styles.css']))
  );
});

// Example: Fetch [event](/page/Event) with cache-first [strategy](/page/Strategy)
self.addEventListener('fetch', [event](/page/Event) => {
  [event](/page/Event).respondWith(
    [caches](/page/Cache).[match](/page/Match)([event](/page/Event).request).then(response => response || fetch([event](/page/Event).request))
  );
});
```[](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers)

## Browser and Platform Support

### Major Browsers

[Apple Safari](/page/Safari) offers partial support for Progressive Web Apps (PWAs), with service workers available since [version](/page/Version) 11.1 in 2017 for offline caching and basic functionality. The web app manifest is supported but with limitations, such as incomplete handling of display modes on [iOS](/page/IOS). Push notifications were added in [version](/page/Version) 16.4 ([March](/page/March) 2023) for [macOS Ventura](/page/MacOS_Ventura) and [iOS](/page/IOS) 16.4, though they require user gestures and immediate display on [iOS](/page/IOS) to maintain permissions. As of [Safari](/page/Safari) 18 in November 2025 (aligned with macOS Sequoia and [iOS](/page/IOS) 18), PWA installation to the [home screen](/page/Home_screen) or [dock](/page/Dock) is possible, but advanced features like background synchronization remain unavailable. This support is consistent across [iOS](/page/IOS) and macOS, prioritizing security over full app-like behaviors.[](https://caniuse.com/web-app-manifest)[](https://developer.apple.com/documentation/usernotifications/sending-web-push-notifications-in-web-apps-and-browsers)[](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps)

Google Chrome has offered comprehensive support for Progressive Web Apps (PWAs) since version 40 in 2015, including full implementation of the web app manifest for installability, service workers for offline functionality, and push notifications for user engagement. This support extends to version 142 as of November 2025, with seamless [Android](/page/Android) integration via the "Add to [Home Screen](/page/Home_screen)" prompt, enabling PWAs to behave like native applications.[](https://caniuse.com/web-app-manifest) On [desktop](/page/Desktop) platforms, Chrome's PWA features allow for standalone windows and taskbar pinning, enhancing [user experience](/page/User_experience) across operating systems.

Mozilla [Firefox](/page/Firefox) provides robust PWA support on [Android](/page/Android) since [version](/page/Version) 54 in 2017, covering core elements like service workers, background sync, and push notifications for reliable offline and real-time capabilities.[](https://caniuse.com/push-api) For desktop, [Firefox](/page/Firefox) introduced experimental PWA [installation](/page/Installation) in Nightly builds in March 2025, progressing to tested support on Windows by August 2025, though full [manifest](/page/Manifest) integration remains partial compared to Chromium-based browsers up to [version](/page/Version) 145.[](https://www.ghacks.net/2025/08/22/experimental-firefox-now-supports-progressive-web-apps-on-windows/) This development addresses prior gaps, allowing users to install and manage PWAs more natively on desktop environments.[](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps/Guides/Installing)

Microsoft Edge gained full PWA support after adopting the Chromium engine in January 2020 with version 79, mirroring Chrome's feature set including manifests, service workers, and notifications up to version 142 in late 2025.[](https://learn.microsoft.com/en-us/microsoft-edge/progressive-web-apps/) Edge excels in Windows integration, supporting PWA installation to the Start menu, taskbar, and even Widgets Board in Windows 11 for enhanced discoverability and actions.[](https://learn.microsoft.com/en-us/microsoft-edge/progressive-web-apps/whats-new/pwa) This alignment ensures consistent PWA performance across desktop and mobile, with ongoing updates like App Actions in version 137 for deeper system ties.[](https://blogs.windows.com/msedgedev/2025/05/30/bring-your-pwa-closer-to-users-with-app-actions-on-windows/)

Chromium-based browsers like [Brave](/page/Brave) and [Opera](/page/Opera) deliver full PWA compatibility, with support for manifests since versions 53 and 40 respectively, extending to their latest releases in 2025.[](https://caniuse.com/web-app-manifest) [Brave](/page/Brave) emphasizes [privacy](/page/Privacy) in PWA implementations, such as optimized service worker caching that blocks trackers without compromising offline access.[](https://community.brave.app/t/progressive-web-applications-pwa-in-brave/605917) [Opera](/page/Opera) similarly aligns with [Chromium](/page/Chromium) standards, supporting push APIs and installation prompts while maintaining cross-platform consistency for desktop and mobile users.[](https://caniuse.com/push-api)

### Platform-Specific Limitations

Progressive Web Apps (PWAs) encounter significant OS-level constraints on [iOS](/page/IOS), where Safari's implementation limits key functionalities despite broader [web](/page/Web) standard support. As of 2025, [iOS](/page/IOS) does not provide full service worker support for background [synchronization](/page/Synchronization), even following the partial enhancements in iOS 18, which prevent PWAs from deferring and executing tasks automatically upon network reconnection without user intervention.[](https://caniuse.com/background-sync) [Push](/page/Push) notifications on [iOS](/page/IOS) require explicit user confirmation through a [gesture](/page/Gesture) to grant permission, and the service worker must display the notification immediately upon receipt; otherwise, the permission is automatically revoked to ensure timely delivery.[](https://developer.apple.com/documentation/usernotifications/sending-web-push-notifications-in-web-apps-and-browsers) Additionally, while home screen badges are supported for installed PWAs using the [Badging API](/page/API) since iOS 16.4, they necessitate separate user configuration in the device's Notifications settings and are limited to [Home Screen](/page/Home_screen) web apps.[](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps/How_to/Display_badge_on_app_icon)

On [Android](/page/Android), PWA support is robust in modern versions through [Chrome](/page/Chrome), enabling full access to service workers, offline caching, and push notifications. However, older [Android](/page/Android) versions prior to 5.0 ([Lollipop](/page/Lollipop)) lack service worker compatibility entirely, rendering core PWA features like offline functionality unavailable, and they do not enforce [HTTPS](/page/HTTPS) as a secure context requirement for these APIs.

Desktop operating systems present varying degrees of integration challenges for PWAs. Windows and macOS offer complete PWA support via browsers such as [Microsoft Edge](/page/Microsoft_Edge) and [Google Chrome](/page/Google_Chrome), including seamless notification handling and installation to the [taskbar](/page/Taskbar) or [dock](/page/Dock). On [Linux](/page/Linux) distributions, while major browsers like [Chrome](/page/Chrome) provide the underlying PWA capabilities, notification integration can differ across desktop environments—such as GNOME's reliance on system trays versus KDE's [plasma](/page/Plasma) notifications—potentially leading to inconsistent display or management of alerts.

To address these platform-specific limitations, developers implement progressive enhancement techniques, detecting available features at runtime (e.g., via checks like `'serviceWorker' in navigator` or `'PushManager' in window`) and gracefully degrading to basic web app modes, such as server-dependent loading without offline support or simplified user prompts for notifications.[](https://web.dev/learn/pwa/progressive-web-apps) This approach ensures core usability across constrained environments while maximizing advanced features where supported.

## Advanced Enabling Technologies

### WebAssembly

WebAssembly (Wasm) is a binary instruction format designed for a stack-based virtual machine, enabling code to execute at near-native speeds within web browsers. It serves as a portable compilation target for high-level languages such as C++, [Rust](/page/Rust), and others, allowing developers to leverage existing codebases for web applications without significant performance loss. This format complements [JavaScript](/page/JavaScript) by providing efficient execution for computationally intensive tasks that would otherwise be slow in interpreted environments.[](https://webassembly.org/)[](https://developer.mozilla.org/en-US/docs/WebAssembly)

In Progressive Web Apps (PWAs), [WebAssembly](/page/WebAssembly) integrates seamlessly to enhance performance, particularly for high-demand operations like image processing or gaming. Developers load Wasm modules dynamically through [JavaScript](/page/JavaScript), often caching the binaries via service workers to support offline execution, ensuring the PWA remains functional without network access. For instance, Adobe's web version of Photoshop utilizes [WebAssembly](/page/WebAssembly), compiled from its C++ codebase via [Emscripten](/page/Emscripten), to perform complex editing tasks such as layer manipulation and filtering at speeds comparable to native applications. Similarly, PWAs incorporating games or simulations benefit from Wasm's efficiency, as seen in ports of engines like [Unity](/page/Unity) that deliver smooth rendering and physics calculations directly in the browser.[](https://web.dev/articles/ps-on-the-web)[](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps/Guides/Offline_and_background_operation)

WebAssembly operates within a strict [security](/page/Security) model, executing in a memory-safe [sandbox](/page/Sandbox) that isolates it from the host environment and prevents unauthorized access to system resources. Modules interact with [JavaScript](/page/JavaScript) through well-defined imports and exports, where functions and globals are explicitly declared and validated at load time, raising exceptions for any violations. To optimize delivery in PWAs, Wasm binaries are typically compressed using [Brotli](/page/Brotli), which achieves superior size reduction compared to [Gzip](/page/Gzip)—often 20-30% smaller—facilitating faster downloads over mobile networks while maintaining compatibility across browsers.[](https://webassembly.org/docs/security/)[](https://almanac.httparchive.org/en/2021/webassembly)

By 2025, advancements in [WebAssembly](/page/WebAssembly), notably the completion of version 3.0 including the [Garbage Collection](/page/GC) ([GC](/page/GC)) proposal, have expanded its capabilities for PWAs. As of late 2025, the [GC](/page/GC) proposal is implemented in major browsers including [Chrome](/page/Chrome) (version 119+), [Firefox](/page/Firefox) (120+), and [Safari](/page/Safari) (18.2+), enabling efficient support for languages like [Java](/page/Java) and C# in PWAs. The [GC](/page/GC) feature introduces automatic [memory management](/page/Memory_management) with support for structured data types, enabling the efficient handling of large, dynamic datasets in complex applications such as embedded [databases](/page/DNA_gyrase) or [real-time](/page/Real-time) [analytics](/page/Analytics) tools. This low-level [GC](/page/GC) allows compilers from languages like [Java](/page/Java) or [OCaml](/page/OCaml) to target Wasm more effectively, reducing manual memory overhead and unlocking previously impractical use cases in browser-based PWAs without relying on external plugins.[](https://webassembly.org/news/2025-09-17-wasm-3.0/)[](https://webassembly.org/features/)

### Data Storage

Progressive Web Apps (PWAs) rely on [client-side](/page/Client-side) storage mechanisms to manage data offline, enabling seamless user experiences without constant network connectivity. The primary [API](/page/API) for handling structured data is IndexedDB, which provides an asynchronous, low-level, transactional database system. It supports object stores for data organization, indexes for efficient querying, and transactions to ensure [data integrity](/page/Data_integrity), making it suitable for storing large datasets such as user preferences, application state, or cached content.[](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API)

For simpler storage needs, PWAs can use the Web Storage API's localStorage and sessionStorage, which offer synchronous key-value pair storage. localStorage persists data across browser sessions for the [origin](/page/Origin), while sessionStorage clears data upon tab closure. Both are limited to approximately 5 MB per [origin](/page/Origin) in most browsers, sufficient for small items like settings or temporary tokens but not for extensive datasets.[](https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API)[](https://developer.mozilla.org/en-US/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria)

To handle offline data synchronization, PWAs employ the Background Synchronization API, which allows service workers to queue changes made while offline and defer resolution until a stable network connection is available. This prevents [data loss](/page/Data_loss) by ensuring queued operations, such as uploading user edits or syncing database updates, are processed reliably in the background without user intervention. Service workers can intercept and manage these storage-related requests to facilitate the sync process.[](https://developer.mozilla.org/en-US/docs/Web/API/Background_Synchronization_API)

Browser-enforced storage quotas prevent excessive disk usage, with limits varying by implementation; for example, [Chrome](/page/Chrome) permits an origin to consume up to 60% of available disk space across storage APIs like IndexedDB. Developers can use the StorageManager API's persist() method to request user permission for persistent storage, which, if granted, exempts the [origin](/page/Origin)'s data from automatic eviction during low-disk scenarios, ensuring longevity for critical offline [data](/page/Data). Quotas can be queried via estimate() to monitor usage and avoid errors.[](https://web.dev/articles/storage-for-the-web)[](https://developer.mozilla.org/en-US/docs/Web/API/StorageManager/persist)

### Push Notifications

Push notifications in progressive web apps (PWAs) enable server-initiated re-engagement with users by delivering messages to the client even when the app is closed or not in focus. The Push API integrates with service workers to receive these messages from external push services, such as [Firebase Cloud Messaging](/page/Firebase_Cloud_Messaging), which route notifications through browser-specific endpoints while the service worker remains active in the background.[](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps/Tutorials/js13kGames/Re-engageable_Notifications_Push)[](https://www.w3.org/TR/push-api/)

Implementation begins with obtaining explicit user permission via the `Notification.requestPermission()` method, which displays a [prompt](/page/Prompt) allowing users to grant, deny, or manage access to notifications for the [origin](/page/Origin). Upon approval, the PWA subscribes to the push service, generating an endpoint URL for message delivery; push payloads are typically limited to around 4 [KB](/page/KB) in total size (varying by browser, e.g., 4 [KB](/page/KB) in [Chrome](/page/Chrome)/[Firefox](/page/Firefox) and 2 [KB](/page/KB) in [Safari](/page/Safari)), often containing [JSON](/page/JSON) data.[](https://developer.mozilla.org/en-US/docs/Web/API/Notification/requestPermission_static)[](https://web.dev/articles/push-notifications-web-push-protocol)

When a push event fires in the service worker, developers invoke `showNotification()` to render the alert, specifying options like a prominent **[title](/page/Title)**, descriptive **[body](/page/Body)** text, an associated **[icon](/page/Icon)**, and interactive **actions** (e.g., buttons for quick responses). On mobile platforms, this supports device vibration via a pattern array (e.g., `[200, 100, 200]`) and default sound playback, provided the `silent` option is not enabled, mimicking native app behavior for better engagement.[](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerRegistration/showNotification)[](https://developer.mozilla.org/en-US/docs/Web/API/Notification/Notification)

As of 2025, the Push API remains a W3C Working Draft, with implementations varying across browsers. This aligns with expanded [iOS](/page/IOS) support in [Safari](/page/Safari) 16.4+ (with limitations, such as requiring home screen installation), improving push functionality availability across major browsers and devices.[](https://www.w3.org/TR/push-api/)[](https://documentation.onesignal.com/docs/en/web-push-for-ios) For scenarios involving network interruptions, undelivered notifications can leverage [data storage](/page/Data_storage) mechanisms to [queue](/page/Queue) payloads until reconnection.[](https://www.w3.org/TR/service-workers/)

## Comparison with Native Apps

### Advantages

Progressive Web Apps (PWAs) offer significant cost efficiencies in development and maintenance compared to native applications, as they utilize a single [codebase](/page/Codebase) that functions across multiple platforms without the need for separate builds tailored to each operating system. This approach reduces development expenses by eliminating the duplication of effort required for platform-specific coding, with estimates indicating up to 50% lower costs for cross-platform projects.[](https://learn.microsoft.com/en-us/microsoft-edge/progressive-web-apps/) Additionally, updates to PWAs can be deployed instantly through server-side changes, bypassing the lengthy review and approval processes associated with app stores, which streamlines maintenance and ensures users always access the latest version without manual intervention.[](https://web.dev/learn/pwa/progressive-web-apps)

PWAs enhance discoverability and [search engine optimization](/page/Search_engine_optimization) (SEO) by being naturally indexable by search engines like [Google](/page/Google), allowing users to find and access them directly via web searches rather than navigating app stores. This eliminates delays from app store approval cycles, enabling faster market entry and broader organic reach. Studies from [Google](/page/Google) indicate that installed PWAs achieve 2.5 times higher conversion rates among users compared to non-installed mobile web experiences, reflecting improved engagement and retention.[](https://web.dev/articles/drive-business-success)

The cross-platform nature of PWAs allows them to operate on any device equipped with a modern [web browser](/page/Web_browser), from smartphones to desktops, thereby minimizing fragmentation and ensuring consistent experiences without OS-specific adaptations. This broad accessibility rivals native apps in offline functionality through service worker caching, providing reliable performance in low-connectivity scenarios without requiring platform-dependent code.[](https://learn.microsoft.com/en-us/microsoft-edge/progressive-web-apps/)

PWAs also feature a reduced storage footprint on user devices, typically occupying about one-tenth the space of equivalent native apps due to leveraging the device's shared web runtime and avoiding redundant [platform](/page/Platform) binaries. For instance, average PWA sizes hover around 2 [MB](/page/MB), in contrast to 16-50 [MB](/page/MB) for native counterparts, which facilitates quicker downloads and [installation](/page/Installation), particularly beneficial for users in regions with limited [bandwidth](/page/Bandwidth) or [storage](/page/Storage).[](https://anyforsoft.com/blog/native-app-vs-progressive-web-app/)

### Limitations

Progressive web apps (PWAs) face constraints in directly accessing device hardware compared to native applications, relying instead on user-mediated Web APIs that require explicit permissions and exhibit inconsistencies across [browser](/page/Browser) implementations. For instance, access to the camera via the MediaDevices API, GPS through the Geolocation API, and Bluetooth using the Web Bluetooth API is possible but limited to what the [browser](/page/Browser) exposes, often without the seamless, always-on integration native apps provide.[](https://web.dev/learn/pwa/progressive-web-apps)

In terms of performance, PWAs encounter ceilings relative to native apps due to the overhead of browser rendering and [JavaScript](/page/JavaScript) execution, resulting in slower startup times and higher battery drain during intensive tasks, as web technologies lack the low-level optimizations available to native code. Studies indicate that PWAs consume more energy overall than native apps, though they remain more efficient than some [hybrid](/page/Hybrid) alternatives for [UI](/page/UI) rendering.[](https://dl.acm.org/doi/10.1016/j.is.2022.102017)[](https://www.researchgate.net/publication/351487772_PWA_vs_the_Others_A_Comparative_Study_on_the_UI_Energy-Efficiency_of_Progressive_Web_Apps)

Platform dependencies further restrict PWAs, particularly on [iOS](/page/IOS), where Apple's implementation limits background execution and some notification features, although push notifications have been supported since iOS 16.4 (2023) for installed PWAs, improving engagement capabilities as of 2025.[](https://web.dev/learn/pwa/progressive-web-apps) Additionally, PWAs cannot natively integrate with app store analytics or in-app purchase systems, forgoing the monetization and user acquisition tools built into platforms like the [Apple App Store](/page/App_store).[](https://web.dev/learn/pwa/progressive-web-apps)

Security trade-offs in PWAs stem from the mandatory use of [HTTPS](/page/HTTPS), which enforces secure connections but confines operations within the browser's [sandbox](/page/Sandbox), preventing the low-level system calls and direct hardware manipulations that native code permits. This isolation enhances user [privacy by design](/page/Privacy_by_design) but limits PWAs' ability to perform advanced system-level tasks available to native applications.[](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps) While these limitations exist, the ease of web distribution can offset some deficits by enabling broader reach without [app store](/page/App_store) approvals.[](https://web.dev/learn/pwa/progressive-web-apps)

## Distribution Methods

### Web Distribution

Progressive web apps (PWAs) are hosted on standard web servers such as [Apache](/page/Apache) or [Nginx](/page/Nginx), requiring secure delivery over [HTTPS](/page/HTTPS) to ensure installability and security features like service workers function properly.[](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable) This hosting setup allows PWAs to be accessed directly via unique URLs, facilitating discovery through [search engine optimization](/page/Search_engine_optimization) (SEO) techniques identical to those used for traditional websites.[](https://web.dev/learn/pwa/progressive-web-apps) Unlike native apps confined to app stores, PWAs leverage organic [web traffic](/page/Web_traffic) and direct linking, enabling broader reach without intermediary platforms.[](https://web.dev/learn/pwa/)

On [iOS](/page/IOS), as of iOS 17.4 and subsequent updates in 2025, [Safari](/page/Safari) supports PWA installation via the Share menu, with enhanced features including push notifications and offline functionality, particularly for [EU](/page/.eu) users under the [Digital Markets Act](/page/Digital_Markets_Act).[](https://brainhub.eu/library/pwa-on-ios)[](https://www.mobiloud.com/blog/progressive-web-apps-ios)

Updates in PWAs occur automatically through service workers, which the browser checks for changes upon page reload or at regular intervals, such as every 24 hours.[](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) Caching strategies like stale-while-revalidate enable zero-downtime updates by serving cached content immediately while fetching and applying fresh versions in the background.[](https://web.dev/learn/pwa/serving) This mechanism ensures users experience seamless enhancements without manual intervention or [app store](/page/App_store) approvals.[](https://web.dev/learn/pwa/update)

PWAs integrate seamlessly with web-based analytics tools, such as [Google Analytics](/page/Google_Analytics), to monitor user engagement, page views, and behavior directly from the [browser](/page/Browser) environment. This approach provides developers with real-time insights into [web traffic](/page/Web_traffic) and interactions, bypassing app store-specific metrics and enabling [A/B testing](/page/A/B_testing) through standard web experimentation frameworks.

User [installation](/page/Installation) of PWAs is prompted by the [browser](/page/Browser) after meeting specific criteria, including [HTTPS](/page/HTTPS) serving, a valid web [app](/page/App) [manifest](/page/Manifest), and user engagement thresholds like at least one interaction and 30 seconds spent on the site in [Chrome](/page/Chrome).[](https://web.dev/articles/install-criteria) The [manifest file](/page/Manifest_file) briefly enables these browser-initiated prompts by defining [app](/page/App) metadata, allowing users to add the PWA to their home screen or desktop without visiting an [app store](/page/App_store).[](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps/Manifest)

### App Store Releases

On Android, Progressive Web Apps (PWAs) can be packaged for submission to the [Google Play](/page/Google_Play) Store using Trusted Web Activities (TWAs), which allow the PWA to run in a full-screen, Chrome-powered context without an [address bar](/page/Address_bar). Developers use the Bubblewrap command-line tool, developed by [Google](/page/Google), to wrap the PWA into an [Android Package Kit](/page/APK) (APK) file by specifying the PWA's [URL](/page/URL), app name, and icons.[](https://developers.google.com/codelabs/pwa-in-play) Verification is achieved through Digital Asset Links, a protocol that associates the APK with the PWA's domain via a [JSON](/page/JSON) file hosted on the website, enabling the full-screen mode and preventing unauthorized use.[](https://developer.android.com/develop/ui/views/layout/webapps/guide-trusted-web-activities-version2) Once packaged, the APK undergoes [Google](/page/Google)'s review process, which typically focuses on standard app policies rather than deep code inspection since the content is web-based.[](https://developer.chrome.com/docs/android/trusted-web-activity)

For iOS, Apple does not provide an official method to wrap PWAs directly into native apps for the App Store, limiting distribution primarily to users adding the PWA to their [home screen](/page/Home_screen) via [Safari](/page/Safari). However, third-party tools like PWABuilder enable developers to generate an iOS package by creating an [Xcode](/page/Xcode) project that loads the PWA within a WKWebView, producing an [IPA](/page/.ipa) file suitable for submission via [TestFlight](/page/TestFlight) or the [App Store](/page/App_store).[](https://blog.pwabuilder.com/posts/publish-your-pwa-to-the-ios-app-store/) This approach uses web view rendering and supports features like push notifications via integrations such as FCM, but lacks some native iOS capabilities like advanced background processing without additional native code, and requires the app to meet Apple's guidelines for non-repackaged [web content](/page/Web_content), often necessitating additional native elements for approval.[](https://docs.pwabuilder.com/#/builder/app-store?id=push-notifications)[](https://github.com/pwa-builder/pwabuilder-ios)

In the [Microsoft Store](/page/Microsoft_Store), PWAs are packaged as MSIX bundles without requiring code changes to the web app, leveraging tools like PWABuilder to generate the package from the PWA's [URL](/page/URL) after evaluating its readiness.[](https://learn.microsoft.com/en-us/microsoft-edge/progressive-web-apps/how-to/microsoft-store) The resulting app runs the PWA using [Microsoft](/page/Microsoft) Edge's engine, with a custom referer header to identify Store installations, and submission involves reserving an app name in the Microsoft Partner Center followed by uploading the MSIX bundle for review, which usually completes in 24-48 hours.[](https://learn.microsoft.com/en-us/microsoft-edge/progressive-web-apps/how-to/microsoft-store) While WebView2 is used for hybrid Windows apps integrating web content, pure PWAs in the Store rely on Edge for rendering to ensure consistent performance across devices.[](https://learn.microsoft.com/en-us/microsoft-edge/progressive-web-apps/how-to/microsoft-store)

Packaging PWAs for app stores offers advantages such as faster review times compared to fully native apps, often due to the reliance on established web standards, but requires compliance with store-specific policies, including mandatory [privacy](/page/Privacy) policies detailing [data collection](/page/Data_collection) practices.[](https://www.adjust.com/blog/native-app-vs-progressive-web-app/) For instance, both Apple and [Google](/page/Google) mandate clear disclosure of user data handling in app metadata.[](https://developer.apple.com/app-store/review/guidelines/) Monetization is facilitated through in-app web payments via APIs like the Payment Request API, allowing seamless transactions without store commissions in many cases, though wrapped PWAs may integrate store billing for [digital goods](/page/Digital_goods) to meet platform rules.[](https://web.dev/articles/pwas-in-app-stores) Drawbacks include potential rejection if the PWA appears as a mere [website](/page/Website) wrapper without [added value](/page/Added_value), and varying [support](/page/Support) for features like offline [access](/page/Access) across stores.[](https://brainhub.eu/library/pwa-on-ios)

## Adoption and Impact

### Notable Examples

One prominent example of a Progressive Web App (PWA) implementation is [Twitter](/page/Twitter) Lite, launched in 2017 to target users in emerging markets with limited bandwidth and device capabilities. Twitter Lite leverages service workers for caching and offline functionality, enabling near-instant loading on subsequent visits and reducing data usage by 70%. This resulted in a 30% reduction in average time-to-interactive for logged-in users and a 50% reduction in the 99th percentile latency, while engagement metrics improved significantly, including a 75% increase in tweets sent and a 65% increase in pages per session.[](https://web.dev/case-studies/twitter)

Starbucks introduced its PWA in 2017 to streamline mobile ordering, particularly in areas with unreliable connectivity. The app utilizes IndexedDB for storing menu items, previous orders, and static content, allowing users to browse menus, customize orders, and manage carts entirely offline. At just 233 KB in size—99.84% smaller than the [iOS](/page/IOS) app—this PWA doubled daily active users on [mobile web](/page/Mobile_web) and enabled desktop orders to match mobile order rates, boosting overall mobile orders and user engagement across markets.[](https://www.mixedmediaventures.com/wp-content/uploads/2018/04/Starbucks.pdf)

Pinterest rolled out its PWA in 2017 to enhance [mobile web](/page/Mobile_web) performance for visual discovery. By implementing precaching of frequently accessed routes via service workers, the PWA achieved instant loading for key pages, significantly reducing the core bundle size from 650 KB to 150 KB compared to the previous mobile site. This led to a 40% increase in time spent on the site and a 60% rise in core engagement, with user-generated ad revenue growing by 44%.[](https://medium.com/dev-channel/a-pinterest-progressive-web-app-performance-case-study-3bd6ed2e6154)

Spotify's PWA provides rich media playback across desktop and mobile web browsers, increasing monthly active users by 30% on mobile web and providing a consistent experience that drove higher adoption among users avoiding app store downloads.[](https://onilab.com/blog/20-progressive-web-apps-examples)

### Industry Trends

As of 2025, progressive web apps (PWAs) have seen substantial adoption across industries, with the global PWA market valued at USD 5.23 billion and projected to grow at a compound annual growth rate (CAGR) of 18.98%, reflecting broader integration into top websites and applications.[](https://straitsresearch.com/report/progressive-web-apps-market) This growth is evidenced by increasing use of PWA elements for enhanced user engagement, particularly in e-commerce, where implementations have driven conversion rates up to 76% higher compared to traditional sites, as reported in case studies from major platforms.[](https://radixweb.com/blog/pwa-for-ecommerce) Economic analyses highlight PWAs' role in reducing cross-platform development costs by 30-50% relative to native apps, enabling faster deployment with a single codebase while maintaining compatibility across devices.[](https://saventech.com/progressive-web-apps-vs-native-apps-who-wins-in-2025/)

In emerging markets, PWAs have accelerated growth due to their low-data consumption, which addresses [connectivity](/page/Connectivity) challenges and supports offline functionality, thereby expanding access in regions with limited [bandwidth](/page/Bandwidth).[](https://www.thinkwithgoogle.com/marketing-strategies/app-and-mobile/progressive-web-apps-benefit-brands/) Looking ahead, 2025 marks an explosion in PWA advancements through [AI](/page/Ai) integrations, such as on-device [machine learning](/page/Machine_learning) for personalized experiences and real-time analytics, positioning them as a [cornerstone](/page/Cornerstone) of hybrid web-mobile ecosystems.[](https://www.stackfiltered.com/blog/the_future_of_ai_driven_pwas_what_to_expect_in_2025_and_beyond) Market projections indicate the PWA sector will reach USD 9.4 billion by 2030, underscoring their potential to capture a growing portion of the mobile application landscape amid rising demand for efficient, scalable solutions.[](https://colaninfotech.com/blog/progressive-web-app-pwa-market-trends-2025/)

PWAs also address key challenges in [accessibility](/page/Accessibility) and [sustainability](/page/Sustainability), inherently supporting [Web Content Accessibility Guidelines](/page/Web_Content_Accessibility_Guidelines) (WCAG) compliance through web standards that ensure equitable user experiences for people with disabilities.[](https://gtcsys.com/faq/are-progressive-web-apps-compliant-with-accessibility-standards-e-g-wcag/) Additionally, their smaller download sizes and optimized resource use contribute to a lower [carbon footprint](/page/Carbon_footprint) compared to native apps, promoting energy-efficient digital practices that reduce environmental impact from data transfers and device [energy consumption](/page/Energy_consumption).[](https://greensoftware.foundation/articles/creating-green-energy-efficient-progressive-web-apps/)

References

  1. [1]
    Progressive web apps - MDN Web Docs - Mozilla
    Aug 25, 2025 · A progressive web app (PWA) is an app that's built using web platform technologies, but that provides a user experience like that of a platform-specific app.In this article · Installing and uninstalling web... · Progressive loading · Guides
  2. [2]
    What are Progressive Web Apps? - web.dev
    Jan 6, 2020 · Progressive Web Apps (PWA) are web apps built and enhanced with modern APIs to provide enhanced capabilities while still reaching any web user on any device ...
  3. [3]
    What is a progressive web app? - MDN Web Docs - Mozilla
    Jun 23, 2025 · A progressive web app (PWA) is an app that's built using web platform technologies, but that provides a user experience like that of a platform-specific app.
  4. [4]
    What makes a good Progressive Web App? - web.dev
    Sep 19, 2024 · Progressive Web Apps (PWA) are built and enhanced with modern APIs to deliver enhanced capabilities, reliability, and installability while reaching anyone, ...Works In Any Browser · Responsive To Any Screen... · Provides An Offline...
  5. [5]
    Best practices for PWAs - Progressive web apps | MDN
    Jun 30, 2025 · Best practices for PWAs. Progressive Web Apps (PWAs) can be installed on devices and used as traditional websites in web browsers.
  6. [6]
    Web application manifest - Progressive web apps - MDN Web Docs
    Aug 8, 2025 · A web application manifest, defined in the Web Application Manifest specification, is a JSON text file that provides information about a web application.Display · Icons · Background_color · Start_url<|control11|><|separator|>
  7. [7]
    Making PWAs installable - Progressive web apps | MDN
    Jun 30, 2025 · Making PWAs installable. One of the defining aspects of a PWA is that it can be promoted by the browser for installation on the device.
  8. [8]
    Celebrate Chrome 100 with #100CoolWebMoments | Blog
    Mar 29, 2022 · Chrome was at version 43 when Alex Russell and Frances Berriman introduced Progressive Web Apps in 2015, with Microsoft announcing Edge as ...<|control11|><|separator|>
  9. [9]
    A beginner's guide to using the application cache | Articles - web.dev
    Jun 18, 2010 · Some browsers place restrictions on the amount of storage quota available to your app. In Chrome for example, AppCache uses a shared pool of ...Introduction · The cache manifest file · Updating the cache · Cache status
  10. [10]
    Application Cache is a Douchebag - A List Apart
    May 8, 2012 · They offer a limited amount of data, but you can use that data in multiple ways, or create your own data. This is the case Application Cache was ...Offlining A ``do Stuff''... · Using Localstorage For... · Page Not AvailableMissing: MDN | Show results with:MDN<|control11|><|separator|>
  11. [11]
    Uses Application Cache | Lighthouse - Chrome for Developers
    May 2, 2019 · Learn how to migrate your web page from the deprecated Application Cache to the Cache API.
  12. [12]
    Responsive Web Design - A List Apart
    May 25, 2010 · Fluid grids, flexible images, and media queries are the three technical ingredients for responsive web design, but it also requires a different way of thinking.
  13. [13]
    Mobile First - LukeW
    Nov 3, 2009 · Building mobile first ensures companies have an experience available to this extremely fast growing user base widely considered to be the next big computing ...
  14. [14]
    Introducing the Accelerated Mobile Pages Project, for a faster, open ...
    Oct 7, 2015 · We're announcing a new open source initiative called Accelerated Mobile Pages, which aims to dramatically improve the performance of the mobile web.
  15. [15]
    How AMP works - amp.dev
    AMP pages allow third-party JavaScript but only in sandboxed iframes. By restricting them to iframes, they can't block the execution of the main page.
  16. [16]
    Progressive Web Apps: Escaping Tabs Without Losing Our Soul
    Jun 15, 2015 · Alex Russell on browsers, standards, and the process of progress. ... Progressive Web App installation flow for Chrome Dev Summit. Here's ...Missing: coins Google
  17. [17]
    Getting started with Progressive Web Apps | Blog
    Dec 15, 2015 · In this post, I'll summarize some options and reference apps for getting started with your own progressive web app today.Missing: initial | Show results with:initial
  18. [18]
    Twitter Lite PWA Significantly Increases Engagement and Reduces ...
    May 17, 2017 · Twitter Lite users benefit from data consumption savings; the PWA is only 600KB over the wire vs. 23.5MB of downloaded data needed to install ...
  19. [19]
    Top 10 progressive web apps in the news industry - Cloudflight
    Nov 13, 2018 · Readers can also save stories in Flipboard magazines. Thanks to its PWA, users will be able to view previously saved offline content, among ...
  20. [20]
    Service Workers - W3C
    Mar 6, 2025 · This document was published by the Web Applications Working Group as a Candidate Recommendation Draft using the Recommendation track. Feedback ...
  21. [21]
    Web Incubator Community Group (WICG)
    The WICG is a place for experimentation and discussion of new web platform features. The WICG is not a standards body, but rather a forum for discussion and ...
  22. [22]
    PWA on iOS - Current Status & Limitations for Users [2025] - Brainhub
    Jun 5, 2025 · With the release of iOS 16.4, Apple introduced support for push notifications in PWAs, allowing developers to send real-time alerts to users.
  23. [23]
    Apple PWA: What iOS 18.1 Means for Progressive Web Apps - 5MS
    With these changes, PWAs on iOS offer richer functionality, improved speed, and a closer-to-native experience. Key Features of iOS 18.1 PWA ...
  24. [24]
    Web Neural Network API - W3C
    Oct 31, 2025 · The Web Neural Network API defines a web-friendly hardware-agnostic abstraction layer that makes use of Machine Learning capabilities of operating systems.Missing: PWAs | Show results with:PWAs
  25. [25]
    Web Bluetooth API - Web APIs | MDN
    ### Summary: How Web Bluetooth API Enables IoT Connectivity in PWAs
  26. [26]
    WebUSB API - Web APIs | MDN
    ### Summary: How WebUSB API Enables Connectivity to Smart Devices in PWAs
  27. [27]
    What's new for web on Android 2023 | Blog - Chrome for Developers
    May 10, 2023 · Another way to bring the web to Android is using Trusted Web Activity (TWA). TWA is the best way to display full screen first-party web content ...
  28. [28]
    PWA vs Native: Which Approach to Choose in 2025? - Brainhub
    Apr 7, 2025 · PWAs promise fast, easy and affordable app building. But are they as good as native apps? Compare: PWA vs native and choose well.
  29. [29]
    Getting started with Progressive Web Apps | Blog
    Dec 15, 2015 · Progressive Web Apps use modern web capabilities to deliver app-like experiences, combining the best of web and apps, and are useful from the ...
  30. [30]
    Progressive web applications (PWAs) - Glossary - MDN Web Docs
    Jul 18, 2025 · Progressive web applications (PWAs) are applications that are built using web platform technologies, but that provide a user experience like that of a platform ...
  31. [31]
    Progressive Web Apps - web.dev
    Sep 20, 2024 · A Progressive Web App (PWA) is a web app that uses progressive enhancement to provide users with a more reliable experience.Missing: key | Show results with:key
  32. [32]
    Foundations | web.dev
    Nov 3, 2021 · All Progressive Web Apps are, at their core, modern websites, so it's important that your website has a solid foundation in responsive ...Responsive Web Design · Web Performance · Core Web Vitals
  33. [33]
    Offline and background operation - Progressive web apps | MDN
    Jun 23, 2025 · Progressive web apps · Guides · Offline and background operation ... The Periodic Background Sync API requires the "periodic-background-sync ...Offline operation · Background sync · Background fetch · Periodic background sync
  34. [34]
    Web Application Manifest - W3C
    Sep 3, 2025 · This specification defines a JSON-based file format that provides developers with a centralized place to put metadata associated with a web application.
  35. [35]
    Add a web app manifest | Articles - web.dev
    Sep 18, 2024 · A web app manifest is a JSON file that tells the browser how your Progressive Web App (PWA) should behave when installed on the user's desktop or mobile device.
  36. [36]
    Safari 15.4 Release Notes | Apple Developer Documentation
    Mar 14, 2022 · Added support for Web App Manifest icons, shown when no apple-touch-icon is provided and when either "purpose": "any" is present or the "purpose ...
  37. [37]
    Service Worker API - MDN Web Docs
    Aug 19, 2025 · Service workers essentially act as proxy servers that sit between web applications, the browser, and the network (when available).Using Service Workers · ServiceWorker · Register() method · FetchEvent
  38. [38]
    Using Service Workers - Web APIs | MDN
    Oct 30, 2025 · Using a service worker you can set an app up to use cached assets first, thus providing a default experience even when offline, before then ...ServiceWorkerContainer · Install event · Fetch eventMissing: reliability inconsistencies
  39. [39]
    Service workers | web.dev
    Dec 3, 2021 · Service workers are middleware proxies that intercept requests, even offline, and can serve resources from cache, network, or local algorithms.Verify Whether A Service... · Scope · Lifecycle
  40. [40]
    Service worker overview | Workbox - Chrome for Developers
    Sep 24, 2021 · Service workers are specialized JavaScript assets acting as proxies between browsers and servers, improving reliability and page performance.A Progressively Enhancing... · Access To A... · An Asynchronous And...
  41. [41]
    "web-app-manifest" | Can I use... Support tables for HTML5, CSS3, etc
    The Web App Manifest provides a centralized place to put metadata associated with a web application. As it has numerous fields (members) used for a variety of ...Missing: history | Show results with:history
  42. [42]
    Push API | Can I use... Support tables for HTML5, CSS3, etc
    ### Summary of Push API Browser Support (Late 2025)
  43. [43]
    [Experimental] Firefox now supports Progressive Web Apps on ...
    Aug 22, 2025 · Mozilla has announced that Firefox users can now use progressive web apps (PWAs). However, the feature is currently only supported on Windows.
  44. [44]
    Installing and uninstalling web apps - Progressive web apps | MDN
    May 5, 2025 · This guide covers how users can install and uninstall PWAs on their devices. If you want to learn about making a web app installable as a PWA, see Making PWAs ...Missing: origin | Show results with:origin
  45. [45]
    Overview of Progressive Web Apps (PWAs) - Microsoft Learn
    Oct 1, 2025 · Progressive Web Apps (PWAs) are built using HTML, CSS, and JavaScript code that's hosted on web servers and that runs in web browser engines.Get started developing a PWA · Use · Publish a PWA to the Microsoft...Missing: origin history credible<|separator|>
  46. [46]
    What's New in PWAs - Microsoft Edge Developer documentation
    Jun 25, 2025 · Microsoft Edge 108 introduces experimental support for Progressive Web Apps to define their own widgets in the Widgets Board in Windows 11.
  47. [47]
    Bring your PWA closer to users with App Actions on Windows
    May 30, 2025 · App Actions on Windows are now available for Progressive Web Apps (PWAs). Starting with Edge version 137, you can now publish your PWA to the Microsoft Store.
  48. [48]
    Progressive Web Applications (PWA) in Brave
    In Brave, you can create a web app for any site via the Main menu, but this feature is not available on iOS.
  49. [49]
    Background Sync API | Can I use... Support tables for HTML5, CSS3 ...
    Background Sync API - UNOFF Provides one-off and periodic synchronization for Service Workers with an onsync event.
  50. [50]
    Sending web push notifications in web apps and browsers
    Update your web server and website to send push notifications that work in Safari, other browsers, and web apps, following cross-browser standards.
  51. [51]
    Display a badge on the app icon - Progressive web apps | MDN
    Jun 30, 2025 · Badges are supported in Safari on iOS and iPadOS, starting with iPadOS 16.4. The badging API is not supported on Chromium-based browsers running ...
  52. [52]
    WebAssembly
    WebAssembly (abbreviated Wasm) is a binary instruction format for a stack-based virtual machine. Wasm is designed as a portable compilation target for ...Getting Started · Docs · Web Embedding · Specs
  53. [53]
    WebAssembly | MDN
    ### Summary of WebAssembly from MDN
  54. [54]
    Photoshop's journey to the web | Articles - web.dev
    Oct 26, 2021 · Photoshop came to the web using WebAssembly and Emscripten, leveraging existing code, and overcoming past limitations of JavaScript and lack of ...Missing: PWA | Show results with:PWA
  55. [55]
    Security - WebAssembly
    The design of WebAssembly promotes safe programs by eliminating dangerous features from its execution semantics, while maintaining compatibility with programs ...
  56. [56]
    WebAssembly | 2021 | The Web Almanac by HTTP Archive
    Dec 1, 2021 · We've decided to recompress all those WebAssembly files with Brotli (compression level 9) to figure it out. ... On the official feature ...
  57. [57]
    Wasm 3.0 Completed - WebAssembly
    Sep 17, 2025 · Staying true to the spirit of Wasm as a low-level language, Wasm GC is low-level as well: a compiler targeting Wasm can declare the memory ...<|control11|><|separator|>
  58. [58]
    IndexedDB API - MDN Web Docs
    Apr 3, 2025 · IndexedDB is a low-level, JavaScript-based, transactional API for client-side storage of structured data, using indexes for high-performance ...Using IndexedDB · IndexedDB key characteristics... · Storage quotas and eviction...
  59. [59]
    Web Storage API - MDN Web Docs - Mozilla
    Feb 22, 2025 · Both sessionStorage and localStorage in Web Storage are synchronous in nature. This means that when data is set, retrieved, or removed from ...Missing: PWAs | Show results with:PWAs
  60. [60]
    Storage quotas and eviction criteria - Web APIs - MDN Web Docs
    Aug 20, 2025 · Browsers can store up to 5 MiB of local storage, and 5 MiB of session storage per origin. Once this limit is reached, browsers throw a ...Origin private file system · StorageManager: persist · StorageManager.estimate()Missing: PWAs | Show results with:PWAs
  61. [61]
    Background Synchronization API - MDN Web Docs
    Apr 22, 2024 · The Background Synchronization API allows web applications to defer server synchronization work to their service worker to handle at a later time, if the ...Missing: PWA 2023-2025
  62. [62]
    Storage for the web | Articles - web.dev
    Sep 23, 2024 · How much can I store? · Chrome allows the browser to use up to 80% of total disk space. An origin can use up to 60% of the total disk space.
  63. [63]
    StorageManager: persist() method - Web APIs | MDN
    Jul 26, 2024 · The persist() method of the StorageManager interface requests permission to use persistent storage, and returns a Promise that resolves to true if permission ...Missing: PWAs | Show results with:PWAs
  64. [64]
    Make PWAs re-engageable using Notifications and Push APIs
    Sep 20, 2025 · The Push API and Notifications API are two separate APIs, but they work well together when you want to provide engaging functionality in your ...
  65. [65]
    Push API - W3C
    Sep 25, 2025 · The Push API enables sending of a push message to a web application via a push service. An application server can send a push message at any time.
  66. [66]
    Notification: requestPermission() static method - Web APIs | MDN
    Jun 11, 2025 · The requestPermission() static method of the Notification interface requests permission from the user for the current origin to display notifications.Syntax · Examples<|separator|>
  67. [67]
    The Web Push Protocol | Articles - web.dev
    Sep 20, 2024 · The minimum size payload a push service must support is 4096 bytes (or 4kb). You can also read the Web Push standard (RFC8030) for more ...
  68. [68]
    ServiceWorkerRegistration: showNotification() method - Web APIs
    Sep 24, 2025 · The showNotification() method of the ServiceWorkerRegistration interface creates a notification on an active service worker.
  69. [69]
    Notification: Notification() constructor - Web APIs | MDN
    ### Notification Constructor Options Summary
  70. [70]
    iOS web push setup - OneSignal Documentation
    iOS web push setup · Cross-Browser Support: Web push notifications now work across all major browsers on iOS/iPadOS 16.4+ including Safari, Chrome, and Edge.Missing: endpoint unification
  71. [71]
    How Progressive Web Apps can drive business success | Articles
    May 20, 2020 · Installed users had a 2.5 times higher conversion rate. Installation is a great way to encourage people return to your site and improve your ...
  72. [72]
    PWA vs Native Apps: A Head-to-Head Comparison - AnyforSoft
    Jan 29, 2024 · #2 Storage. The average size of a progressive web application is about 2 Mb, whereas an average native takes up about 16 Mb of space. Of course, ...Pwa Vs Native App... · Pwa Vs Native Mobile App... · Pwa Vs Native Solutions...
  73. [73]
    A comparative study on the energy consumption of Progressive Web ...
    Native development shows the lowest energy consumption. PWAs, albeit having a higher energy consumption than native apps, are a viable alternative to other ...
  74. [74]
    A Comparative Study on the UI Energy-Efficiency of Progressive ...
    Aug 7, 2025 · The aim of this study is to analyze the difference in energy consumption of PWAs and other mobile development approaches with a focus on UI rendering and ...
  75. [75]
    Learn PWA  |  web.dev
    ### Summary of PWA Hosting, Distribution, Discovery, Updates, Analytics, and Installation Prompts
  76. [76]
    Serving | web.dev
    Jan 10, 2022 · A key aspects of Progressive Web Apps is that they're reliable; they can load assets quickly, keeping users engaged and providing feedback ...Responding To A Request · Caching Strategies · Stale While Revalidate<|separator|>
  77. [77]
    Update - web.dev
    Mar 10, 2022 · Synchronize and update a PWA in the Background · Richer offline experiences with the Periodic Background Sync API · Push API · Push ...
  78. [78]
    What does it take to be installable? | web.dev
    Sep 19, 2024 · In Chrome, your Progressive Web App must meet the following criteria before it will fire the beforeinstallprompt event and show the in-browser ...
  79. [79]
    Adding Your Progressive Web App to Google Play
    Sep 18, 2024 · In this lab, you'll take an existing Progressive Web App that you have deployed and wrap it in an app for distribution in Google's Play store.1. Welcome · What You'll Learn · What You'll NeedMissing: 2023 | Show results with:2023
  80. [80]
    Trusted Web Activities Quick Start Guide | Views - Android Developers
    Nov 12, 2024 · When you launch a Trusted Web Activity, the browser will check that the Digital Asset Links check out, this is called verification. If ...
  81. [81]
    Overview | Web on Android - Chrome for Developers
    Feb 4, 2020 · Trusted Web Activity is a new way to open your web-app content such as your Progressive Web App (PWA) from your Android app using a protocol based on Custom ...
  82. [82]
    Publish your PWA to the iOS App Store | PWA Builder Blog
    Feb 21, 2024 · Announcing PWABuilder's new iOS platform. Publish your PWA to the App Store and gain new iPhone and iPad users.
  83. [83]
    pwa-builder/pwabuilder-ios-app-store: iOS platform for ... - GitHub
    Sep 11, 2025 · This is PWABuilder's iOS platform that generates an iOS app that loads your PWA in a WKWebView. The platform generates a zip file containing an Xcode project.<|separator|>
  84. [84]
    Publish a PWA to the Microsoft Store
    Sep 19, 2025 · To publish your PWA to the Microsoft Store, no code changes are required. Instead, you create an app reservation in Microsoft Partner Center, package your PWA ...Missing: WebView2 | Show results with:WebView2
  85. [85]
    PWAs vs. native apps – Explore the pros and cons | Adjust
    Nov 18, 2022 · Compared to native apps, PWAs use up much less storage space on a user's device. Google describes this app type as “reliable, fast, and ...
  86. [86]
    App Review Guidelines - Apple Developer
    You must comply with applicable privacy laws around the world relating to the collection of data from children online. Be sure to review the Privacy section ...App Store Improvements · Alternative app marketplace · Promoted In-App PurchasesMissing: PWA | Show results with:PWA
  87. [87]
    PWAs in app stores | web.dev
    Mar 31, 2023 · PWABuilder is a powerful tool that allows developers to create packages that can be submitted to various app stores.
  88. [88]
    [PDF] CASE STUDY: STARBUCKS PROGRESSIVE WEB APP
    In order to create the offline functionality for the PWA, complex caching had to be set up to download the information for each menu item, store information on ...
  89. [89]
    A Pinterest Progressive Web App Performance Case Study - Medium
    Nov 29, 2017 · Time spent is up by 40% compared to the old mobile web experience ... Next, Pinterest started precaching a few of the most used routes ...
  90. [90]
    20+ the Best Progressive Web App (PWA) Examples in 2024 - Onilab
    Sep 11, 2024 · Pinterest. 40% increase in time spent on the progressive app compared to the mobile website;; 60% raise in core user engagement; ...
  91. [91]
    Progressive Web Apps Market Size & Outlook, 2025-2033
    This personalized approach has led to a 70% increase in conversions. Similarly, Starbucks' PWA integrates AI to offer customized menu recommendations, enhancing ...Missing: credible | Show results with:credible
  92. [92]
    Why PWAs Are Key to eCommerce Success - Radixweb
    Dec 1, 2024 · Google Analytics Data shows over 50% of web traffic comes from mobile devices. ... The conversion rate increased to 76% after Alibaba adopted PWA.
  93. [93]
    Progressive Web Apps vs Native Apps: Who Wins in 2025?
    For example, a Native App can achieve 60 FPS rendering consistently, while PWAs may struggle on low-end devices. – Winner: Native Apps, for superior performance ...Missing: mid- | Show results with:mid-
  94. [94]
    A Progressive Web App Might Be Right for Your Brand
    PWAs were introduced in 2015. Because they use less data than a regular mobile app, they first took off in emerging markets that suffer from poor internet ...
  95. [95]
    The Future of AI-Driven PWAs: What to Expect in 2025 and Beyond
    Oct 10, 2025 · In 2025, AI-driven PWAs are expected to deliver hyper-personalized experiences by leveraging advanced algorithms to analyze user behavior in real-time.
  96. [96]
    Progressive Web App (PWA) Market Trends (2025) - Colan Infotech
    Nov 14, 2024 · By 2025, the PWA market is expected to be valued at $2.8 billion, growing at 31.1% CAGR, with a projected $9.4 billion by 2030. PWAs are ...2 According To Expectations... · Application Development... · Key Ai Software Development...<|separator|>
  97. [97]
    Are Progressive Web Apps compliant with accessibility standards ...
    Yes, Progressive Web Apps (PWAs) are compliant with accessibility standards, including WCAG. PWAs are built using web technologies, which inherently support ...
  98. [98]
    Creating Green, Energy Efficient, Progressive Web Apps | GSF
    Aug 12, 2021 · Progressive Web Apps (PWAs) are closer than ever to so-called native applications, can they also offer solutions to be more energy efficient?