How Much Does It Cost to Build a Progressive Web App in 2026?

A progressive web app is not just a responsive website with a manifest file slapped on top. A real PWA includes a service worker that intercepts network requests, a web app manifest that enables installation on home screens, and an architecture designed to work reliably on flaky or nonexistent network connections. Those three things alone separate a $5,000 "PWA" from a $100,000 one.

The confusion starts because Google popularized the term broadly, and now every agency claims to build PWAs. Some of them just add a manifest.json and call it done. That gives you an install prompt and nothing else. A production-grade PWA handles offline data sync, background push notifications, precaching of critical assets, and graceful degradation when the network drops mid-transaction.

Why does this matter for your budget? Because the service worker layer is where the real engineering effort lives. Writing a service worker that correctly handles cache invalidation, manages background sync for form submissions, and avoids serving stale data to users is genuinely difficult. Most frontend developers have never written one from scratch. That specialized skill set drives up either the hourly rate or the project timeline, often both.

Before you request quotes, get clear on what "PWA" means for your product. Do you need full offline functionality, or just fast load times on slow connections? Do you need push notifications, or is email sufficient? The answers will move your budget by tens of thousands of dollars.

These numbers reflect 2026 pricing from a competent mid-market development team. Not the cheapest option on Upwork, not a Big Four consultancy. A team that ships production software and stands behind it.

Basic PWA: $15,000 to $40,000

A basic PWA adds installability and smart caching to an otherwise standard web application. You get a web app manifest with icons and theme colors, a service worker that precaches the app shell and static assets, and a "cache-first" strategy for previously visited pages. Users can add the app to their home screen and get a near-instant load on repeat visits.

This tier works well for content-heavy sites, restaurant menus, event apps, internal company portals, and simple e-commerce storefronts. Development takes 4 to 8 weeks. You are essentially building a solid web app (which has its own cost structure, covered in our web app pricing guide) and layering on PWA capabilities.

Frameworks at this level: Next.js with next-pwa, Nuxt with @vite-pwa/nuxt, or SvelteKit with vite-plugin-pwa. These plugins handle most of the service worker generation through Workbox under the hood, which dramatically reduces custom code.

Mid-Tier PWA: $40,000 to $80,000

This is where PWAs start to genuinely replace native apps. Mid-tier PWAs include offline data access (not just cached pages, but actual IndexedDB-backed data stores), push notifications via the Web Push API, background sync for queued user actions, and more sophisticated caching strategies that mix network-first and cache-first depending on the resource type.

Think field service apps where technicians need to fill out inspection forms without cell coverage, then sync when they are back online. Or a sales tool that lets reps browse the product catalog and create quotes on a plane. These use cases demand conflict resolution logic when offline edits collide with server-side changes. That logic alone can eat two to three weeks of development time.

Timeline: 8 to 16 weeks with a team of two to three developers.

Enterprise PWA: $80,000 to $200,000+

Enterprise PWAs are full application platforms that happen to run in the browser. They include everything from the mid tier, plus advanced features: periodic background sync, sophisticated offline-first architectures with CRDT-based conflict resolution, multi-device state synchronization, granular push notification segmentation, deep integration with device APIs (camera, geolocation, Bluetooth via Web Bluetooth), and performance budgets enforced through CI pipelines.

