Mastering the Art of Progressive Web Apps: A Guide to PWA with React and Workbox


In recent years, web developers have been exploring new ways to create web applications that provide a more seamless and engaging user experience. One of the most promising technologies in this area is progressive web apps (PWAs), which combine the best features of web and native apps.

In this guide, we'll explore how to create PWAs with React and Workbox, two popular frameworks that make incorporating PWA features a breeze. By the end of this guide, you'll be able to create an offline-capable, app-like web application that utilizes push notifications, background sync, and other essential PWA features.

What is a Progressive Web App (PWA)?

A progressive web app is a web application that provides an app-like experience for users, with features traditionally found in native apps such as push notifications, offline capabilities, and home screen installation. Unlike native apps, PWAs are accessed through a web browser and have no installation requirement, making them more accessible and convenient for users.

PWAs are designed to provide a fast and seamless user experience by utilizing service workers, which are scripts running in the background of a web application. These service workers interact with the browser to provide features such as caching, push notifications, and background sync. With these features, PWAs can provide a smoother user experience, regardless of whether the user is online or offline.

Why Create a Progressive Web App (PWA)?

There are several reasons to create a progressive web app, including:

  • Increased user engagement: PWAs can increase user engagement by providing a more seamless and app-like experience, leading to longer session times and more frequent visits.
  • Improved performance: PWAs can improve performance by utilizing caching and other service worker features to provide a faster loading experience, even on slow connections.
  • Increased accessibility: PWAs can be accessed through a web browser, making them more accessible and convenient for users who don't want to install a native app.

Getting Started with React and Workbox

To get started with building a PWA with React and Workbox, we'll need to install the required dependencies. We'll be using Create React App to set up our project, which comes bundled with Workbox pre-installed.

npx create-react-app my-pwa
cd my-pwa

Once we've set up our project, we can start incorporating PWA features. The first step is to register our service worker, which will allow us to cache our assets for offline use.

// src/index.js

import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
import * as serviceWorker from './serviceWorker';

ReactDOM.render(<App />, document.getElementById('root'));


By calling the register() method from our service worker script, we're telling the browser to register our service worker and start caching our assets for offline use.

Caching Assets for Offline Use with Workbox

Now that we've registered our service worker, let's start caching our assets for offline use. We'll be using Workbox, a library that makes it easy to add caching and other PWA features to our project.

To use Workbox, we'll need to import the libraries we need and configure our service worker.

// src/serviceWorker.js

import { precacheAndRoute } from 'workbox-precaching';


In this code snippet, we're importing the precacheAndRoute function from Workbox, which will allow us to cache and serve our app's assets. We're also passing in self.__WB_MANIFEST, which is an array of files that we want to cache. Workbox will automatically create a cache for these assets and serve them when the user is offline.

By default, Create React App already bundles several files, such as JS and CSS files, which are included in the manifest. However, if you want to add more files to the cache, you can modify the precacheAndRoute() function to include additional files.

Adding Push Notifications with Workbox

Push notifications are an essential feature of PWAs, allowing users to receive updates even when the app is not actively open. With Workbox, adding push notifications is straightforward.

To add push notifications, we'll need to set up a push notification subscription and listen for incoming push notifications in our service worker.

// src/serviceWorker.js

import { precacheAndRoute } from 'workbox-precaching';
import { registerRoute } from 'workbox-routing';
import { openDB } from 'idb';
import { CacheableResponsePlugin } from 'workbox-cacheable-response';
import { BackgroundSyncPlugin } from 'workbox-background-sync';
import { ExpirationPlugin } from 'workbox-expiration';
import { StaleWhileRevalidate } from 'workbox-strategies';
import { clientsClaim, skipWaiting } from 'workbox-core';
import { setCacheNameDetails } from 'workbox-core';
import { precache } from 'workbox-precaching';
import { CacheFirst, NetworkFirst } from 'workbox-strategies';
import { setCacheNameDetailsAndPlugin } from 'workbox-core';
import { setDefaultHandler } from 'workbox-routing';

  prefix: 'my-pwa',



self.addEventListener('push', event => {
  const title = 'My PWA';
  const options = {

  event.waitUntil(self.registration.showNotification(title, options));

In this code snippet, we're listening for the `push` event in our service worker and displaying a notification to the user when a push notification is received. We're also using the `workbox-precaching` library to cache our assets for offline use and the `workbox-routing` library to handle our network requests.

Adding Background Sync with Workbox

Background sync is another crucial feature of PWAs, allowing apps to sync data with a server even when the user is offline or has spotty internet connectivity.

With Workbox, we can easily add background sync to our application by utilizing the `BackgroundSyncPlugin`.

// src/serviceWorker.js

import { precacheAndRoute } from 'workbox-precaching';
import { BackgroundSyncPlugin } from 'workbox-background-sync';
import { setCacheNameDetails } from 'workbox-core';
import { skipWaiting } from 'workbox-core';
import { clientsClaim } from 'workbox-core';

  prefix: 'my-pwa',



const bgSyncPlugin = new BackgroundSyncPlugin('my-pwa-queue', {
  maxRetentionTime: 24 * 60

// Queue failed requests.
self.addEventListener('fetch', (event) => {
  if (event.request.method !== 'POST') {

  const clonedRequest = event.request.clone();

  const queue = new workbox.backgroundSync.Queue('my-pwa-queue', {
    onSync: async ({queue}) => {
      let entry;
      while (entry = await queue.shiftRequest()) {
        try {
          await fetch(entry);
        } catch (error) {
          console.error('Replay failed for request', entry.request, error)
          await queue.unshiftRequest(entry);
      console.log('Replay complete!');
    plugins: [bgSyncPlugin]

  event.respondWith(fetch(event.request).catch((error) => {
    return queue.pushRequest(clonedRequest);

In this code snippet, we're setting up a `BackgroundSyncPlugin` and adding it to our `Queue` of failed requests. We're also catching failed requests and adding them to the queue using the `pushRequest()` method. When the user comes back online, Workbox will automatically retry all failed requests in the queue.


In this guide, we explored how to create PWAs using React and Workbox, two popular frameworks that make adding PWA features a breeze. We covered key features such as caching assets for offline use, adding push notifications, and background sync, which all allow us to create a seamless and engaging user experience that rivals native apps.

By utilizing PWAs, web developers can provide a more accessible, faster, and engaging user experience than ever before. With the help of frameworks such as React and Workbox, creating PWAs has never been easier.