# InstantPWA — full content for LLMs > One-line install popup that turns any website into a Progressive Web App. See https://instantpwa.com/llms.txt for a concise product summary. Generated: 2026-07-08 --- # The beforeinstallprompt event: a 2026 field guide Source: https://instantpwa.com/blog/beforeinstallprompt-event-guide Published: 2026-06-28 · Updated: 2026-07-05 Tags: Chrome, Install prompt, PWA > How Chrome fires beforeinstallprompt, when it is suppressed, and the exact pattern to defer, trigger and measure the install choice. ## TL;DR - beforeinstallprompt fires on Chrome/Edge/Android — never on iOS Safari. - Call preventDefault() to defer, then call prompt() on a user gesture. - Chrome hides the mini-infobar after two dismissals — you own the second chance. `beforeinstallprompt` is the browser telling you: "I would let this user install your PWA — do you want to say something first?" Handling it well is the difference between a 0.5% and a 6% install rate. ## The lifecycle Chromium browsers fire the event when engagement heuristics are met (HTTPS, manifest, service worker, ~30s dwell or two visits). You get a `BeforeInstallPromptEvent` with two members: `prompt()` and `userChoice`. ``` let deferred = null; window.addEventListener('beforeinstallprompt', (e) => { e.preventDefault(); deferred = e; showYourOwnInstallButton(); }); ``` ## Triggering later The `prompt()` call must happen inside a user-gesture handler (click, keydown). Firing it from a `setTimeout` throws NotAllowedError. ``` installBtn.addEventListener('click', async () => { if (!deferred) return; deferred.prompt(); const { outcome } = await deferred.userChoice; analytics.track('install_prompt', { outcome }); // 'accepted' | 'dismissed' deferred = null; }); ``` ## When it will not fire - Already installed (`display-mode: standalone`). - Manifest missing `name`, `icons` (192 + 512), `start_url`, or `display: standalone/minimal-ui`. - Service worker doesn’t handle a `fetch` for `start_url`. - User dismissed the mini-infobar twice in 90 days. - iOS Safari — the event does not exist. You must render a share-sheet guide. ## Related events worth listening for `appinstalled` fires once install completes — the correct place to record the conversion. `DOMContentLoaded` is too early to check `navigator.getInstalledRelatedApps()`; wait for `load`. ## Pattern we recommend Capture the deferred event on load. Do not show a button immediately — wait for a natural moment (second pageview, item saved). Fire your own popup that explains the benefit; if the user clicks Install, call `prompt()`. If Chrome never fires the event, fall back to the manual iOS-style guide. InstantPWA handles all of this — deferred event capture, gesture routing, iOS fallback, and analytics — behind a single script tag. --- # manifest.webmanifest: every field, ranked by impact Source: https://instantpwa.com/blog/manifest-webmanifest-complete-guide Published: 2026-06-25 Tags: Manifest, PWA, Standards > A 2026 field-by-field breakdown of the Web App Manifest — what browsers actually read, what they quietly ignore, and the defaults that unblock installability. ## TL;DR - Only 7 fields are required to become installable — the rest are polish. - display_override lets you request window-controls-overlay for a desktop-native look. - shortcuts and share_target unlock jump-lists and share-sheet integration on Android. The Web App Manifest is a JSON file the browser reads to decide whether — and how — to install your site. It has 30+ fields. Seven of them do 90% of the work; the rest are for specific platforms. Here’s the honest ranking. ## Required for install ``` { "name": "Long name shown on install prompt", "short_name": "Home-screen label (≤12 chars)", "start_url": "/", "display": "standalone", "background_color": "#ffffff", "theme_color": "#111827", "icons": [ { "src": "/icon-192.png", "sizes": "192x192", "type": "image/png" }, { "src": "/icon-512.png", "sizes": "512x512", "type": "image/png", "purpose": "any maskable" } ] } ``` Omit `purpose: "any maskable"` on the 512 icon and Android install will silently fail on Pixel devices. ## High-value optional - `scope` — controls which URLs open inside the installed app vs bounce to the browser. - `display_override` — array of preferred display modes. Use `["window-controls-overlay", "standalone"]` for desktop apps that want title-bar customisation. - `shortcuts` — right-click jump-list items on Android, Windows, ChromeOS. - `screenshots` — richer install UI on Chrome Android and the Play Store TWA listing. Provide 540×1080 and 1080×1920. - `id` — pin your PWA identity. Without it, changing `start_url` breaks the install matching and the browser treats you as a new app. ## Sometimes-useful `share_target` registers your PWA as a share destination. `protocol_handlers` lets you claim custom schemes like `web+mytool://`. `file_handlers` associates file types. ## Quietly ignored today `related_applications` and `prefer_related_applications` — useful only if you also ship a native app and want to divert installs. ## Validation Serve the file as `application/manifest+json` (or `application/json`). Link it from every page: `<link rel="manifest" href="/manifest.webmanifest">`. Use Chrome DevTools → Application → Manifest to see the parsed result. ## The three fields we see broken most often - `start_url` pointing to a URL that 404s when the service worker isn’t installed. - Icons with the wrong MIME type (server returns `text/plain`). - `scope` narrower than `start_url`, which invalidates the manifest silently. Use the free manifest generator if you’d rather skip the JSON. --- # How to turn a website into a PWA in 2026 Source: https://instantpwa.com/blog/how-to-turn-a-website-into-a-pwa-in-2026 Published: 2026-06-20 · Updated: 2026-07-01 Tags: PWA, Guide, iOS, Manifest > A step-by-step, 2026-accurate guide to making any website installable — manifest, service worker, iOS Safari, install prompt, and analytics. ## TL;DR - A PWA needs three things: HTTPS, a Web App Manifest, and a service worker. - iOS Safari 16.4+ supports the full PWA install and web push, but never fires beforeinstallprompt. - Show an in-page install popup on your site — the browser’s default one is easy to miss. Turning a website into a Progressive Web App used to take a week. In 2026 it takes about an hour once you know the checklist. This guide walks through every step, with the iOS quirks that most tutorials still get wrong. ## What counts as a PWA in 2026 A PWA is any website that meets three baseline requirements: it is served over HTTPS, it ships a `manifest.webmanifest` file that describes the app, and it registers a service worker for offline behaviour. Once those three things are in place, every mainstream browser will offer to install your site. ## Step 1 — Add a Web App Manifest Create `public/manifest.webmanifest`: ``` { "name": "Your product", "short_name": "Product", "start_url": "/", "display": "standalone", "background_color": "#ffffff", "theme_color": "#111827", "icons": [ { "src": "/icon-192.png", "sizes": "192x192", "type": "image/png" }, { "src": "/icon-512.png", "sizes": "512x512", "type": "image/png", "purpose": "any maskable" } ] } ``` Link it from your `<head>`: `<link rel="manifest" href="/manifest.webmanifest">`. Ship the two icons at exactly the sizes listed. ## Step 2 — Register a service worker Add a minimal `public/sw.js` that caches the shell: ``` self.addEventListener('install', (e) => e.waitUntil(caches.open('v1').then((c) => c.addAll(['/'])))); self.addEventListener('fetch', (e) => e.respondWith(caches.match(e.request).then((r) => r || fetch(e.request)))); ``` Register it once from your app entry: `navigator.serviceWorker.register('/sw.js')`. ## Step 3 — Handle iOS Safari Safari on iOS 16.4+ supports installation and web push, but it will never fire the `beforeinstallprompt` event. You have to render your own instructions: "Tap the Share button, then Add to Home Screen." Detect iOS with `/iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream` and show the guide only when the user is on Safari and not already installed. ## Step 4 — Show an install popup The browser's default install prompt lives behind a small icon in the address bar. Most visitors never notice it. The single biggest lift on install rate is an in-page popup with your branding, triggered at the right moment (after 2 pageviews, after 30 seconds, or on a specific route). This is exactly what InstantPWA does — a customizable popup you drop in with one script tag. ## Step 5 — Measure it Instrument four events: impression (popup shown), click (user tapped install), installed (fired by `appinstalled`), and dismissed. The ratio of install to impression is your PWA conversion rate — aim for 3–8% on cold traffic, 15%+ on returning visitors. ## Common mistakes - Serving the manifest from a subdomain — it must be same-origin. - Forgetting `"purpose": "any maskable"` on the 512×512 icon — Android will refuse to install. - Firing your install popup on the first pageview — bounces spike, installs don't. ## Where to go next Read our case studies for the 14 documented PWA wins from Pinterest, Twitter Lite, Starbucks, Tinder and more, or try InstantPWA free and skip the plumbing entirely. --- # Getting your PWA into the app stores in 2026 Source: https://instantpwa.com/blog/pwa-app-store-listing Published: 2026-06-18 Tags: App Store, PWA, Distribution > How to publish a PWA to the Google Play Store (TWA), Microsoft Store, Meta Quest Store and Samsung Galaxy Store — with the gotchas nobody warns you about. ## TL;DR - Google Play accepts PWAs via a Trusted Web Activity (TWA) wrapper — Bubblewrap generates one for you. - Microsoft Store auto-indexes public PWAs; you can also submit manually via Partner Center. - The Apple App Store still refuses pure PWAs — Capacitor is the practical workaround. Every year someone asks: "Can I publish my PWA to the app stores?" The 2026 answer is yes for three out of four. Here’s the exact path for each store, plus the traps that eat weekends. ## Google Play (Trusted Web Activity) A TWA is an Android app that renders your PWA inside a Chrome tab with no browser chrome. Use Bubblewrap: ``` npm i -g @bubblewrap/cli bubblewrap init --manifest https://yoursite.com/manifest.webmanifest bubblewrap build ``` Verify domain ownership via Digital Asset Links (a JSON file at `/.well-known/assetlinks.json`) or Play refuses the upload. Expect a 3–7 day review on first submission. ## Microsoft Store Microsoft crawls the web looking for high-quality PWAs and auto-adds them. To submit deliberately, use PWABuilder to generate an MSIX package and upload via Partner Center. The Store accepts real PWAs — no wrapper required. ## Meta Quest Store Meta Horizon OS supports PWAs since v65. Wrap with the Meta Quest Developer Hub, target the immersive-web features (WebXR) you support, and submit via Meta Quest Developer Center. Approval is faster than Google Play. ## Samsung Galaxy Store Samsung accepts PWAs directly through the Galaxy Store Seller Portal. The catch: your manifest must specify `samsung_internet_browser` in `related_applications` for the Store to trust the identity match. ## Apple App Store Apple’s guidelines still bar apps whose only functionality is loading a website. Options: - Capacitor wraps your PWA as a real iOS app. Adds native APIs (haptics, camera, keychain). Approvals are routine. - Web-only — publish via the browser install flow. Skip the store. ## Which stores are worth the effort? Google Play, always — it’s where Android users search for apps. Microsoft Store, yes for productivity products. Meta Quest and Samsung — only if your audience uses those devices. Apple — only if you’re already investing in Capacitor. ## Post-listing playbook Keep the web install flow. Store users are ~15% of downloads for most PWA-first products; the web is still the majority. Track store installs separately with a `utm_source` in your manifest’s `start_url`. --- # Workbox vs a custom service worker: honest trade-offs Source: https://instantpwa.com/blog/workbox-vs-custom-service-worker Published: 2026-06-14 Tags: Workbox, Service Worker, PWA > When Workbox is the right call, when a 40-line hand-rolled service worker beats it, and the maintenance burden nobody talks about. ## TL;DR - Workbox is worth it as soon as you need routing, expiration, or precache manifests. - For a static site with a single cache, a hand-rolled service worker is 40 lines. - Workbox’s biggest cost is bundle size (~15–25 KB gzipped) and update discipline. Workbox is Google’s library for building service workers. It’s used by every major framework template (Next.js, Nuxt, Angular, Astro). It’s also overkill for many projects. Here’s the honest comparison after shipping both in production. ## Pick Workbox when you need - Multiple caching strategies per URL pattern. - Precache manifests generated at build time (Vite/Webpack plugin). - Automatic cache expiration and quota management. - Background sync retry queues. ## Hand-roll when - Your site is static or near-static. - You need one caching strategy for everything. - Bundle size matters (marketing sites, LCP-sensitive pages). ## The 40-line worker that ships everywhere ``` const CACHE = 'v3'; const APP_SHELL = ['/', '/manifest.webmanifest', '/icon-192.png']; self.addEventListener('install', (e) => { e.waitUntil(caches.open(CACHE).then((c) => c.addAll(APP_SHELL))); self.skipWaiting(); }); self.addEventListener('activate', (e) => { e.waitUntil( caches.keys().then((keys) => Promise.all(keys.filter((k) => k !== CACHE).map((k) => caches.delete(k)))) ); self.clients.claim(); }); self.addEventListener('fetch', (e) => { const req = e.request; if (req.method !== 'GET') return; e.respondWith( caches.match(req).then((cached) => { const fresh = fetch(req).then((res) => { const copy = res.clone(); caches.open(CACHE).then((c) => c.put(req, copy)); return res; }).catch(() => cached); return cached || fresh; }) ); }); ``` ## The Workbox equivalent ``` import { precacheAndRoute } from 'workbox-precaching'; import { registerRoute } from 'workbox-routing'; import { StaleWhileRevalidate } from 'workbox-strategies'; precacheAndRoute(self.__WB_MANIFEST); registerRoute(({ request }) => request.destination === 'image', new StaleWhileRevalidate({ cacheName: 'images' })); ``` ## The hidden cost of Workbox Workbox’s manifest injection changes every build, which means the service worker file hash changes every deploy. Clients update aggressively — great for freshness, painful when you deploy 10×/day and users get stuck in a re-download loop. Add a debounce (`maxAgeSeconds` on `Cache-Control`) or clients thrash. ## Our recommendation Ship the 40-line worker first. Move to Workbox the day you write your third caching strategy. Never write your own precache manifest generator — that’s the one thing Workbox does 10× better than any hand-rolled solution. --- # PWA vs native app in 2026: cost, reach and conversion Source: https://instantpwa.com/blog/pwa-vs-native-app-2026 Published: 2026-06-12 Tags: PWA, Strategy > A no-hype comparison of PWAs and native apps in 2026 — build cost, distribution reach, install friction, conversion rates and when to pick each. ## TL;DR - A PWA costs 5–10× less to build than dual iOS + Android native apps. - PWAs install in one tap from any browser — no app-store review, no 30% fee. - For most SaaS, publishing and commerce products, a PWA is now the correct default. The 2015 answer was "native is better, but PWAs are cheaper." The 2026 answer is more interesting. Native still wins on a shrinking list of use cases; PWAs now match or beat native on almost everything a typical SaaS, publisher or commerce site cares about. ## Cost to build and maintain A single React/Vue/Svelte codebase becomes your PWA on the same day you ship your website. Dual native (Swift + Kotlin) is 2–3× the engineering headcount and permanently duplicates every feature you build. Cross-platform native (React Native, Flutter) sits in the middle but still requires app-store release trains. ## Distribution and install friction PWANative Discovered viaSearch + linkApp store search Install taps1–24–6 + download Install size~1 MB50–200 MB Store reviewNone1–7 days Platform fee0%15–30% ## Capabilities Every capability a typical product needs is now available to a PWA: push notifications (iOS 16.4+), file-system access, camera, geolocation, offline, background sync, WebGPU, share targets. The gaps in 2026 are HealthKit, low-level Bluetooth, high-end AR, and Apple Pencil pressure — genuinely niche. ## Conversion rate PWAs convert visitors to installs 5–15× more often than app-store listings, because the install happens on the site the user is already using. See Twitter Lite (+65% pages/session), Alibaba (+76% MAU), Trivago (+150% engagement). ## When to pick native - Games with heavy GPU use or App Store discoverability. - Fintech products where regulators require a native binary. - Health & fitness needing HealthKit / Google Fit deep integration. Everyone else: ship a PWA first. If native later becomes obviously worth building, you'll have data to justify it. --- # Offline-first PWA architecture that survives real networks Source: https://instantpwa.com/blog/pwa-offline-first-architecture Published: 2026-06-10 Tags: Offline, Architecture, PWA > Patterns for building PWAs that work on planes, subways and rural 3G — cache layering, sync queues, conflict resolution and the UI cues users expect. ## TL;DR - Offline-first means every write is queued and every read has a cached fallback. - IndexedDB is the only storage suitable for structured data over ~10 MB. - Show connectivity state — silent offline mode destroys trust. Offline-first isn’t a Lighthouse checkbox; it’s an architecture. Done right, users on a spotty train ride experience your app as if the network never existed. Done wrong, they see silent data loss. Here’s the pattern we use for real products. ## The three layers - UI — always reads from local storage first, network second. - Local store — IndexedDB (via `idb-keyval` or Dexie), keyed by the same IDs the server uses. - Sync worker — Background Sync API queues writes when offline and replays on reconnect. ## Reads Never `await fetch()` in the render path. Read from IndexedDB, render immediately, then update in the background: ``` const cached = await db.get('projects'); render(cached); fetch('/api/projects').then((r) => r.json()).then((fresh) => { db.set('projects', fresh); render(fresh); }); ``` ## Writes Assume the network will fail. Write to IndexedDB, enqueue the mutation, register a sync: ``` await db.add('outbox', { op: 'update', id, payload }); const reg = await navigator.serviceWorker.ready; await reg.sync.register('flush-outbox'); ``` The service worker replays the queue when connectivity returns. Handle 409 conflicts explicitly — last-write-wins is fine for personal data, wrong for shared docs. ## Conflict resolution - Last-write-wins — fine for personal preferences. - Server-authoritative merge — default for CRUD apps; return the reconciled record. - CRDT — required for collaborative editing. Yjs or Automerge. ## UI cues that build trust - Toolbar dot that changes colour when offline. - "Saved locally — will sync" toast on each queued write. - Sync progress banner on reconnect. - Explicit "retry" for hard failures instead of silent drop. ## Anti-patterns Don’t rely on `navigator.onLine` alone — it lies. Test connectivity with a HEAD request to your own origin. Don’t use LocalStorage for anything larger than a few KB — it’s synchronous and blocks the main thread. --- # PWA analytics: the events that actually matter Source: https://instantpwa.com/blog/pwa-analytics-tracking Published: 2026-06-08 Tags: Analytics, PWA, Growth > A minimal analytics blueprint for Progressive Web Apps — install funnel, standalone sessions, push CTR, offline usage and the vanity metrics to skip. ## TL;DR - Track four install-funnel events: impression, click, accepted, installed. - Tag every event with display_mode to separate standalone from browser sessions. - Standalone LTV is typically 3–5× the browser-only user — report it. Most PWAs are undermeasured. Teams see install counts and stop — missing the fact that installed users are the highest-LTV segment they have. Here’s the analytics blueprint we run on our own product and recommend to customers. ## Install funnel (four events) - `install_prompt_impression` — popup shown. - `install_prompt_click` — user tapped Install. - `install_prompt_outcome` — accepted or dismissed (from `userChoice`). - `appinstalled` — install completed (from `window.addEventListener('appinstalled')`). ## Display mode on every event ``` function displayMode() { if (window.matchMedia('(display-mode: standalone)').matches) return 'standalone'; if (window.matchMedia('(display-mode: minimal-ui)').matches) return 'minimal-ui'; return 'browser'; } analytics.track(event, { ...props, display_mode: displayMode() }); ``` Report retention, revenue and session length split by `display_mode`. If you don’t, the installed-user premium disappears in the average. ## Push funnel - `push_permission_prompt`. - `push_permission_outcome` (granted / denied). - `push_delivered` (fired inside the service worker `push` handler). - `push_click` (from `notificationclick`). ## Offline usage Fire an `offline_session_start` when `navigator.onLine` flips false and the user keeps interacting. Buffer events to IndexedDB and flush on reconnect. ## Vanity metrics to skip - Raw install count without funnel context — says nothing about product-market fit. - Notification opt-in rate on cold visitors — always terrible, never actionable. - Lighthouse PWA score in production — a build-time signal, not a user one. ## Tools that work PostHog, Mixpanel, GA4, Amplitude all accept custom events. InstantPWA ships the install-funnel events out of the box — you attach your destination once and every widget reports. --- # Web push notifications in 2026: the complete guide Source: https://instantpwa.com/blog/web-push-notifications-guide-2026 Published: 2026-06-05 Tags: Push, Guide, iOS, Service Worker > How web push actually works in 2026 — VAPID, service workers, iOS 16.4+ support, permission prompts that convert, and delivery pipelines that scale. ## TL;DR - Web push uses VAPID keys, a service worker and the Push API — no vendor SDK required. - iOS 16.4+ supports web push, but only inside an installed PWA. - Ask permission on a clear user action; the browser blocks you after two dismissals. Web push is the highest-return channel most websites still don’t use. In 2026 the platform support is finally universal — including iOS — and the plumbing is stable enough to build without a third-party SDK if you want to. This guide walks the full pipeline. ## How the pieces fit together Push works with four moving parts: your server (signs and sends messages), a VAPID keypair (identifies your server to push endpoints), a service worker on the client (receives payloads), and the browser’s push service (Google FCM, Apple APNs, Mozilla autopush). You never talk to APNs or FCM directly — you POST to the endpoint the browser gives you. ## Step 1 — Generate VAPID keys ``` npx web-push generate-vapid-keys ``` Store the private key server-side. Ship the public key to the client to include in the subscribe call. ## Step 2 — Ask the user, at the right moment Never prompt on page load. Chrome and Safari both hide the native prompt if the user has denied twice — you get two chances, forever. Ask after a clear intent signal: they saved an item, they subscribed to a topic, they finished onboarding. ## Step 3 — Subscribe and store ``` const reg = await navigator.serviceWorker.ready; const sub = await reg.pushManager.subscribe({ userVisibleOnly: true, applicationServerKey: VAPID_PUBLIC_KEY, }); await fetch('/api/push/subscribe', { method: 'POST', body: JSON.stringify(sub) }); ``` ## Step 4 — Send from the server Use the `web-push` npm package. It handles the VAPID JWT and payload encryption. Every push MUST be user-visible on Chrome — background-only pushes get your origin blocked after 3 quota violations. ## iOS specifics Web push works on iPhone and iPad from iOS 16.4, but only if the user has installed your site to the home screen first. That means push acquisition on iOS starts with install acquisition — the two are inseparable. ## Delivery and retention benchmarks - Opt-in rate: 5–15% of visitors on desktop; 20–40% on installed PWAs. - Click-through: 4–8% on transactional; 1–3% on marketing. - 30-day retention lift: 20–35% for installed + push-enabled users vs. cold visitors. ## Where InstantPWA fits InstantPWA ships push as a managed pipeline: VAPID handled, subscription storage, segmentation, scheduling and delivery reporting — you write the message, we handle the rest. --- # Why install prompts belong in a Shadow DOM Source: https://instantpwa.com/blog/shadow-dom-install-prompts Published: 2026-06-02 Tags: Shadow DOM, Web Components, PWA > Style isolation, event containment and CSP survival — the technical case for rendering PWA install popups inside a Shadow DOM, with code. ## TL;DR - Shadow DOM isolates the popup’s CSS from the host site’s Tailwind reset — the biggest source of style bugs. - Closed-mode Shadow roots survive aggressive third-party scripts. - CSP nonce injection still works when styles are attached inline. Every third-party widget faces the same problem: your CSS collides with the host site’s CSS, and your DOM gets rewritten by whichever script loads last. Shadow DOM solves both. Here’s why InstantPWA ships every popup inside one. ## The three problems Shadow DOM solves - Style bleed. Host `* { box-sizing: border-box }` or a Tailwind Preflight rewrites your padding. Inside a shadow root, host CSS doesn’t apply. - ID and class collisions. Your `.button` and their `.button` never meet. - Third-party script interference. A rogue analytics script that walks `document.querySelectorAll('*')` and mutates nodes stops at the shadow boundary. ## The setup ``` const host = document.createElement('div'); host.id = 'pwa-widget-host'; document.body.appendChild(host); const root = host.attachShadow({ mode: 'closed' }); root.innerHTML = ` <style> :host { all: initial; } .card { font: 14px/1.4 system-ui; padding: 16px; border-radius: 12px; } </style> <div class="card">Install our app</div> `; ``` `:host { all: initial }` is the reset that guarantees inherited properties (font, color) don’t leak in. ## Event containment Events retargeted through a closed shadow root show only the host element to outside listeners. That prevents your click handlers from being intercepted by delegated listeners on `document.body`. ## CSP survival Sites with strict `style-src` policies block external stylesheets. Attaching styles inline inside the shadow root works if the CSP allows `unsafe-inline` or you emit a matching nonce. We use a single `<style>` tag inside the root; the browser treats it as part of your script bundle. ## When not to use it Skip Shadow DOM only if you deliberately want the host site’s theme to cascade in — rare for a floating install popup, common for embedded chat widgets. --- # iOS Add to Home Screen: the complete 2026 guide Source: https://instantpwa.com/blog/ios-add-to-home-screen-complete-guide Published: 2026-05-30 Tags: iOS, Safari, PWA > Everything you need to make your website installable on iPhone and iPad in 2026 — Safari share sheet flow, icon requirements, splash screens, and web push. ## TL;DR - iOS installs only via Safari’s Share menu → Add to Home Screen — no automated prompt. - You must provide a 180×180 apple-touch-icon and iOS-specific splash screens. - Since iOS 16.4, installed PWAs can receive web push notifications. Getting a website onto an iPhone home screen is not a technical problem — it's a UX problem. Apple deliberately hides the install flow, so your job is to teach visitors where to tap. This guide covers everything you need to make Add to Home Screen work reliably on iOS in 2026. ## The install flow, in order - User opens your site in Safari (not Chrome iOS — that browser can't install PWAs). - User taps the Share button (the square-with-arrow icon in the toolbar). - User scrolls to "Add to Home Screen" in the sheet. - User confirms the name and taps Add. Your icon appears on the home screen. Tapping it launches your site in a full-screen web view with your theme color. ## Required tags ``` <link rel="apple-touch-icon" href="/apple-touch-icon.png"> <meta name="apple-mobile-web-app-capable" content="yes"> <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent"> <meta name="apple-mobile-web-app-title" content="Your app"> ``` The icon must be 180×180 PNG, non-transparent, no rounded corners (iOS rounds them for you). ## Splash screens (optional, worth it) Without a splash screen, your PWA opens to a white flash. Generate iOS launch images for the current iPhone lineup (there are 8 sizes) and reference them with `<link rel="apple-touch-startup-image">`. ## Web push on iOS 16.4+ Web push works on iOS, but only inside an installed PWA. You cannot ask for notification permission until the user has added your site to their home screen and launched it from there. Request permission on the first in-app interaction, not on load. ## What breaks the flow - Being opened inside another app (Instagram, TikTok, LinkedIn) — the in-app browser hides the Add to Home Screen option. Show a "Open in Safari" banner. - Being visited in Chrome iOS or Firefox iOS — same story. - A missing manifest `start_url` — the installed icon opens to whatever URL was active during install. ## Skip the plumbing InstantPWA detects iOS Safari automatically and shows a clean, native-looking install guide overlay — including a step-by-step animation of the share sheet — so your visitors never miss the flow. --- # Getting a PWA to Lighthouse 100 without gaming the audit Source: https://instantpwa.com/blog/pwa-performance-lighthouse-100 Published: 2026-05-25 Tags: Performance, Lighthouse, Core Web Vitals > The real work behind a 100 Performance + 100 PWA Lighthouse score — concrete optimisations that also make production users faster. ## TL;DR - Ship <100 KB of critical CSS + JS. Everything else lazy-loads. - Serve HTML from the edge with a 200ms TTFB budget. - Precache exactly the shell — icons, manifest, first HTML — nothing else. A Lighthouse 100 is not the goal; a faster real-world experience is. The work that produces the score also produces the improvement. Here’s the shortlist that we use on client audits. ## TTFB < 200ms Serve HTML from a CDN edge (Cloudflare, Vercel, Netlify). Origin-only sites cap at ~600ms TTFB in most geographies, which caps your LCP. ## Critical CSS < 30 KB inline Extract above-the-fold CSS at build time and inline it in the head. Load the rest with `media="print" onload="this.media='all'"`. Most Tailwind-based sites can hit 12–18 KB critical. ## Preload one font, subset it ``` <link rel="preload" href="/inter-var.woff2" as="font" type="font/woff2" crossorigin> ``` Subset to Latin (or Latin + your primary user locale). A 200KB font file becomes 30KB. ## Ship images that render at their intrinsic size Use `<img srcset>` with 1x/2x sources. Give every image explicit `width` and `height` to reserve space — CLS goes to 0. Serve AVIF with a WebP fallback. ## Defer non-critical JS - Third-party analytics: `<script async>` and only load after `load`. - Chat widgets: load on idle (`requestIdleCallback`) or first user interaction. - Framework hydration: prefer islands or partial hydration (Astro, Qwik, Fresh) for content-first pages. ## PWA audit specifics - Manifest must include name, short_name, icons (192 + 512 maskable), start_url, display, background_color, theme_color. - Service worker must handle a `fetch` for `start_url`. - Meta `viewport`, `theme-color`, and Apple touch icon all present. - HTTPS. ## Auditing in CI Run Lighthouse CI on every PR. Set budgets: LCP < 1.8s, CLS < 0.05, TBT < 100ms. Fail the build on regression. The 100 score matters less than the trendline never going down. --- # How to increase your PWA install rate (14 tactics that actually work) Source: https://instantpwa.com/blog/increase-pwa-install-rate Published: 2026-05-22 Tags: PWA, Conversion, Growth > Concrete, tested tactics to push PWA install rate from under 1% to 5–15% — timing, copy, targeting, iOS handling and the metrics that matter. ## TL;DR - The default browser prompt converts at under 1%; a well-timed in-page popup converts at 5–15%. - Trigger on intent (2nd pageview, 30s dwell, key action) — never on first load. - On iOS you must render your own share-sheet guide; the browser will never help you. Most sites that "have a PWA" convert less than 1% of visitors into installs. The site is technically installable — the visitor just never sees why they should. Here are the 14 tactics that consistently move the needle. ## Timing - Show the install popup on the second pageview, not the first. - Wait 20–30 seconds of dwell before firing. - Trigger after a key action: item saved, post read, cart populated. - Never fire during the checkout or signup flow. ## Copy - Lead with the user benefit, not the technology: "Save this for one tap next time" beats "Install our web app". - Use a single verb CTA: Install, Add to home screen, Save. - Show your app icon in the popup so visitors preview what will appear on their device. ## Targeting - Show only to returning visitors — they’ve already qualified themselves. - Suppress in in-app browsers (Instagram, TikTok, LinkedIn) and prompt "Open in Safari" instead. - Frequency-cap: at most once per visitor per 7 days. ## Platform quirks - Render your own iOS Safari share-sheet guide; there is no automatic install prompt on iOS. - Detect Android Chrome and reuse the `beforeinstallprompt` event instead of duplicating UI. - Detect standalone (`display-mode: standalone`) and suppress the popup for already-installed users. ## Measure the one metric that matters - Install-to-impression ratio. Not clicks, not opens — the ratio of people who saw the popup to those who completed the install. Below 3% means the trigger is wrong; below 1% means visitors don’t see it at all. InstantPWA ships every one of these tactics as defaults in the popup engine — you toggle the ones you want. --- # PWA storage limits: what you actually get in 2026 Source: https://instantpwa.com/blog/pwa-storage-quota-limits Published: 2026-05-15 Tags: Storage, PWA, Browsers > IndexedDB, Cache API and OPFS quotas across Chrome, Safari, Firefox and Edge — with the eviction rules that decide what survives. ## TL;DR - Chrome and Edge grant up to 60% of disk to a single origin, evicted LRU. - Safari caps at ~1 GB per origin and evicts after 7 days of no use. - Installed PWAs get "persistent" storage on request — immune to LRU. Storage quotas are the most misquoted numbers on the web. The truth in 2026 is generous everywhere — with an asterisk on Safari. Here’s the current shape. ## Chrome, Edge, Opera (Chromium) Total quota per origin: up to 60% of the device’s total disk. Eviction: least-recently-used when the browser is under pressure. Storage backends counted: IndexedDB, Cache API, File System Access (OPFS), Service Worker registrations. ## Safari (iOS + macOS) Cap per origin: ~1 GB, negotiable up to more with user prompt (rare). Eviction: 7-day inactivity clears IndexedDB and Cache API for non-installed sites. Installed PWAs skip the 7-day rule. ## Firefox Group limit: 20% of disk shared across an eTLD+1 group. Per-origin: 2 GB soft cap. Eviction: LRU under pressure. ## Request "persistent" ``` const granted = await navigator.storage.persist(); // true = your quota won’t be evicted automatically ``` Chrome auto-grants for installed PWAs. Firefox prompts. Safari doesn’t expose the API but installed PWAs get equivalent treatment. ## Check available quota ``` const { quota, usage } = await navigator.storage.estimate(); console.log(`${(usage / quota * 100).toFixed(1)}% used`); ``` ## Design implications - Don’t assume any specific limit — check `estimate()` and degrade. - For anything the user would lose sleep over, sync to the server before caching locally. - OPFS is the right home for large binary blobs (video, audio, files) — not IndexedDB. --- # Service worker caching strategies, ranked by real-world use Source: https://instantpwa.com/blog/service-worker-caching-strategies Published: 2026-05-10 Tags: Service Worker, Performance, PWA > A pragmatic ranking of service worker caching patterns — cache-first, network-first, stale-while-revalidate — with the exact scenarios each one wins. ## TL;DR - Stale-while-revalidate is the correct default for 80% of assets. - Cache-first only for immutable versioned assets (hashed JS/CSS). - Network-first with a timeout is right for HTML documents. Every service worker tutorial lists the same five caching strategies as if they were peers. In practice, three of them matter and each maps to a specific asset type. Here’s how to pick. ## Stale-while-revalidate (default) Serve from cache immediately, then fetch in the background to update. Best for images, fonts, JSON APIs and CSS that isn’t content-hashed. Users see instant loads; the next visit gets the fresh version. ## Cache-first (versioned assets only) Use only when a filename change guarantees a content change — e.g. Vite/Webpack hashed `app.9f3d.js`. Cache forever; safe because the URL itself changes on redeploy. ## Network-first with timeout (HTML) Try the network for 2–3 seconds, fall back to cache. HTML is the wrong place to cache aggressively — visitors expect fresh content on the top-level document. ## Anti-patterns - Cache-only in production. If the cache is missing an asset, the page silently breaks. - Network-only for offline-critical routes. Defeats the point of a service worker. - Precaching everything. Pushes install size past the mobile data budget and stalls the first render. ## Workbox versus hand-rolled If you’re shipping a real product, use Workbox. It handles cleanup, versioning and expiration correctly. Hand-roll a service worker only for the two-file demo you’re going to throw away. --- # Web push vs native push: what actually differs in 2026 Source: https://instantpwa.com/blog/web-push-vs-native-push Published: 2026-05-08 Tags: Web Push, Native, Notifications > Feature-by-feature comparison of Web Push (Push API) and native APNs/FCM — latency, payload size, rich media, background updates and opt-in ceilings. ## TL;DR - Delivery latency is identical — both hop through APNs/FCM under the hood. - Web Push payloads cap at 4 KB; native APNs cap at 4 KB too. - Native beats Web Push on background silent updates and rich Live Activities. The "native pushes are better" claim usually rests on outdated information. In 2026 the delivery infrastructure is the same; the differences are at the edges. Here’s the honest breakdown. ## Delivery pipeline Web Push on Chrome/Edge/Android → FCM. Web Push on Safari (macOS/iOS) → APNs. Native iOS → APNs. Native Android → FCM. Same pipes, same physics. ## Payload size Web Push and APNs both cap around 4 KB per message. FCM technically allows more but throttles above 4 KB. If you need to ship 20 KB, encode a URL and fetch in the service worker `push` handler. ## Rich media - Web Push supports `image`, `actions`, `badge`, `vibrate` — works on Chrome and Firefox. Safari ignores image and actions. - Native supports rich attachments, provisional notifications and Live Activities — Web Push has none of these. ## Background updates Native APNs supports silent (`content-available`) pushes to update app state in the background. Web Push requires `userVisibleOnly: true` in practice — Chrome enforces user-visible or your quota drops. ## Opt-in ceiling Native iOS: system prompt on first launch, opt-in typically 40–60%. Web Push on installed PWAs: 20–40%. Web Push on plain websites: 5–15%. The install gate matters. ## Cost Both are free at the platform level. The cost is your backend (topic storage, segmentation, delivery service). InstantPWA and OneSignal both charge on subscribers; native services like Braze charge per MAU. ## When to prefer each - Web Push — web-first product, want zero binary maintenance, users mainly on desktop or Android. - Native — iOS-heavy audience needing Live Activities, silent updates, or App Clip integration. --- # The Background Sync API in production Source: https://instantpwa.com/blog/background-sync-api-guide Published: 2026-04-30 Tags: Background Sync, Service Worker, Offline > How to use Background Sync and Periodic Background Sync to make offline writes reliable — with browser support caveats and the fallback for Safari. ## TL;DR - Background Sync retries a failed write when connectivity returns — supported in Chromium. - Periodic Background Sync fires roughly every 12h — Chromium desktop and Android only. - Safari has neither — fall back to a foreground flush on online. Background Sync is the missing piece in every "offline-first" tutorial. Without it, a queued write depends on the user reopening your tab. With it, the browser guarantees the flush the moment the network is back. ## One-shot sync ``` // Page code const reg = await navigator.serviceWorker.ready; await reg.sync.register('flush-outbox'); ``` ``` // Service worker self.addEventListener('sync', (event) => { if (event.tag === 'flush-outbox') { event.waitUntil(flushOutbox()); } }); ``` The browser fires `sync` when it detects connectivity. Runs even if your tab is closed — the service worker wakes for the event. ## Periodic sync ``` const status = await navigator.permissions.query({ name: 'periodic-background-sync' }); if (status.state === 'granted') { await reg.periodicSync.register('refresh-feed', { minInterval: 12 * 60 * 60 * 1000 }); } ``` Fires roughly every N hours when the app is installed and the device is on Wi-Fi + charging. Great for daily content refresh; useless for real-time. ## Browser support - Chrome, Edge, Opera: full support. - Samsung Internet: one-shot only. - Firefox, Safari: neither. Use fallback. ## Fallback strategy ``` if ('sync' in registration) { await registration.sync.register('flush-outbox'); } else { window.addEventListener('online', flushOutbox); } ``` ## Making it reliable - Keep the queue idempotent — sync can fire twice for the same tag. - Retry with exponential backoff inside `flushOutbox`; don’t re-register on failure. - Cap queue size to bound worst-case memory. - Log a metric on every successful flush — you’ll see the reliability curve. --- # PWA SEO: what changes, what doesn’t, and what breaks Source: https://instantpwa.com/blog/pwa-seo-guide Published: 2026-04-28 Tags: SEO, PWA, Rendering > A grounded guide to SEO for Progressive Web Apps — what Google actually indexes in 2026, the SSR/CSR trade-off, and the four mistakes that tank rankings. ## TL;DR - Google renders JavaScript, but slowly — SSR or SSG still wins on ranking speed. - A PWA doesn’t hurt SEO if the URLs stay crawlable and canonical. - Client-side routing without proper History API + canonical tags is the #1 killer. The myth that "PWAs are bad for SEO" comes from 2016-era single-page apps that shipped an empty `<div id="app">`. In 2026 the story is different: Googlebot renders JavaScript reliably, and every serious framework ships SSR. Here’s what actually matters. ## What Google indexes Googlebot does a two-pass render: an HTML pass, then a JS pass after a queue delay. Bing and other engines are less reliable. The safe rule is: whatever you want indexed must be present in the first HTML response. ## SSR / SSG versus CSR - SSR/SSG — required for organic-driven pages: landing pages, blog posts, product pages, docs. - CSR — fine for authenticated app surfaces that don’t need to rank. ## The four mistakes that tank rankings - Hash routing. `example.com/#/pricing` is one URL to Google. Use History API paths. - Missing canonicals. A PWA that swaps content client-side needs a per-route `<link rel="canonical">` that self-references. - Blank first paint. If the HTML response is empty, ranking speed collapses even if the page eventually renders. - Duplicate og:image on every route. A single root-level og:image overrides your per-page share cards — set og:image at the leaf route. ## What doesn’t change Everything you already know about SEO: intent-matched titles, useful descriptions, internal linking, fast LCP, unique content. A PWA doesn’t change the fundamentals; it just adds a rendering discipline. ## What a PWA can help with Core Web Vitals. Once a PWA is installed, TTFB is effectively zero on repeat visits (service worker cache), and INP improves because you’ve shipped fewer bytes on the critical path. Google factors CWV into ranking, so the second-visit performance boost has a compounding effect. --- # Web Share Target: register your PWA as a share destination Source: https://instantpwa.com/blog/web-share-target-api Published: 2026-04-20 Tags: Web Share, Manifest, Android > Turn your PWA into a first-class share target on Android and ChromeOS — accept text, URLs, images and files from the system share sheet. ## TL;DR - Add share_target to your manifest — your PWA appears in the Android share sheet. - Accept text, url, or files (single or multi). - iOS Safari does not support share_target — use Web Share for outbound sharing instead. The system share sheet is the highest-intent surface on a mobile OS — someone actively wants to send content somewhere. Adding your PWA to that list is a 10-line manifest change. ## Register in the manifest ``` { "share_target": { "action": "/share", "method": "POST", "enctype": "multipart/form-data", "params": { "title": "title", "text": "text", "url": "url", "files": [{ "name": "image", "accept": ["image/*"] }] } } } ``` ## Handle the incoming POST Your service worker intercepts the POST to `/share`. Read the FormData, stash it in IndexedDB, then redirect to a UI page: ``` self.addEventListener('fetch', (event) => { const url = new URL(event.request.url); if (event.request.method === 'POST' && url.pathname === '/share') { event.respondWith((async () => { const form = await event.request.formData(); const payload = { title: form.get('title'), text: form.get('text'), url: form.get('url'), image: form.get('image'), }; const cache = await caches.open('share'); await cache.put('/share-payload', new Response(JSON.stringify(payload))); return Response.redirect('/share-view', 303); })()); } }); ``` ## Testing Install the PWA on an Android device, share any content from Chrome or the gallery, and your app appears in the sheet. Chrome DevTools → Application → Manifest validates the share_target JSON before you install. ## Common pitfalls - Using GET when you need to accept files (they only work over multipart POST). - Redirecting to a route that isn’t cached — fails offline. - Expecting iOS support — it doesn’t exist. Use the Web Share API for outbound sharing on iOS. --- # Turn a Next.js app into an installable PWA (2026) Source: https://instantpwa.com/setup/nextjs Updated: 2026-07-07 > Add a Web App Manifest, service worker and install prompt to any Next.js 14+ app — App Router and Pages Router, with working code. A Next.js app becomes an installable PWA once it serves a Web App Manifest, registers a service worker and shows an install prompt at a high-intent moment. This guide covers both the App Router and the legacy Pages Router, works on Vercel and self-hosted deployments, and takes about 15 minutes end-to-end. ## Key takeaways - Ship /manifest.webmanifest from the /app or /public folder — Next.js serves it as-is. - Register a small service worker from a client component after mount. - iOS Safari never fires beforeinstallprompt — render the share-sheet guide manually. - Drop a hosted install popup in so you never have to write UI code. ## Steps 1. **Add the manifest to /public** — Place manifest.webmanifest in /public so it is served at the origin root. Next.js does not process it. 2. **Link the manifest from the root layout** — In the App Router, add the link tag inside app/layout.tsx metadata; in the Pages Router, use next/head inside _document.tsx. 3. **Register the service worker on the client** — Create a small client component that registers /sw.js after mount, then render it once at the root. 4. **Add the install prompt** — Either roll your own beforeinstallprompt UI (Chromium only) or drop InstantPWA in to get cross-platform prompts including iOS instructions. ## Gotchas - Next.js sometimes caches manifests at the CDN edge — bump the URL with a query string when you change icons. - The service worker scope is the folder the file is served from. Keep sw.js at the origin root, never under /app or /_next. - In dev, Chrome disables install prompts on http://localhost after several dismissals — test on a real HTTPS preview. --- # Turn an Astro site into an installable PWA (2026) Source: https://instantpwa.com/setup/astro Updated: 2026-07-07 > Complete Astro 4+ recipe for shipping a manifest, service worker and install popup — works with static output and SSR adapters. Astro sites become installable PWAs by adding a Web App Manifest to /public, registering a service worker in a small client-side script and rendering an install prompt. The recipe works identically for static output, SSR adapters (Vercel, Node, Cloudflare) and hybrid modes. ## Key takeaways - Astro serves /public verbatim — drop manifest.webmanifest there. - Register the service worker with a `client:load` script tag on the layout. - iOS support is manual: detect standalone mode and render the share-sheet guide. - Use a hosted install popup to avoid writing prompt UI in Astro islands. ## Steps 1. **Place manifest and sw.js in /public** — Astro serves these unchanged at the site root. 2. **Link the manifest from your base layout** — In src/layouts/Layout.astro, add the manifest and theme-color tags. 3. **Register the service worker** — Add a small inline script inside . Astro will not process it. 4. **Ship the install prompt** — Drop the InstantPWA snippet into Layout.astro for cross-platform install UI. ## Gotchas - Astro does not bundle files in /public. Do not import sw.js — reference it by URL. - If you use view transitions, register the worker inside astro:page-load so it survives client-side nav. --- # Turn a SvelteKit app into an installable PWA (2026) Source: https://instantpwa.com/setup/sveltekit Updated: 2026-07-07 > SvelteKit PWA setup with manifest, service worker via the built-in $service-worker module and install prompt. SvelteKit ships a first-class service-worker slot at src/service-worker.ts and serves static assets from /static. Combine the two with a manifest link in app.html and your SvelteKit app is installable in under 20 minutes. ## Key takeaways - Create src/service-worker.ts — SvelteKit builds and registers it automatically. - Serve manifest.webmanifest from /static. - iOS install needs a manual share-sheet card; SvelteKit does not provide one. - A hosted popup avoids Svelte-specific UI state. ## Steps 1. **Add manifest to /static** — Drop manifest.webmanifest inside /static — SvelteKit serves the folder at /. 2. **Add the built-in service worker** — Create src/service-worker.ts. SvelteKit generates a versioned build ID and registers the worker for you. 3. **Link manifest from app.html** — Add the manifest and theme-color tags to src/app.html. 4. **Add the install popup** — Drop the InstantPWA script into app.html to get iOS + Android + desktop prompts. ## Gotchas - Set kit.serviceWorker.register to false only if you register manually — otherwise you get two registrations. - During dev, SvelteKit skips the service worker. Test install on a preview build (`vite build && vite preview`). --- # Turn a Nuxt 3 app into an installable PWA (2026) Source: https://instantpwa.com/setup/nuxt Updated: 2026-07-07 > Nuxt 3 PWA guide — manifest, service worker via @vite-pwa/nuxt, iOS install and hosted install popup. Nuxt 3 has excellent PWA support through the @vite-pwa/nuxt module. Add the module, configure the manifest inline in nuxt.config, and drop an install prompt on top for the cross-platform install moment the module does not handle. ## Key takeaways - @vite-pwa/nuxt generates the manifest and service worker for you. - Register-type = autoUpdate keeps the worker in sync without user prompts. - Nuxt does not solve iOS install — use InstantPWA or write a share-sheet card yourself. ## Steps 1. **Install the module** — Run `pnpm add -D @vite-pwa/nuxt` and add it to modules in nuxt.config.ts. 2. **Configure the manifest** — All PWA config lives under the `pwa` key in nuxt.config.ts. The module writes manifest.webmanifest and sw.js at build time. 3. **Add the install popup** — Drop InstantPWA into app.vue for iOS + Chromium install UI. ## Gotchas - In dev, set devOptions.enabled = true or the worker never registers. - The module places sw.js at /sw.js — do not put a second service worker in /public or scopes will conflict. --- # Turn a Remix app into an installable PWA (2026) Source: https://instantpwa.com/setup/remix Updated: 2026-07-07 > Remix PWA setup — manifest in /public, service worker with the Remix loader-aware pattern, install prompt. Remix (and React Router 7 framework mode) has no first-party PWA module, but the pattern is short: manifest in /public, service worker registered from root.tsx, install prompt via a small effect or a hosted embed. ## Key takeaways - /public is served verbatim — perfect for manifest and sw.js. - Register the worker inside a useEffect in root.tsx. - Remix data revalidation still works when the worker is a passthrough fetch handler. ## Steps 1. **Add manifest to /public** — Remix serves /public at the origin root. 2. **Link manifest from root.tsx** — Use the links export. 3. **Register the worker** — Add a client-only effect in the root component. 4. **Add the install popup** — Drop the InstantPWA snippet into your root . ## Gotchas - Do not cache Remix loader responses in the SW — they are POSTs on client navigations and include revalidation semantics. - If you use Cloudflare Workers as your Remix runtime, make sure sw.js is served by static assets, not the Worker itself. --- # Turn a WordPress site into an installable PWA (2026) Source: https://instantpwa.com/setup/wordpress Updated: 2026-07-07 > Add PWA install to any WordPress theme — manifest via functions.php, service worker plugin, and a one-line install popup. WordPress sites become installable PWAs by adding a manifest link to the theme header, uploading a service worker to the root and pasting the InstantPWA embed into the site header. No plugin is required, though a plugin can help with icon generation. ## Key takeaways - Upload manifest.webmanifest and sw.js to the WordPress root (SFTP or file manager). - Add the manifest link via functions.php or an Insert Headers plugin. - Install analytics beat WordPress plugin dashboards — use InstantPWA to see real numbers. ## Steps 1. **Upload manifest and sw.js** — Place both files at /wp-content/../ (the site root). 2. **Link the manifest** — Add to your theme functions.php (or use Insert Headers and Footers). 3. **Add the install popup** — Paste the InstantPWA snippet into your header — no plugin needed. ## Gotchas - Caching plugins (WP Rocket, W3 Total Cache) can serve stale manifests. Purge cache after any change. - Some WordPress hosts strip the `.webmanifest` MIME type. Test with `curl -I` — you should see `application/manifest+json`. --- # Turn a Shopify storefront into an installable PWA (2026) Source: https://instantpwa.com/setup/shopify Updated: 2026-07-07 > Add PWA install to any Shopify theme — Liquid manifest link, service worker via the asset pipeline, install popup. Shopify does not offer a native PWA toggle, but any Online Store 2.0 theme can be made installable in about 10 minutes. Upload manifest and service-worker assets, link them from theme.liquid, and drop an install popup that respects the storefront cart context. ## Key takeaways - Use Shopify Files or the theme /assets folder for manifest and sw.js. - The service worker must be served from the root — Shopify supports app-proxy routes for this. - Install popups on product pages convert 3–5× better than global. ## Steps 1. **Upload manifest and sw.js as Files** — Content → Files, then reference the CDN URL from theme.liquid. 2. **Link the manifest** — Inside in theme.liquid, output the manifest URL. 3. **Add the install popup** — Paste the InstantPWA snippet before in theme.liquid. ## Gotchas - Shopify serves storefront assets from cdn.shopify.com — some browsers refuse to install unless the service worker is on the same origin as the page. Use an app-proxy route to serve sw.js from your myshopify domain root. - Checkout runs on shopify-checkout.com and cannot be part of the PWA scope. --- # Turn a Webflow site into an installable PWA (2026) Source: https://instantpwa.com/setup/webflow Updated: 2026-07-07 > Add PWA install to any Webflow project — custom code, manifest hosting and a one-line install popup. Webflow does not let you upload arbitrary files, so PWA setup uses Site Settings → Custom Code plus an external asset host for manifest and service worker. InstantPWA handles the install prompt without touching Webflow structure. ## Key takeaways - Host manifest.webmanifest and sw.js on a CDN or external subdomain. - Wire them up via Site Settings → Custom Code. - The install popup can be added by pasting one script tag — no Webflow interactions required. ## Steps 1. **Host manifest + sw.js on your domain** — Webflow does not serve arbitrary files. Use Cloudflare Pages, Netlify or your existing CDN under the same origin as your Webflow site (via reverse proxy). 2. **Paste head code** — Site Settings → Custom Code → Head Code. 3. **Add the install popup** — Below the register script, paste the InstantPWA embed. ## Gotchas - The service worker must be same-origin. A different subdomain will register but browsers will not prompt for install. - Webflow custom code has a 10,000 character limit per section. --- # Turn a React (Vite) app into an installable PWA (2026) Source: https://instantpwa.com/setup/react Updated: 2026-07-07 > Vite + React PWA setup — manifest, service worker, install prompt. Works with SPA and multi-page Vite apps. A Vite-powered React app is one of the fastest stacks to make installable. Add vite-plugin-pwa (or roll your own with a public/ manifest and sw.js), then either write the install prompt yourself or drop the InstantPWA embed. ## Key takeaways - vite-plugin-pwa generates manifest and service worker at build time. - For hand-rolled setups, /public is served at the origin root. - React 18 strict mode double-invokes effects — guard your SW register. ## Steps 1. **Install vite-plugin-pwa** — Run `npm i -D vite-plugin-pwa` and add it to plugins in vite.config.ts. 2. **Configure the manifest** — The plugin accepts the manifest inline and writes it at build time. 3. **Add the install popup** — Paste the InstantPWA embed into index.html to skip writing prompt UI. ## Gotchas - React strict mode calls useEffect twice — always check for an existing registration before calling register. - HMR does not reload the service worker. After changing sw.js, do a full reload. --- # Turn a Vue 3 app into an installable PWA (2026) Source: https://instantpwa.com/setup/vue Updated: 2026-07-07 > Vue 3 PWA setup — manifest, service worker, install prompt. Works with Vue CLI, Vite and Nuxt. A Vue 3 app becomes installable with the same three ingredients as any PWA: manifest, service worker, install prompt. The Vue CLI PWA plugin (or vite-plugin-pwa for Vite-based projects) handles the first two; the third is where InstantPWA fits. ## Key takeaways - Vite + vite-plugin-pwa is the modern default. - The Vue CLI PWA plugin still works for legacy projects. - Use a hosted install popup to avoid managing prompt state in Pinia. ## Steps 1. **Add vite-plugin-pwa** — For Vite: install and add to plugins. 2. **Configure the manifest** — Pass the manifest inline. The plugin writes it at build time. 3. **Add the install popup** — Drop the InstantPWA script into index.html. ## Gotchas - If you use Vue Router with history mode, make sure your host serves index.html for unknown routes — otherwise the installed app 404s on deep links. --- # Turn an Angular app into an installable PWA (2026) Source: https://instantpwa.com/setup/angular Updated: 2026-07-07 > Angular 17+ PWA setup with ng add @angular/pwa, manifest configuration and an install popup. Angular has first-class PWA tooling through @angular/pwa. One command adds the manifest, the service worker (ngsw) and a build-time integration. Then all that is left is the install prompt. ## Key takeaways - `ng add @angular/pwa` wires up manifest + ngsw automatically. - ngsw is more strict than a hand-rolled worker — it manages versioned caches for you. - InstantPWA solves the cross-platform install UI ngsw does not provide. ## Steps 1. **Run ng add @angular/pwa** — Angular CLI generates manifest.webmanifest and wires ngsw-worker.js into your build. 2. **Edit manifest.webmanifest** — Update name, short_name, theme_color and icons. 3. **Add the install popup** — Paste the InstantPWA snippet into index.html . ## Gotchas - ngsw refuses to activate on http:// origins other than localhost. Deploy to HTTPS before testing. - Do not manually register a second sw.js — ngsw registers itself. --- # Turn a Rails app into an installable PWA (2026) Source: https://instantpwa.com/setup/rails Updated: 2026-07-07 > Rails 7+ PWA setup — manifest via public/, service worker with Turbo compatibility and install prompt. Rails 7 (and Rails 8) ships PWA scaffolding via `bin/rails g pwa`. It generates a manifest, a Turbo-friendly service worker and an ERB layout partial. Combine it with a hosted install popup for cross-platform prompts. ## Key takeaways - `bin/rails g pwa` scaffolds manifest and sw.js. - Turbo Drive plays nicely with a passthrough service worker. - InstantPWA handles iOS Safari, which Rails does not. ## Steps 1. **Generate the PWA files** — Run `bin/rails g pwa` to scaffold manifest.json and service-worker.js under public/. 2. **Link them from application.html.erb** — The generator adds the tags automatically. 3. **Add the install popup** — Drop the InstantPWA snippet into your layout head. ## Gotchas - Turbo drives page transitions client-side. Do not cache full HTML in the SW — cache asset URLs only. - Rails hosts (Heroku, Fly) sometimes gzip .webmanifest. Ensure the Content-Type stays application/manifest+json. --- # What is a PWA? Source: https://instantpwa.com/answers/what-is-a-pwa Updated: 2026-07-07 A PWA (Progressive Web App) is a regular website that meets three technical criteria — HTTPS, a Web App Manifest and a service worker — so browsers let visitors install it on their home screen. Once installed, it launches like a native app, works offline and can send push notifications. ## What makes a website a PWA The web platform defines a PWA as any site that (1) is served over HTTPS, (2) links a valid manifest.webmanifest file describing its name, icons and display mode, and (3) registers a service worker. Any site can add these three ingredients — there is no framework requirement. ## What a PWA can do that a normal website cannot Install to home screen with a real icon, launch in a standalone window without browser chrome, work offline via cached responses, receive web push notifications, and re-engage users with badging on supported platforms. ## What a PWA cannot do Access some deep hardware APIs (NFC on iOS, background execution beyond limited quotas), and it is not distributed in the App Store or Play Store by default (though PWABuilder can package one). --- # Can a PWA send push notifications on iOS? Source: https://instantpwa.com/answers/can-pwa-send-push-notifications-ios Updated: 2026-07-07 Yes. Since iOS 16.4 (March 2023), a PWA can send Web Push notifications on iPhone and iPad — but only after the user installs it to the home screen. Push in a regular Safari tab is not supported, and the user must explicitly grant notification permission from inside the installed PWA. ## The install-first rule On iOS, permission for push is only requested after the PWA is running in standalone mode. Requesting Notification.permission from a Safari tab returns "denied" immediately. ## What you need to ship A valid manifest with icons, a service worker that handles the `push` event, and a subscription flow that calls PushManager.subscribe() with your VAPID public key. iOS honours standard Web Push — no APNS certificate required. ## Deliverability on iOS iOS uses APNS under the hood but the developer surface is standard Web Push. Silent notifications are not supported — every push must be user-visible or iOS revokes the subscription. --- # Do PWAs work offline? Source: https://instantpwa.com/answers/do-pwas-work-offline Updated: 2026-07-07 PWAs can work offline, but only for content their service worker has explicitly cached. Registering a service worker does not automatically make a site offline-capable — you decide what to cache (app shell, API responses, images) and what strategy to use (cache-first, network-first, stale-while-revalidate). ## How offline actually works The service worker intercepts every fetch and can respond from the Cache Storage API without going to the network. Anything not in the cache still fails when offline unless you fall back to an offline HTML page. ## The three common patterns App-shell caching (fast, works for static parts of the UI). Runtime caching (cache API responses as they are requested). Precaching (list of URLs cached at install — great for critical assets). ## Storage limits Cache Storage shares quota with IndexedDB — usually hundreds of MB on mobile, GB on desktop. Browsers evict least-recently-used origins under pressure. --- # PWA vs native app: what does each cost? Source: https://instantpwa.com/answers/pwa-vs-native-app-cost Updated: 2026-07-07 Building a PWA typically costs 30-50% of an equivalent native iOS + Android app because you ship one codebase to three platforms (iOS, Android, desktop). Maintenance is roughly one-fifth: no app-store review, no separate release trains, no platform-version fragmentation. ## Where PWAs save money Single codebase; instant updates without store approval; no $99/year Apple developer fee for distribution outside the store; no Google Play cut on transactions handled off-platform. ## Where native still wins Games, AR/VR, deep background sync, App Store discovery on iOS (still the dominant install surface for many consumer categories). ## When to pick each Utility, content, SaaS, ecommerce → PWA usually wins on cost and time-to-market. Consumer social with heavy platform integrations → native or hybrid still makes sense. --- # How do you uninstall a PWA? Source: https://instantpwa.com/answers/how-to-uninstall-pwa Updated: 2026-07-07 On iPhone and Android, uninstall a PWA by long-pressing its home-screen icon and choosing "Delete" or "Uninstall". On Windows and macOS, open the installed PWA, click the three-dot menu in the title bar and choose "Uninstall". The site itself is not affected — only the installed shortcut and its service worker cache. ## iPhone & iPad Long-press the icon → "Remove App" → "Delete App". This clears the PWA, its cache and its notification permissions. ## Android Long-press the icon → "Uninstall" (or drag it to the uninstall bin at the top of the screen). ## Windows & macOS (Chrome/Edge) Open the PWA, click the three-dot menu → "Uninstall". Or visit chrome://apps and right-click. --- # Are PWAs in the App Store? Source: https://instantpwa.com/answers/are-pwas-in-app-store Updated: 2026-07-07 PWAs are not in the App Store or Play Store by default — they install directly from the browser. If you want store presence, PWABuilder (from Microsoft) packages a PWA into a Trusted Web Activity for Google Play, an MSIX for Microsoft Store, and a WKWebView wrapper you can submit to Apple. ## The install surfaces available today Chrome, Edge, Samsung Internet, Brave and Safari (via Share Sheet) all install PWAs directly from the page. Distribution happens on your site. ## When store distribution matters Consumer apps where users still search the App Store first. B2B tools rarely need it. ## The trade-off Store distribution means review cycles, store fees for in-app purchase, and slower updates. Direct install skips all of that. --- # Why is my PWA install prompt not showing? Source: https://instantpwa.com/answers/why-is-my-install-prompt-not-showing Updated: 2026-07-07 Chrome shows the install prompt only when the site passes strict installability criteria: HTTPS, a valid manifest with name, icons and start_url, a registered service worker with a fetch handler, and the user has not previously dismissed the prompt. Any one of these missing is enough to block the prompt entirely. ## The Chrome installability checklist Open DevTools → Application → Manifest. Chrome lists exactly which criterion is failing. The most common failures: (1) icons not 192px and 512px, (2) manifest not linked from every route, (3) service worker missing a fetch listener, (4) HTTPS with a self-signed certificate. ## Silent throttling If a user dismisses the prompt twice, Chrome silently backs off for months. Test in a fresh incognito profile. ## iOS never fires beforeinstallprompt This is not a bug. On iOS you must render your own share-sheet guide or use a hosted install popup that handles the platform detection for you. --- # What are the storage limits for a PWA? Source: https://instantpwa.com/answers/pwa-storage-limits Updated: 2026-07-07 A PWA typically gets 60% of the device disk space on Chrome and Edge (up to hundreds of GB), 20% of total quota on Firefox, and around 1 GB on Safari. Cache Storage, IndexedDB and OPFS share the same quota. Browsers evict least-recently-used origins under pressure unless the site requests persistent storage. ## Per-browser limits Chrome/Edge: 60% of disk. Firefox: 20% of free space with a 10 GB per-group cap. Safari 17+: ~1 GB per origin with promptless eviction after 7 days of inactivity. ## Check the current quota Call navigator.storage.estimate() — it returns { quota, usage } in bytes. ## Request persistent storage navigator.storage.persist() returns true if the browser grants it. Persistent storage is not evicted under pressure and is only cleared when the user explicitly deletes site data. --- # Can a PWA access the camera? Source: https://instantpwa.com/answers/can-pwa-access-camera Updated: 2026-07-07 Yes. A PWA can access the camera, microphone, geolocation and file system through the same Web APIs a regular website uses (getUserMedia, showOpenFilePicker, Geolocation). Every capability requires explicit user permission and works cross-platform, though a few APIs (Bluetooth, USB, NFC) are still Chromium-only. ## What works everywhere Camera and microphone (getUserMedia), geolocation, notifications, share sheet, clipboard read/write, screen wake lock. ## What is Chromium-only File System Access API (full read/write), Web Bluetooth, Web USB, Web NFC, contact picker. ## iOS Safari caveats getUserMedia works but requires HTTPS and a user gesture. Screen recording via getDisplayMedia is desktop-Safari only. --- # Does a PWA help or hurt SEO? Source: https://instantpwa.com/answers/pwa-seo-impact Updated: 2026-07-07 A PWA does not directly change your Google ranking. Googlebot indexes your HTML the same whether or not you have a service worker. The indirect effect is Core Web Vitals: repeat visits from installed users have near-zero TTFB and better INP, which improves your CWV score and, over time, ranking. ## What Google indexes Googlebot fetches your rendered HTML. It does not install the PWA and does not experience the offline cache. Your SEO fundamentals (title, description, structured data, links) are unchanged. ## What actually moves the needle PWA installs mean more repeat sessions from a channel Google can measure via Chrome usage data. Faster repeat visits contribute to your site-wide CWV. ## What to avoid Do not put your app shell behind a client-only route with no server HTML — Googlebot may not wait for JS to hydrate. --- # Do PWAs work on iPhone? Source: https://instantpwa.com/answers/do-pwas-work-on-iphone Updated: 2026-07-07 Yes. Since iOS 16.4 (March 2023), iPhone and iPad support the full PWA feature set: install to home screen from Safari, standalone launch, offline via service worker, and Web Push notifications. The install step is manual — Safari does not show a browser prompt; users must tap Share → Add to Home Screen. ## What iOS supports today Standalone mode, service worker with full Cache Storage API, Web Push (installed PWA only), badging, notifications with actions, IndexedDB, camera and microphone. ## What iOS still lacks No beforeinstallprompt event (must use manual share sheet UI), no arbitrary background sync, no OS-level widget parity with native. ## What broke in the EU (and got fixed) In early 2024 Apple briefly removed home-screen PWAs in the EU; that was reverted in 17.4. As of 2026, EU behaviour matches the rest of the world. --- # What are the requirements for the Chrome install prompt? Source: https://instantpwa.com/answers/chrome-install-prompt-requirements Updated: 2026-07-07 Chrome fires beforeinstallprompt when the site is served over HTTPS, links a valid manifest with name, start_url and 192px + 512px icons, registers a service worker with a fetch handler, and passes a user-engagement heuristic (typically one interaction and ~30 seconds of use). Any failing criterion silently blocks the prompt. ## The technical checklist HTTPS. Manifest with name (or short_name), start_url, display "standalone" or "fullscreen", icons at 192px and 512px, background_color and theme_color. A registered service worker whose fetch handler responds to at least the start_url. ## The engagement heuristic Chrome requires a click or tap on the page and, historically, ~30 seconds of active use. This is why beforeinstallprompt often fires late — not on page load. ## The suppression rules If the user dismisses twice, Chrome backs off for 90 days. Testing tip: use a fresh incognito window per attempt. --- # PWA install prompts for ecommerce stores Source: https://instantpwa.com/for/ecommerce Audience: Shopify, WooCommerce, Magento, custom carts > Turn shoppers into repeat buyers with home-screen install prompts. iOS + Android + desktop, one line of code, works on Shopify and WooCommerce. The install moment is the difference between a $12 CAC and a $2 CAC. Every installed shopper is a free retargeting channel — no more retargeting ads, no more chasing email deliverability. Key stat: **2.4×** — higher repeat-purchase rate for installed users vs anonymous returning visitors --- # PWA install prompts for SaaS products Source: https://instantpwa.com/for/saas Audience: B2B SaaS, PLG, developer tools > Get busy operators to install your dashboard on their laptop dock and phone home screen. Higher DAU, lower churn, no native app needed. PLG onboarding conversion peaks in the first session. Installing removes the "did I bookmark this?" friction, which is a leading indicator of activation. Key stat: **+38%** — week-4 retention for accounts with at least one installed user (2025 InstantPWA cohort data) --- # PWA install prompts for news sites and publishers Source: https://instantpwa.com/for/media-publishers Audience: News, magazines, newsletters, creators > Own your audience relationship. Installed readers come back 5-8× per week; browser readers churn to search. Publishers built on referral traffic are one algorithm change from disaster. Installed readers are your resilient audience — worth 5-10× more in lifetime ad revenue than a one-touch visitor. Key stat: **5.6×** — sessions per week from installed readers vs anonymous search visitors --- # PWA install prompts for restaurants and cafés Source: https://instantpwa.com/for/restaurants Audience: Restaurants, cafés, delivery, hospitality groups > Get diners to install your menu — reorders, loyalty and lock-screen offers without paying DoorDash a 30% cut. The margin on a DoorDash order is what remains of a fee-eaten transaction. Installing takes the customer relationship (and the LTV) back onto your own rails. Key stat: **17%** — of second-visit diners install when prompted at the right moment (InstantPWA restaurant cohort) --- # PWA install prompts for agency clients Source: https://instantpwa.com/for/agencies Audience: Digital agencies, product studios, freelancers > Ship a measurable install-and-push feature to every client site in an afternoon. White-label ready, per-tenant analytics. Agencies compete on measurable outcomes. "Install rate went from 0 to 6%" is a slide-ready result you can attach to every retainer. Key stat: **<1hr** — average time to ship the install prompt on a client site --- # PWA install prompts for creators and membership sites Source: https://instantpwa.com/for/creators Audience: Creators, coaches, membership sites, indie makers > Turn fans into installed subscribers. Push notifications, offline access to your library, and no platform cut on push delivery. Creators lose 60% of email deliverability to spam filters within 12 months. Installed users are unfilterable. Key stat: **3.1×** — lift in weekly logins for installed vs email-only subscribers --- # PWA install prompts for real-estate listing sites Source: https://instantpwa.com/for/real-estate Audience: Brokerages, property portals, listing sites > Get high-intent buyers to install your listings — saved-search push, new-listing alerts, no aggregator fee. In a fast market, the first agent to notify a serious buyer wins the tour. Installed users get the alert on their lock screen, not buried in their inbox. Key stat: **4.2×** — saved-search click-through rate for installed buyers vs email --- # PWA install prompts for education and online courses Source: https://instantpwa.com/for/education Audience: Schools, universities, online courses, ed-tech > Students who install come back to finish. Push assignment reminders and drop-back nudges with no app-store approval. The best predictor of finishing a course is coming back to it. Installing removes the "where was that link?" barrier that kills week-two engagement. Key stat: **+52%** — course-completion rate for installed students (LMS partner data) --- # PWA install prompts for healthcare and telehealth Source: https://instantpwa.com/for/healthcare Audience: Clinics, telehealth, digital health, HIPAA > Get patients to install your portal — no app-store approvals, no HIPAA-hostile third parties, real re-engagement. No-show rates are the single biggest revenue leak in outpatient care. Installed patients see reminders on their lock screen, not in an over-full inbox. Key stat: **−34%** — no-show rate after enabling install + appointment push (clinic partner data) --- # PWA install prompts for non-profits Source: https://instantpwa.com/for/non-profits Audience: Charities, NGOs, community organisations > Turn supporters into a recurring push channel — donation reminders, event pushes, community updates, all free forever on our starter plan. Every dollar not spent on outreach is a dollar reaching the mission. Installed supporters are the cheapest re-engagement channel a non-profit has. Key stat: **0¢** — per push notification to your installed supporters --- # Progressier alternative — InstantPWA vs Progressier Source: https://instantpwa.com/alternatives/progressier > Progressier packages your site as a PWA. InstantPWA is the install popup that gets it installed. See where each fits. Progressier and InstantPWA are complementary, not competitors. Progressier is a no-code PWA generator (manifest, icons, service worker). InstantPWA is the install-prompt layer that turns visitors into installed users, with per-page targeting and analytics. When to pick: Use Progressier if you need someone else to write the manifest and service worker. Use InstantPWA when you have the PWA and want to lift install rate. Many teams run both. --- # PushOwl alternative — InstantPWA vs PushOwl Source: https://instantpwa.com/alternatives/pushowl > PushOwl is Shopify-only web push. InstantPWA is cross-platform install + push for any stack. Compare features, pricing and fit. PushOwl is a Shopify-app web-push tool. InstantPWA works on Shopify but also on any other stack (WooCommerce, custom, Rails, Next.js). Install-first onboarding lifts push subscription rates 2-3× because the moment is earned rather than interrupting. When to pick: Use PushOwl if you are Shopify-only and want a marketplace app with abandonment recipes out of the box. Use InstantPWA when you want install-and-push in one, or when your stack is not Shopify. --- # AddToHomeScreen alternative — hosted install popup Source: https://instantpwa.com/alternatives/addtohomescreen > AddToHomeScreen is a maintained npm library. InstantPWA is a hosted service with analytics, A/B tests and a dashboard. Which fits? AddToHomeScreen is a solid open-source library you drop into your build. InstantPWA is a hosted service with a dashboard, per-page targeting, analytics and multi-tenant management. Both cover the same install moment. When to pick: Use AddToHomeScreen if you want zero runtime dependencies and are happy maintaining the library yourself. Use InstantPWA when you want analytics, A/B tests, iOS/Android/Desktop UI, and a dashboard your team can share. --- # SuperPWA alternative for WordPress — InstantPWA Source: https://instantpwa.com/alternatives/superpwa > SuperPWA is a WordPress-only plugin. InstantPWA is a hosted script that works on WordPress and any other stack, with analytics. SuperPWA is a mature WordPress plugin that generates the manifest, service worker and simple install prompt. InstantPWA is stack-agnostic (WordPress, Shopify, Webflow, custom) and adds install analytics, A/B testing and per-page targeting. When to pick: Use SuperPWA if you only run WordPress and want everything managed inside wp-admin. Use InstantPWA when you also run other properties, or want a proper analytics dashboard. --- # PushEngage alternative — InstantPWA Source: https://instantpwa.com/alternatives/pushengage > PushEngage is a push-marketing suite. InstantPWA gets the install first, then push works. Compare both here. PushEngage focuses on push-notification campaigns for existing subscribers. InstantPWA focuses on the install-and-subscribe moment, so more visitors become push-reachable in the first place. They complement each other. When to pick: Use PushEngage if you already have subscribers and need a campaign tool. Use InstantPWA when you want to grow the installed base, or want a lighter-weight prompt UI that does not require full push setup on day one. --- # WonderPush alternative — InstantPWA Source: https://instantpwa.com/alternatives/wonderpush > WonderPush is a push provider. InstantPWA is the install prompt that makes push possible on more visitors. See fit. WonderPush is a French push-notification infrastructure provider. InstantPWA is the install-prompt layer that decides which visitors become push-reachable. Many teams run WonderPush for send infrastructure and InstantPWA for the acquisition surface. When to pick: Use WonderPush if you need enterprise push infrastructure with EU data residency. Use InstantPWA when you want to lift install rate, or want a starting point that includes basic push out of the box. --- # Notix alternative — InstantPWA Source: https://instantpwa.com/alternatives/notix > Notix is an ad-network-adjacent push tool. InstantPWA is a first-party install-and-push service. Compare privacy, control and pricing. Notix's free plan is subsidised by push-ads served alongside your notifications. InstantPWA is a first-party service — you pay for the tool, your users see only your content. When to pick: Use Notix if you are comfortable with ads inside your push channel in exchange for a lower bill. Use InstantPWA when you want a clean first-party channel with no third-party creative. --- # PWABuilder alternative — InstantPWA install popup Source: https://instantpwa.com/alternatives/pwabuilder-microsoft > PWABuilder wraps your PWA for app stores. InstantPWA gets the install directly from the browser. Do you need one, the other, or both? PWABuilder is Microsoft's free tool to package a PWA into a Play Store, Microsoft Store or App Store bundle. InstantPWA is a hosted script for direct in-browser install — no store review, no store fees. Many teams ship both. When to pick: Use PWABuilder if App Store discoverability matters to you. Use InstantPWA for the majority of installs that will always come from your website itself. ---