PWA Development Checklist: From Manifest to Offline Support

A progressive web app (PWA) is a website that can be installed on a phone or desktop, load instantly, work offline and send notifications, all from a single web codebase. Done well, it gives users an app-like experience without an app store download. Done badly, it is just a website with a stale cache. This PWA development checklist walks through every layer that matters, from the web app manifest to offline sync and launch testing, so your team can ship a PWA that actually behaves like an app.
If you are still deciding whether a PWA, a native app or a cross-platform app is right for you, read our comparison of native vs hybrid vs cross-platform apps first.
What Makes a Website a PWA?
A website becomes an installable PWA when it is served over HTTPS, has a valid web app manifest and registers a service worker. Everything else on this list improves quality, reliability and engagement.
Browser support varies. Chromium-based browsers (Chrome, Edge, Samsung Internet) support the widest set of PWA features, including install prompts. Safari on iOS supports installation through “Add to Home Screen” and, since iOS 16.4, web push notifications for installed web apps. Good references are MDN’s progressive web apps guide and Google’s Learn PWA course.
1. Foundations Checklist
Get the basics right before adding offline or push features. These items are prerequisites for everything that follows.
- HTTPS everywhere. Service workers only run on secure origins (localhost is allowed for development). Redirect all HTTP traffic.
- Responsive layout. The app must work from small phones to large desktops, with a correct viewport meta tag.
- App shell architecture. Separate the static interface (header, navigation, layout) from dynamic content so the shell can load instantly from cache.
- Clean URLs for every screen. Each view should have a shareable, deep-linkable URL.
2. Web App Manifest Checklist
The web app manifest is a JSON file that tells the browser how your app should look and behave when installed. It is defined by the W3C Web Application Manifest specification.
| Manifest field | What it does | Tip |
|---|---|---|
| name / short_name | Full app name and the label under the icon | Keep short_name to about 12 characters |
| start_url | Page that opens on launch | Add a query parameter to track installed launches in analytics |
| id | Stable identity of the app | Set it once and never change it |
| display | standalone, fullscreen, minimal-ui or browser | standalone is the usual choice |
| icons | Home screen and splash icons | Provide at least 192px and 512px PNGs, plus a maskable icon |
| theme_color / background_color | Toolbar and splash screen colors | Match your brand and the app’s first paint |
| scope | Which URLs belong to the app | Links outside scope open in the browser |
| screenshots / description | Richer install dialog in supporting browsers | Include mobile and desktop screenshots |
Also add an Apple touch icon link in your HTML, because iOS has historically relied on it for home-screen icons.

3. Service Worker and Offline Support Checklist
The service worker is a script that sits between your app and the network, deciding what to serve from cache and what to fetch. Your offline experience is only as good as your caching strategy.
- Precache the app shell (HTML, CSS, JavaScript, fonts, key icons) at install time, with versioned file names.
- Pick a strategy per resource type: cache-first for static assets, network-first for frequently changing data, and stale-while-revalidate for content that can be slightly out of date.
- Provide an offline fallback page instead of the browser’s default error.
- Store user data in IndexedDB, not in the Cache API, and queue changes made offline for later sync.
- Handle updates gracefully. Tell users when a new version is ready and let them refresh, rather than silently mixing old and new code.
- Clean up old caches during activation so storage does not grow indefinitely.
- Request persistent storage where offline data matters, because browsers can evict storage when the device is low on space.
Libraries such as Workbox reduce the amount of hand-written service worker code. For apps where offline work is central, such as field service or inspections, see our deeper guide to offline-first app architecture and sync strategies.
4. Installability and Engagement Checklist
Installation and notifications turn a PWA from a website into a habit. Ask for both at the right moment, never on first page load.
- Custom install prompt. In Chromium browsers, capture the install event and show your own button after the user has seen value, for example after a second visit or a completed order.
- iOS install guidance. Safari does not show an automatic prompt, so show short instructions for “Share, then Add to Home Screen” to iPhone users.
- Push notifications. Use the Push API with a clear opt-in explaining what users will receive. On iOS, push only works once the PWA is installed. Our push notification strategy covers timing and frequency.
- App-store distribution if needed. PWAs can be packaged for Google Play using a Trusted Web Activity and listed in the Microsoft Store. Apple’s App Store generally requires a native wrapper with meaningful native functionality.
5. Performance and Accessibility Checklist
A PWA should feel faster than the website it replaces. Measure against Google’s Core Web Vitals and the WCAG accessibility guidelines.
- Keep the initial JavaScript bundle small and lazy-load routes.
- Serve modern image formats at the right sizes.
- Reserve space for images and ads to avoid layout shift.
- Ensure touch targets are large enough and focus states are visible.
- Test with screen readers in standalone mode, not only in the browser tab.
6. Testing and Launch Checklist
Test the installed app, not just the website. Many PWA bugs only appear in standalone mode, offline or after an update.
- Run Lighthouse and the browser DevTools Application panel to check the manifest and service worker.
- Install on real Android and iOS devices and on desktop Chrome or Edge.
- Test airplane mode, slow 3G throttling and flaky connections.
- Deploy a new version and confirm the update flow works for already-installed users.
- Verify analytics separate installed launches from browser visits.
Your PWA Development Checklist at a Glance
Before launch, confirm that each of these ten items is done. If any are missing, the app may still work, but it will not feel like an app.
- Site served entirely over HTTPS.
- Responsive layout with a fast-loading app shell.
- Complete manifest with id, icons, maskable icon and screenshots.
- Service worker with a deliberate caching strategy per resource.
- Offline fallback page and offline data queue.
- Visible update flow for new versions.
- Contextual install prompt plus iOS instructions.
- Opt-in push notifications with clear value.
- Passing Core Web Vitals and WCAG checks.
- Tested installed, offline and after an update on real devices.
How Much Does a PWA Cost?
Converting a well-built existing website into a basic PWA typically costs $5,000–$20,000. A new PWA with offline data sync, push notifications and integrations usually costs $25,000–$90,000, which is often less than building separate iOS and Android apps. Your final quote depends on scope.
Frequently Asked Questions
Do PWAs work on iPhone?
Yes. Users install PWAs from Safari using “Add to Home Screen”, and installed web apps can receive push notifications on iOS 16.4 and later. Some features available in Chromium browsers, such as automatic install prompts and background sync, are not supported on iOS.
Can a PWA be published on Google Play?
Yes. You can package a PWA as an Android app using a Trusted Web Activity, as long as it meets Google Play’s policies and quality requirements.
Is a PWA good for SEO?
A PWA is still a website, so its pages can be indexed like any other. Use server-side rendering or pre-rendering for important content so search engines see it without running JavaScript.
What is the difference between a PWA and a native app?
A PWA runs in the browser engine from one web codebase and installs without an app store. Native apps have deeper access to device hardware and platform features but require separate builds and store approval.
Launch Your PWA with Sigmato
Our team builds installable, offline-ready apps through our PWA development services, alongside web applications and native mobile apps. Share your current site or idea and we will run through this checklist with you.