What a progressive web app is
A progressive web app (PWA) is a website that behaves like an app. Users can install it on their home screen, open it full-screen, use it offline or on poor connections and receive push notifications — all from a single web codebase, without going through an app store.
PWAs are ideal when reach and speed matter more than deep device integration: customer portals, field tools, booking apps, internal dashboards and content experiences.
Problems we solve
- Users unwilling to download an app for occasional use
- Field staff working with poor or no connectivity
- Budget for one codebase rather than web plus two native apps
- App store fees or review delays for simple apps
- A mobile website that feels slow and clunky
What’s included
Installable experience
Web app manifest, icons and full-screen display.
Offline support
Service workers that cache the app and data for offline use.
Background sync
Actions taken offline sync automatically when back online.
Push notifications
Web push on Android, desktop and iOS (from iOS 16.4, for installed web apps).
Performance
Fast loading on slow networks and low-end devices.
App store packaging
Optional listing in Google Play and Microsoft Store.
PWA or native app?
| PWA | Native / cross-platform app | |
|---|---|---|
| Distribution | Link or search; optional store listing | App stores |
| Cost | One web codebase | Higher; separate builds |
| Offline & notifications | Yes, with some iOS limits | Full |
| Device features | Camera, location, basic sensors | Full access, including Bluetooth and background tasks |
| Discoverability | Indexed by search engines | Store search |
Designing for offline
Offline support is more than caching pages. We decide which data each user needs offline, store it securely on the device, let users keep working, queue their changes and resolve conflicts when they reconnect. Clear indicators show what is saved locally and what has synced, so users trust the app in the field.
What PWAs can and cannot do today
| Capability | Support (typical) |
|---|---|
| Install to home screen | Android and desktop browsers widely; iOS via Share → Add to Home Screen |
| Offline use with service workers | All modern browsers |
| Push notifications | Android and desktop; iOS for installed web apps on recent versions |
| Camera, geolocation, file access | Widely supported with permission |
| Bluetooth, NFC, background sync | Mainly Chromium-based browsers |
| App store presence | Possible via wrappers (e.g. Trusted Web Activity on Google Play) |
Browser support changes frequently; we check current support during discovery.
PWA launch checklist
- Valid web app manifest with icons, name, colours and start URL
- Service worker with a clear caching strategy per resource type
- Offline fallback page and graceful handling of failed requests
- HTTPS everywhere
- Fast first load on mid-range phones and slow networks
- Update flow that tells users when a new version is available
- Install prompt shown at a helpful moment, not on first visit
- Analytics for installs and offline usage
Caching strategy deserves particular care: cache static assets aggressively, but make sure users never get stuck on stale data or an old version of the app.
Turning a website into a PWA step by step
-
Measure
Audit performance and mobile usability; a slow site will make a slow PWA.
-
Add the manifest
Name, icons and display mode so the site can be installed.
-
Cache the shell
Use a service worker to cache static assets for instant repeat loads.
-
Handle offline
Offer an offline page first, then offline support for the most useful content and actions.
-
Re-engage
Add push notifications only where users clearly benefit from them.
How the building blocks fit together
| Component | What it does | Practical notes |
|---|---|---|
| Web app manifest | Name, icons, colours and display mode for installation | Needed for “Add to Home Screen” and app-like launch |
| Service worker | Intercepts network requests; enables caching and offline use | Requires HTTPS; versioning is critical to avoid stale code |
| Cache storage & IndexedDB | Store app shell, assets and user data locally | Plan storage limits and clean-up |
| Push API & notifications | Re-engage users with messages | Supported on iOS for installed web apps since iOS 16.4 |
| Background sync | Send queued changes when the connection returns | Support varies by browser; provide a fallback |
Caching strategies explained
Choosing the right caching strategy per type of request is what makes a PWA feel fast and reliable without showing out-of-date information.
- Cache first — for versioned assets such as scripts, styles and icons that rarely change.
- Network first — for data that must be fresh, falling back to cache when offline.
- Stale while revalidate — show cached content instantly and refresh it in the background; ideal for lists and catalogues.
- Network only — for payments, authentication and other actions that must never be served from cache.
We use proven tooling such as Workbox to implement these strategies and to handle service worker updates, so users are prompted to refresh when a new version is ready.
Performance targets that matter
Installable web apps are judged against native apps, so speed is essential. We set budgets for page weight and JavaScript, and track Core Web Vitals — Largest Contentful Paint, Interaction to Next Paint and Cumulative Layout Shift — on real devices, including mid-range Android phones on slower networks. Code splitting, image optimisation, preloading critical resources and server or static rendering for first load all contribute.
Common PWA mistakes
- A service worker that caches everything and serves outdated content after releases
- No offline fallback page, so users see the browser’s error screen
- Asking for notification permission on first visit before users see any value
- Ignoring iOS differences in installation, storage and notification behaviour
- Testing only on desktop browsers with fast connections
Measuring PWA success
Useful measures include install rate, repeat visits from installed users, offline sessions completed, notification opt-in and click-through, and conversion on mobile compared with the previous website. We instrument these from launch so improvements can be prioritised with data.
Comparing options? Read about cross-platform apps and performance testing.
Security and data on the device
Because PWAs store data locally for offline use, we decide carefully what is cached. Sensitive data is kept to the minimum needed offline, cleared on logout and never stored in places accessible to other sites. Authentication tokens are short-lived and refreshed securely, and service worker scripts are served only over HTTPS from your own domain.
We also plan what happens when a user is offline for a long time: queued changes are validated again when they reach the server, conflicts are resolved with clear rules and users are told plainly when an action could not be completed. Handling these cases well is what separates a trustworthy offline experience from one that silently loses data.
Finally, we test installation, updates and offline behaviour on real iPhones and Android devices, because browser differences still matter.
Distributing your PWA
Users can install a PWA straight from the browser, but you can also reach app-store audiences. On Android, a PWA can be packaged as a Trusted Web Activity for Google Play; on Windows, it can be listed in the Microsoft Store. Apple’s App Store generally requires a native or wrapped app, so we discuss whether store presence on iOS is essential before choosing an approach.
Related services
Compare with cross-platform apps or build with web application development.
This page is part of Web Development Services — see the full overview for related services, approach and pricing.