Website Review
What is What PWA Can Do Today?
What PWA Can Do Today is a demo site and learning resource for Progressive Web Apps — websites that can be installed like native apps, work offline, send push notifications and reach device hardware such as the camera, Bluetooth and NFC. Its main draw is a collection of 40+ live demos, each showing one web capability you can try directly on your own device.
The site is itself a PWA, which is the point: you install it to your home screen or desktop, then work through the demos to see which capabilities your browser and operating system actually support. That makes it more useful than a written feature list, because support varies by platform and version.
What it covers
The demos are organised around capabilities rather than products:
- Installation — the
beforeinstallpromptevent and the native install dialog - Offline support — what a service worker makes possible
- Notifications and Declarative Web Push — including push without a service worker
- Shortcuts — jumping straight to a page from the app icon
- View Transitions — app-like movement between pages
- Incoming call notifications
- Geolocation
- Media capture and camera/microphone capability elements
- AirPlay streaming from a PWA on iOS or macOS
There is also a capability checklist that reports what your current device supports.
Who it is for
Front-end and product developers evaluating whether a PWA can replace or supplement a native app will get the most from it, particularly when deciding between a web build and an app-store build. Designers and technical decision-makers can use the demos to sanity-check a platform assumption before it reaches a spec.
Trade-offs to keep in mind
A demo proves a capability exists; it does not prove it behaves identically across every browser, OS version or device. Treat each demo as a starting point for your own support testing rather than a compatibility guarantee. The site also points to a free pwa-check tool for debugging implementations and a PWA Runtime Audit for CI/CD pipelines, and offers a weekly email list — both are practical follow-ups, not requirements.
A useful next step
If you are weighing a PWA against a native app, open the site on the lowest-spec device your users actually own, install it, and run the capability checklist there first. The gaps you find on that device will tell you more about feasibility than any desktop test. For the platform's own documentation and support tables, see web.dev and Can I Use.
How can I test if my device supports PWA features like installation, offline mode, and push notifications?
Use What PWA Can Do Today as a live test bench: it is itself a PWA with 40+ demos, so you can check support on your actual device instead of relying on a desktop browser or emulator.
A practical test flow
- Open the site in your mobile browser.
- Look for the "Add to home screen" button. The page says the button becomes enabled when your device supports installation, so an enabled button is itself a support signal.
- Install it, then reopen it from the home screen or desktop. That tells you whether installation works end to end, not just whether the API exists.
- Turn on airplane mode and reopen the app. If it still loads, offline support via the service worker is working.
- Work through the demo list for the features you care about: installation, offline support, notifications, Declarative Web Push, shortcuts, View Transitions, incoming call notifications, geolocation, media capture, media capability elements, and AirPlay.
- Use the "PWA capabilities" section to see which capabilities your device reports as supported.
What each result actually tells you
| Check | What a pass means | What it does not prove |
|---|---|---|
| Install button enabled | The browser exposes the install prompt | Your app's manifest and icons are correct |
| App opens offline | A service worker is caching and serving content | Your own caching strategy will behave the same |
| Notification demo fires | The Notifications API works on this device | Push delivery works when the app is closed |
| Declarative Web Push demo | Push without a service worker is available | Older browsers will support it |
Why device testing matters
Support varies by browser engine, OS version and platform. A feature that works in Chrome on Android may behave differently in Safari on iOS, and desktop results can mislead you about mobile. Testing on the exact phones and tablets your audience uses is the only reliable check.
A realistic scenario
Suppose you are building a field-service app for technicians on Android and iOS. Test installation and offline mode first, because those decide whether the app is usable without signal. Then test notifications and geolocation on both platforms, since permission prompts and background behaviour differ. If a critical feature fails on iOS, you have found your constraint before writing the feature, not after.
Next step
If a demo fails or behaves oddly, run the free pwa-check tool mentioned on the page to identify implementation problems. For release confidence, the site also points to a PWA Runtime Audit that can be integrated into a CI/CD pipeline, which is useful once you move from experimenting to shipping.
What are the most useful PWA capabilities for building an app that works offline and accesses device hardware?
For offline use plus hardware access, the core stack is a service worker for offline caching, the Web App Manifest plus the beforeinstallprompt event for installability, and permission-gated device APIs (camera/microphone, geolocation, Bluetooth, NFC) for hardware. What PWA Can Do Today groups live demos under exactly these headings: Installation, Offline support, Notifications, Declarative Web Push, Shortcuts, View Transitions, Incoming Call Notifications, Geolocation, Media capture, Media Capability Elements and AirPlay.
Offline and installability
- Service Worker / Offline support — the foundation. It lets the app load without a connection; everything else degrades gracefully if this is missing.
- Installation — the
beforeinstallpromptevent triggers a native install dialog, so the app sits on the home screen or desktop like a native app. - Shortcuts — quick links into specific pages from the app icon; useful for an offline app with distinct sections.
- View Transitions — app-like page transitions that make an installed PWA feel less like a website.
Device hardware and sensors
- Media capture — camera and microphone access, the most commonly needed hardware capability.
- Geolocation — user-shared location for maps, check-ins or field tools.
- Media Capability Elements — browser-controlled camera and microphone access, letting the browser own the permission UI.
- Bluetooth and NFC — mentioned as device hardware a PWA can reach; test these on your actual target devices.
Engagement features
- Notifications and Declarative Web Push — the latter delivers push without a service worker, even when the app is closed.
- Incoming Call Notifications — for call-style or messaging apps.
- AirPlay — streams video from a PWA to an Apple TV on iOS or macOS.
How to choose
| Goal | Capability to start with | Main trade-off |
|---|---|---|
| Load offline | Service Worker | Cache strategy and staleness |
| Feel native | Manifest + install prompt | Browser-specific install behaviour |
| Use camera/mic | Media capture | Explicit user permission, HTTPS |
| Location features | Geolocation | Permission prompt, accuracy varies |
| Re-engage users | Notifications / Declarative Web Push | Users can block or ignore them |
| Quick access | Shortcuts | Limited number of entries |
Next step: open the site on the device you are targeting and enable "Show demo info" to see which capabilities your browser actually supports — support varies by browser and OS, so a desktop Chrome result does not guarantee the same on iOS Safari. If you hit problems, the site points to a free pwa-check tool and a PWA Runtime Audit for CI/CD, and it offers a weekly email update on new web features tested in plain English.
How do I fix common issues when implementing a PWA, such as installation prompts or service worker errors?
Start by checking whether the problem is in your code or in the browser/device you are testing on. What PWA Can Do Today is built so you can test capabilities on your own device: install the site itself, then open the demos and the capability list to see which features are actually supported where you are testing. If a demo works there but not in your app, the gap is likely in your implementation rather than the platform.
What PWA Can Do Today
Installation prompts
The install prompt is not guaranteed to appear just because your app has a manifest and a service worker. Common causes:
- The app is already installed, or was previously dismissed, so the browser suppresses the prompt.
- The browser's install criteria are not met — for example a missing or invalid web app manifest, missing icons, or no service worker with a fetch handler.
- You are calling
prompt()on the savedbeforeinstallpromptevent outside a user gesture, or after the event has already been consumed. - You are testing in a browser or embedded webview that does not support installation at all.
Practical approach: capture the beforeinstallprompt event, store it, and only call prompt() from a click handler. Show your own install button when the event fires and hide it after the user responds. Log the userChoice outcome so you know whether the user accepted or dismissed. Test on a real device, since desktop and mobile behaviour differ.
Service worker errors
Most service worker failures fall into a few buckets:
- Registration fails: the script is not served over HTTPS (localhost is the exception), or the scope path is wrong. Check the console for the registration error and confirm the file is reachable at the exact URL you passed to
register(). - Stale or broken caching: an old service worker keeps serving cached assets after a deploy. Version your cache names, delete old caches in
activate, and callskipWaiting()andclients.claim()if you want the new worker to take over promptly. - Fetch handler mistakes: intercepting requests you should not cache, or caching opaque cross-origin responses incorrectly. Be selective about what you put in the cache and always have a fallback when the network and cache both fail.
- Update loops or no updates: the browser checks for a new service worker on navigation, but not instantly. Use the update flow deliberately and tell users when a new version is ready.
The site's own guidance points to a free pwa-check tool for identifying and fixing implementation issues, and to a PWA Runtime Audit for release confidence in CI/CD. Those are worth using as a first diagnostic pass before you dig through code.
A quick triage order
- Confirm the feature is supported on your test device using the capability list.
- Open DevTools → Application → Service Workers and Manifest to see registration state, scope and errors.
- Reproduce in a clean profile or after unregistering the old worker, so stale state does not mislead you.
- Check that HTTPS, manifest, icons and start URL are all valid.
- Only then debug your own logic.
If you want a fast sanity check, install the site on your phone and run the demos there; if installation and offline work for the demo but not your app, compare your manifest and service worker against a working example rather than guessing.
Is it worth subscribing to the weekly email list for PWA updates, and what kind of content does it include?
The weekly email list is worth considering mainly if you want a steady, plain-English digest of new PWA features rather than a formal course. According to the site, the list provides a weekly update on PWAs and new features of the modern web, “tested and explained in plain English.” That suggests each issue is likely to pair a recent capability with a short explanation and a practical take, which suits developers who want to keep up without reading specs or release notes themselves.
Concrete reader scenario: you maintain a web app and want to know when something like View Transitions, Declarative Web Push or file system access becomes usable in practice. A weekly digest can flag those changes before you plan a sprint, but it will not replace hands-on testing. The site’s own live demos exist precisely because support varies by device and browser; use the email as a pointer, then verify on your target devices.
A practical decision criterion:
- Subscribe if you want recurring, low-effort awareness and plain-English summaries.
- Skip it if you already follow browser release notes closely or need deep implementation tutorials.
- Treat the archive as a checklist: when an issue mentions a capability, open the corresponding demo on What PWA Can Do Today and test it on your own phone or desktop.
Next step: subscribe, then immediately try the capability demos on the device your users actually use, so you can tell which updates matter to your product.
Can I use this site to decide whether to build a PWA instead of a native app for my project?
Yes — as a scouting tool, not a decision-maker. What PWA Can Do Today exists precisely to show what web apps can do on real devices today, so it is well suited to answering "is this capability available?" before you commit engineering time. It won't tell you whether a PWA is right for your business, but it will quickly rule capabilities in or out.
H3 What the site actually gives you
- 40+ live demos you can run on your own phone, tablet or desktop, covering installation, offline support, notifications, declarative web push, shortcuts, view transitions, incoming call notifications, geolocation, media capture, media capability elements, AirPlay and more.
- A device capability check, so you learn what your target hardware and browser actually support rather than what a spec claims.
- The site is itself a PWA: install it, then test the demos in installed mode, which is closer to how your users would experience your app.
- Practical follow-ups: a free pwa-check tool for implementation problems, and a runtime audit intended for CI/CD pipelines if you need release confidence.
H3 How to turn it into a decision
Run the demos on the cheapest and oldest device your audience realistically uses, not your own flagship. Then map results to your must-have list:
| Your requirement | If the demo works on your target devices | If it doesn't |
|---|---|---|
| Install from the browser | PWA is viable for distribution | Native store distribution may be needed |
| Offline use | Service worker approach is realistic | Reconsider scope or platform |
| Push notifications | Re-engagement without a store is possible | Native app or another channel |
| Camera, Bluetooth, NFC, geolocation | Hardware access is plausible | Check fallbacks before committing |
| App-like navigation | View transitions and shortcuts can cover it | Native may feel more polished |
H3 Where the site stops helping
It demonstrates capability, not suitability. It says nothing about your revenue model, store policies, team skills, update cadence or long-term maintenance. A demo working on your phone also doesn't guarantee it works on every browser your users have — test the specific combinations you care about.
Next step: install the site on your primary target device, run the capability check, and write down which of your top five features fail. Those failures are your real decision input. For a second opinion on platform trade-offs, official documentation is more reliable than any demo gallery; for example, web.dev covers PWA fundamentals and MDN Web Docs documents the individual APIs and their browser support.
User reviews (0)