Companies like Starbucks, Pinterest, and Uber have invested at this level. Their PWAs load in under two seconds on 3G connections and function as full replacements for their native apps in many markets. At this tier, you also need dedicated QA for offline scenarios, accessibility audits, and cross-browser testing across Chrome, Safari, Firefox, and Edge (Safari's PWA support has improved significantly but still has quirks).

Timeline: 4 to 9 months. Budget 15 to 20 percent of the build cost annually for ongoing maintenance.

If you take one thing from this article, let it be this: the service worker is the single most expensive component of a PWA, measured in engineering hours per line of code. A poorly written service worker will break your app in ways that are almost impossible for users to fix without clearing their browser cache manually. A well-written one is invisible, fast, and reliable.

Here is what a production service worker needs to handle:

• Precaching: Identifying and caching your app shell (HTML, CSS, JavaScript, fonts, critical images) during installation so the app loads instantly on repeat visits
• Runtime caching: Deciding per-request whether to serve from cache, network, or a combination. API calls for user data typically use network-first. Static assets use cache-first. Images might use stale-while-revalidate.
• Cache versioning: Busting old caches when you deploy new code, without breaking in-progress user sessions
• Background sync: Queuing failed POST/PUT requests and replaying them when connectivity returns, with retry logic and error handling
• Push notification handling: Receiving push events, displaying notifications with actions, and routing users to the correct screen when they tap
• Update flow: Detecting when a new service worker is available and prompting users to refresh, without losing unsaved work

Google's Workbox library handles 70 to 80 percent of this out of the box, and we strongly recommend using it rather than hand-rolling service worker logic. Workbox provides precaching with revision hashing, runtime caching strategies as configurable plugins, and background sync with automatic retry. It integrates directly with Webpack, Vite, and Rollup through build plugins.

Even with Workbox, expect 40 to 80 hours of engineering time for a mid-complexity service worker setup. Without it, double or triple that estimate. The debugging alone is painful because service workers run on a separate thread, have their own lifecycle events, and cache errors can persist across deployments if you are not careful.

This is the question every founder asks, and the honest answer is that a PWA costs 40 to 60 percent less than building native apps for both iOS and Android. But that discount comes with trade-offs you need to understand before committing.

Where PWAs Win on Cost

One codebase instead of three (iOS, Android, web). One team instead of platform-specific specialists. No App Store or Play Store review cycles delaying your releases. No 15 to 30 percent commission on in-app purchases. Instant updates pushed to all users without waiting for them to download a new version. For a mid-complexity app, that translates to $40K-80K for a PWA versus $100K-200K for native iOS plus Android apps.

If you are trying to decide between a PWA and going fully native, our web app vs. mobile app comparison covers the UX and business trade-offs in detail.

Where Native Still Justifies the Cost

Native apps still win when you need tight hardware integration (ARKit, HealthKit, advanced Bluetooth peripherals), when App Store discoverability is a core acquisition channel, when you need the smoothest possible animations at 120fps, or when your user base expects a native app (fintech, health, fitness). PWAs cannot access certain device APIs that native apps take for granted, though the gap shrinks every year.

The Middle Ground: React Native and Flutter

Cross-platform frameworks like React Native and Flutter let you ship to iOS, Android, and (increasingly) the web from a single codebase. They cost more than a PWA but less than fully native development. For a detailed breakdown, check our React Native vs. Flutter comparison. Typical cost for a mid-complexity cross-platform app: $60K-120K. PWAs are still cheaper, but cross-platform gives you App Store presence and better device API access.

Quick Comparison Table

• PWA: $40K-80K for mid-tier, single codebase, no store fees, limited device APIs, instant updates
• React Native / Flutter: $60K-120K, single codebase, store presence, good device APIs, store review delays
• Fully Native (iOS + Android): $100K-200K, two codebases, full device access, maximum performance, highest maintenance cost

For most B2B SaaS products, internal tools, and content platforms, a PWA is the right call. For consumer apps where App Store ranking matters, consider cross-platform or native.

Your framework choice does not just affect developer experience. It directly impacts how much PWA-specific work you need to do manually versus what comes for free.

Next.js with next-pwa or Serwist

Next.js is the most popular React framework in 2026, and its PWA ecosystem is mature. The next-pwa package (now maintained as Serwist) generates a Workbox-powered service worker at build time, handles precaching of pages and static assets automatically, and supports runtime caching configuration through a simple config object. Setup takes a few hours. Customization for offline data and push notifications takes days, not weeks. Estimated cost savings versus hand-rolling: $5,000 to $15,000.

Nuxt 3 with @vite-pwa/nuxt

Nuxt's PWA module integrates with Vite's PWA plugin, which also uses Workbox under the hood. The developer experience is slightly more streamlined than Next.js for basic PWA features because Nuxt's module system handles manifest generation, icon resizing, and service worker registration automatically. Vue's smaller talent pool can offset these savings if you need to hire, though. Freelance Vue developers bill $100-180/hour versus $90-160/hour for React developers in the US market.

SvelteKit with vite-plugin-pwa

SvelteKit produces the smallest JavaScript bundles of any major framework, which gives PWAs a measurable performance advantage. Smaller bundles mean faster precaching, faster first loads, and less storage consumed on user devices. The trade-off is a much smaller ecosystem. Fewer developers know Svelte, fewer pre-built components exist, and fewer agencies can support it long-term. For a startup that plans to grow a team, this can become expensive.

Angular with @angular/pwa

Angular's built-in PWA schematic generates a service worker config and manifest with a single CLI command. Angular's service worker module supports push notifications and update detection natively. If your team already uses Angular, adding PWA capabilities is the cheapest path forward. Starting a new project on Angular just for PWA features does not make sense given the framework's steeper learning curve and larger bundle sizes.

Our recommendation for most new PWA projects in 2026: Next.js with Serwist. The React talent pool is enormous, the framework handles SSR and static generation (critical for PWA performance), and the tooling is battle-tested at scale.

A PWA that loads slowly is just a bad website. The entire value proposition of a progressive web app rests on performance, and that performance is engineered through two concepts: app shell architecture and performance budgets.

App Shell Architecture

The app shell is the minimal HTML, CSS, and JavaScript needed to render your application's skeleton: the navigation bar, sidebar, footer, and layout containers, without any dynamic content. This shell is precached by the service worker during installation. On subsequent visits, the browser loads the shell instantly from cache and fills in dynamic content from the network or from IndexedDB.

Building a proper app shell costs $3,000 to $8,000 in additional engineering time on top of your standard frontend work. The challenge is separating your UI into a cacheable shell and dynamic content in a way that feels seamless. Done well, your app appears to load in under one second even on a 3G connection. Done poorly, users see a skeleton screen that flickers or flashes before content appears.

Performance Budgets

A performance budget sets hard limits on JavaScript bundle size, total page weight, and loading metrics (Largest Contentful Paint, First Input Delay, Cumulative Layout Shift). For PWAs, we recommend these targets:

• Total JavaScript (compressed): Under 200KB for the initial load
• Largest Contentful Paint: Under 2.5 seconds on a mid-tier mobile device over 4G
• Time to Interactive: Under 3.5 seconds on the same baseline
• Service worker precache payload: Under 2MB to avoid excessive storage use on low-end devices

Enforcing these budgets requires tooling: Lighthouse CI running in your deployment pipeline, bundlewatch or size-limit checking pull requests for bundle regressions, and real user monitoring (RUM) through tools like Vercel Analytics, SpeedCurve, or Google's web-vitals library. Setting up this infrastructure costs $2,000 to $5,000 and saves you from the slow creep of performance degradation that kills PWAs six months after launch.

We have seen PWAs that passed every Lighthouse audit at launch score below 50 a year later because nobody enforced a performance budget. Treat your budget like a test suite: if it fails, the deploy does not ship.

Building the PWA is the big upfront cost. Keeping it running is the ongoing one. Here is what to expect monthly.

Hosting: $20 to $500/month

PWAs are served as static or server-rendered web pages, so hosting costs are modest compared to native app backends. Vercel's Pro plan ($20/month per team member) handles most PWAs comfortably with edge caching, automatic HTTPS, and preview deployments. Netlify is comparable. For enterprise PWAs with heavy API traffic, AWS (CloudFront + Lambda or ECS) or Google Cloud Run typically runs $100 to $500/month depending on traffic volume. The key requirement is HTTPS everywhere, since service workers only function over secure connections.

Push Notification Services: $0 to $200/month

Web push notifications use the free Web Push Protocol, but managing subscriber lists, segmentation, and analytics requires a service. Firebase Cloud Messaging (FCM) is free for unlimited push messages. OneSignal offers a generous free tier and charges $9 to $99/month for advanced segmentation. For enterprise needs, Amazon SNS or a self-hosted solution using the web-push npm package keeps costs predictable.

Monitoring and Analytics: $0 to $300/month

You need to monitor both application errors and performance. Sentry ($26/month for the Team plan) handles error tracking. Vercel Analytics or Google Analytics handles usage metrics. For real user performance monitoring, SpeedCurve or Calibre start around $50/month. You can get away with free tools (Sentry's developer plan, Google Analytics, web-vitals library) for early-stage products.

Ongoing Maintenance: $1,500 to $5,000/month

This is the line item founders consistently underestimate. Monthly maintenance for a production PWA includes dependency updates (security patches, framework upgrades), service worker cache strategy adjustments as your content model evolves, browser compatibility fixes (Safari updates its PWA support roughly every quarter, sometimes introducing regressions), push notification delivery monitoring, and performance budget enforcement.

At a minimum, budget 15 to 20 percent of your initial build cost per year for maintenance. A $60,000 PWA needs $9,000 to $12,000 annually in maintenance, or roughly $750 to $1,000/month. Skipping maintenance is how you end up with a service worker that serves a six-month-old cached version of your app to 30 percent of your users.

After building dozens of PWAs for startups and mid-market companies, here is our honest framework for deciding.

Choose a PWA When:

• Your users access the product primarily through a browser and you want a mobile-app feel without App Store overhead
• Offline or low-connectivity support is a core requirement (field workers, travelers, emerging markets)
• You need to ship fast and cannot afford separate iOS and Android builds
• Your product is B2B and your users will install via a URL shared by their IT admin, not by searching an app store
• Re-engagement through push notifications matters, but you do not need the full native notification stack
• Budget is constrained and you need maximum reach per dollar spent

Skip the PWA When:

• You need access to HealthKit, ARKit, CallKit, or other Apple/Google-exclusive APIs
• App Store ranking is a primary customer acquisition channel
• Your app requires intensive GPU rendering (games, 3D visualization beyond what WebGL handles well)
• Your target users are exclusively on iOS and expect a fully native experience (Safari's PWA support is good but not identical to native)
• You need background location tracking, geofencing, or persistent Bluetooth connections

The Hybrid Approach

Some of our most successful projects use a PWA as the primary product and wrap it in a thin native shell using Capacitor (by the Ionic team) or TWA (Trusted Web Activity for Android) for App Store distribution. This costs an additional $5,000 to $15,000 on top of the PWA build and gives you the best of both worlds: one codebase with store presence. Capacitor is particularly effective because it lets you add native plugins for specific device APIs while keeping 95 percent of your code as standard web technology.

If you are weighing these options and want a straight answer on what fits your product and budget, book a free strategy call with our team. We will review your requirements and give you an honest estimate, no sales pitch attached.