Quick Answer: What is a pwa?
A Progressive Web App (PWA) is an application built with standard web technologies that behaves much like a native app. It can be installed on a device, launched from a home screen or start menu, and keep working when the network drops. You meet PWAs through a browser tab, an install prompt, or an app store listing.
PWAs differ from ordinary websites because they add an installable shell, offline caching, and deeper operating system integration. They also differ from fully native apps because one codebase serves every platform instead of separate builds for each device type.
Before committing to the approach, weigh installability, offline behavior, browser support, store distribution, update flow, and long-term maintenance cost.
A user taps an icon on a phone home screen. The app opens in its own window, loads instantly, and keeps working in a subway tunnel with no signal. Nothing about that experience feels like a website, yet the whole thing was built with HTML, CSS, and JavaScript. That is the quiet magic of the Progressive Web App, and it has reshaped how teams think about shipping software. This guide explains what a PWA actually is, how it works under the hood, where it fits compared with native apps and plain websites, and the practical mistakes that trip up first-time builders.
The Core Idea Behind Progressive Web Apps

A PWA starts life as a normal website. It runs on the open web, lives at a URL, and is reachable by anyone with a browser. What makes it “progressive” is a set of enhancements layered on top: a manifest file that describes the app’s name and icons, a service worker that caches assets and intercepts network requests, and a secure HTTPS connection. Together these turn a page into something the operating system treats as a first-class application.
Microsoft’s Edge documentation describes PWAs as applications built with web technologies that can be installed and run on all devices from one codebase, delivering native-like experiences on supporting devices while still running in a browser like a website. That dual identity is the heart of the concept. The same product can be a link someone clicks and an icon someone installs.
The term itself signals intent. These apps are meant to be reliable even on flaky connections, installable on launch surfaces like a Mac Applications folder, a Windows Start menu, or an Android and iOS home screen, and re-engageable through notifications and other hooks. Chrome’s developer documentation frames PWAs exactly this way: modern, high-quality applications built with web technology that offer capabilities similar to iOS, Android, and desktop apps.
How a PWA Actually Works
Underneath the marketing language, a PWA is a small set of technical ingredients working together.
The Web App Manifest
The manifest is a JSON file that tells the browser how the app should appear and behave once installed. It supplies the app name, short name, icon set, theme colors, start URL, and display mode. When display mode is set to standalone, the installed app opens without browser chrome, looking and feeling like a dedicated program. Without a manifest, a site can still be saved to a home screen, but it will look like a bookmark rather than an app.
The Service Worker
The service worker is a script that runs separately from the page and acts as a programmable network proxy. It can cache files ahead of time, serve them when the network fails, and manage background tasks. This is what makes offline mode possible. A well-built service worker means the app shell loads instantly on repeat visits because it comes from local storage rather than a server round trip.
Installability and the App Lifecycle
Installability is a defining trait. The W3C’s roadmap for web applications on mobile ties the PWA experience directly to the application lifecycle: how apps get installed, appear in application lists, start, stop, wake from remote notifications, and sync when the device reconnects. These lifecycle moments are what separate an app from a page. A PWA can register for a file type, launch at sign-in, and appear in activity switchers and device search.
PWA vs. Native App vs. Regular Website
The fastest way to understand PWAs is to see them beside the alternatives.
| Feature | Regular Website | Native App | Progressive Web App |
|---|---|---|---|
| Installation | Not installable (bookmark only) | Via app store | Via browser prompt or app store |
| Offline support | None by default | Full | Yes, via service worker caching |
| Codebase | One web codebase | Separate per platform | One web codebase |
| Updates | Instant on reload | Store review and download | Instant, served from the web |
| Device integration | Limited | Deep | Growing, with some limits |
| Distribution | Any URL | App stores | URL plus store listings |
The trade-offs are real. Native apps still reach deeper into hardware and platform APIs. Websites remain the most frictionless way to reach someone. PWAs sit in the middle, borrowing reach from the web and capability from native software.
A UK government technology blog made the economic case plainly: PWAs offer a user experience on a handset that is almost identical to a native application, but with a single codebase that works like a normal website. For public services, that means not maintaining several versions of the same application, which keeps development costs down.
Where You Encounter PWAs in the Real World
PWAs are not a niche experiment. They show up in places people rarely notice.
Microsoft has treated PWAs as first-class citizens on Windows. In a 2018 announcement, the company explained that PWAs should be discoverable everywhere apps are discoverable, including the Microsoft Store, and that PWAs installed through the Store would be packaged and run in their own sandboxed container. The same post emphasized that in the browser context, all the benefits of being a PWA should still accrue to the website, letting users choose how and where they engage.
That dual-path philosophy matters. A PWA can be discovered through search, shared as a link, or found in a store alongside native apps. Users get to decide whether they want a quick visit or a permanent install.
Government services, news publishers, e-commerce storefronts, and internal business tools have all adopted the model. The common thread is a need to reach many devices without building and maintaining separate native codebases.
What PWAs Can and Cannot Do
Honest expectations save projects. Here is the practical split.
What works well:
- Fast repeat loads through cached app shells
- Offline reading, forms, and basic interactions
- Home screen and desktop installation with custom icons
- Push notifications for re-engagement
- Store distribution on platforms that accept PWAs
- A single codebase across desktop and mobile
Where limits appear:
- Access to some hardware sensors and background processes is narrower than native
- Browser and platform support varies, so features must be tested per device
- iOS support has historically lagged behind Android, though it continues to improve
- Heavy 3D, advanced camera pipelines, and deep system hooks may still demand native code
A useful rule of thumb: if the core value of the product can be delivered through a screen, a network connection, and a bit of local storage, a PWA is a strong candidate. If it depends on tight hardware control, native remains the safer bet.
Common Mistakes That Undermine a PWA
Practical experience shows the same errors repeating across teams new to the model.
Treating the manifest as an afterthought. A missing or malformed manifest produces a broken install experience, wrong icons, or no install prompt at all. Build it early and test it on real devices.
Caching everything blindly. A service worker that caches too aggressively serves stale content and confuses users. Version your caches and define clear update strategies.
Ignoring the offline experience. Users judge the app the moment the network fails. If the offline state shows a raw browser error, the illusion of an app collapses. Design a meaningful offline screen.
Skipping device testing. Emulators hide install quirks. Test the install flow on an actual Android phone, an iPhone, and a desktop browser.
Assuming installability is automatic. Browsers apply criteria before offering installation. Verify the app meets them rather than hoping the prompt appears.
Forgetting updates. Because PWAs update silently, users can run old code without knowing. A visible refresh prompt solves most of this friction.
How to Evaluate Whether a PWA Fits Your Project
A short checklist helps teams decide before writing code.
- Define the core job. Write one sentence describing what the app must do. If it needs no exotic hardware, a PWA likely covers it.
- Map the offline need. Decide which screens must work without a network. That list drives your caching strategy.
- Check target platforms. Confirm install and feature support on every browser and device your audience actually uses.
- Plan distribution. Decide whether a URL alone is enough or whether store listings matter for discovery.
- Budget for testing. Allocate time for real-device install tests, update flows, and offline scenarios.
- Plan the update path. Choose how users learn about new versions and how caches get invalidated.
Running this checklist early prevents the most expensive surprise: discovering halfway through that a required capability is not available where your users live.
The Bottom Line on Progressive Web Apps
A PWA is best understood as a website that grew up. It keeps the web’s reach and instant updates, then adds installation, offline resilience, and operating system presence. Microsoft’s platform work, the W3C’s lifecycle model, and real deployments across public services all point in the same direction: the line between website and app keeps thinning.
The model is not a universal replacement for native software, and it is not a magic upgrade you bolt on at the end. It rewards teams that plan the manifest, the service worker, the offline experience, and the update flow from day one. For many products, that planning pays off with one codebase, faster releases, and users who get an app-like experience without ever visiting an app store.
Frequently Asked Questions
Do PWAs work on iPhones?
Yes, with caveats. PWAs can be installed to the iOS home screen and run in a standalone window, but some capabilities arrive later or behave differently than on Android. Test the specific features you depend on, especially notifications and background behavior, on actual iOS devices before committing.
Do users have to visit an app store to install a PWA?
No. Installation usually happens through the browser, often via an install prompt or a menu option. PWAs can also be listed in stores that accept them, such as the Microsoft Store, which gives users a choice between a quick web visit and a store-based install.
Are PWAs faster than native apps?
Not inherently. Speed depends on caching, asset size, and network conditions. A well-built PWA with a cached app shell often loads faster on repeat visits than a native app cold-starts, but heavy native apps optimized for the device can outperform a poorly built PWA. Performance is an engineering outcome, not a category guarantee.
Can a PWA work completely offline?
It can work offline for whatever has been cached. A service worker stores the app shell and chosen assets, so previously visited screens and stored data remain available. Anything requiring a live server call, such as fresh content or a payment authorization, still needs a connection.
Is a PWA the same thing as a responsive website?
No. A responsive website adapts its layout to screen size, which is one ingredient of a good PWA. A PWA goes further by adding a manifest, a service worker, installability, and offline behavior. Every PWA should be responsive, but not every responsive site is a PWA.
How much does it cost to build a PWA compared with native apps?
Costs vary by scope, but the structural advantage is a single codebase instead of separate ones per platform. Public-sector teams have cited lower development cost as a major reason for choosing the model, since they avoid maintaining multiple versions of the same application. Ongoing maintenance also tends to be simpler because updates ship through the web.


