Progressive Web Application (PWA)
Term 25 of 68 in the ERPStack technical glossary
What is Progressive Web Application (PWA)?
A Progressive Web Application (PWA) is a type of application software delivered through the web, built using common web technologies including HTML, CSS, and JavaScript, designed to work on any platform.
Progressive Web Application (PWA) at a glance
- Requirements
- 3 pieces: HTTPS, a web app manifest, and a service worker controlling the cache
- Offline model
- Queue writes locally, replay when connectivity returns — every replay must be idempotent
- Distribution
- 1 URL, 0 app store review cycles, updates delivered on next load
- Best fit
- Warehouse scanners, field service and shop-floor terminals on unreliable networks
- Built with
- Next.js 16 and React 19 with a service worker and Tailwind CSS 4, writes queued locally and replayed into PostgreSQL 18 through Drizzle ORM 0.45, hosted on Vercel or AWS with Sentry reporting
- Numbers that matter
- 3 requirements — HTTPS, manifest, service worker; 1 URL instead of 2 app store submissions; 0 review cycles; 1 idempotency key per queued write
- Compare with
- A native app, a plain React 19 web application with no service worker, or an Electron desktop build talking to the same REST API
- Commonly paired with
- Edge Caching / CDN in front of Next.js 16 and React 19, Idempotency in API Design on replay, PostgreSQL 18 and Redis behind the API, Tailwind CSS 4 for the shell, Vercel or AWS hosting, Playwright 1.59 offline tests and Sentry
- Offline write path
- 1 local queue, 1 idempotency key per write, replayed against PostgreSQL 18; Redis absorbs the burst when 50 devices reconnect at once
- Field hardware
- Warehouse scanners and shop-floor terminals in logistics, manufacturing and retail, served by Next.js 16 and React 19 through Edge Caching / CDN with Tailwind CSS 4 in the shell.
- Sync path
- Queued writes replay into PostgreSQL 18 through Drizzle ORM 0.45 with Idempotency in API Design on every key, Redis absorbing the burst, Sentry reporting a replay that fails twice.
How Progressive Web Application (PWA) works in production
The ERPStack approach to Progressive Web Application (PWA)
We build offline-first PWA dashboard consoles for logistics and field operation teams, ensuring continuous activity logging even without network connections.
Frequently asked questions about Progressive Web Application (PWA)
What makes a web app a Progressive Application?
Three capabilities working together: it is served over HTTPS, it declares a web app manifest so it can be installed to a home screen, and it registers a service worker that controls caching and offline behaviour. A Progressive Application is therefore not a framework choice — it is a set of platform features that turn an ordinary site into something installable and resilient to poor connectivity.
How does offline support actually work?
Through a service worker and a local write queue. A Progressive Application intercepts network requests, serves cached responses when the network is unavailable, and stores outgoing changes locally until connectivity returns. The difficult part is the replay: queued writes may arrive minutes later and may conflict, so every operation needs an idempotency key and a defined conflict rule rather than last-write-wins by accident.
When should you build a PWA instead of a native app?
When distribution and iteration matter more than deep device integration. A Progressive Application deploys as a URL, updates without a review cycle and runs from 1 codebase across platforms, which suits internal tools, field applications and warehouse terminals. Native remains the right answer for demanding hardware access or platform-specific interface conventions that users genuinely expect.
What do people underestimate about PWAs?
Cache invalidation and update behaviour. A Progressive Application with a service worker can pin an old version of the application indefinitely if the update strategy is wrong, which produces the worst kind of bug report — a user on a version nobody can reproduce. Deciding explicitly when a new service worker takes control, and how the user is told, is part of the build rather than an afterthought.