Skip to content
Subscribe to RSS Find me on GitHub Follow me on Twitter

A Guide to Building Progressive Web Apps with Angular


  • What are Progressive Web Apps (PWAs)? Progressive Web Apps (PWAs) are web applications that combine the best features of both web and native mobile apps. They are built using web technologies such as HTML, CSS, and JavaScript, but offer a native-like experience to users. PWAs can be accessed through a web browser like a regular website, but they can also be installed on a user's device and accessed offline.

  • Why build PWAs with Angular? Angular is a popular JavaScript framework for building web applications. It provides a powerful and scalable architecture, along with a rich set of tools and features. When it comes to building PWAs, Angular offers several advantages such as excellent support for building offline-capable applications using service workers, a robust component-based architecture, and a seamless integration with the Angular CLI for efficient development and deployment.

  • Benefits of PWAs Progressive Web Apps offer numerous benefits for both developers and users. Some of the key benefits include:

  1. Offline capabilities: PWAs can work even when there is no internet connection, allowing users to access content and perform actions offline.
  2. Responsive and mobile-friendly: PWAs are designed to work well on all devices and screen sizes, ensuring a consistent user experience across different platforms.
  3. Fast loading times: PWAs utilize techniques such as caching and lazy loading to reduce loading times, resulting in a smooth and responsive user experience.
  4. Discoverability: PWAs can be indexed by search engines and discovered through traditional web search, making them more accessible to users.
  5. App-like experience: PWAs provide an app-like experience with features such as push notifications, home screen icons, and full-screen mode, enhancing user engagement and retention.
  6. Cost-effective development: Building a PWA using web technologies allows developers to target multiple platforms with a single codebase, saving time and resources compared to developing separate native apps.

Setting up an Angular Project

To get started with building a Progressive Web App (PWA) with Angular, you need to set up an Angular project. Here are the steps to follow:

Install Angular CLI

Angular CLI (Command Line Interface) is a powerful tool that allows you to scaffold and manage Angular projects efficiently. To install Angular CLI, open your command line interface and run the following command:

npm install -g @angular/cli

Create a new Angular project

Once you have installed Angular CLI, navigate to the directory where you want to create your project and run the following command:

ng new my-pwa-project

This will create a new Angular project with the name "my-pwa-project". Angular CLI will automatically set up the basic project structure and install the necessary dependencies.

Congratulations! You have successfully set up your Angular project for building a Progressive Web App. Now, let's move on to building the basic structure of a PWA.

Building the Basic Structure of a PWA

Manifest file

What is a manifest file?

A manifest file is a JSON file that provides information about a web application, such as its name, icons, and theme. It allows the browser to understand how to display the application when it is installed on a user's device.

Creating a manifest file for an Angular project

To create a manifest file for an Angular project, follow these steps:

  1. Create a new file called manifest.json in the root directory of your Angular project.
  2. Open the manifest.json file and define the required properties such as name, short_name, icons, and start_url.
  3. Add any additional properties you want to include in the manifest file, such as theme_color or background_color.
  4. Save the manifest.json file.

Service workers

What are service workers?

Service workers are JavaScript files that run in the background of a web application and enable features such as offline caching, push notifications, and background synchronization. They allow web applications to work offline and provide an enhanced user experience.

Registering a service worker in an Angular project

To register a service worker in an Angular project, follow these steps:

  1. Create a new file called service-worker.js in the root directory of your Angular project.
  2. Open the service-worker.js file and write the necessary code to implement the desired functionality, such as caching static assets or handling push notifications.
  3. In your Angular project's main index.html file, add a script tag to register the service worker by referencing the service-worker.js file using the navigator.serviceWorker.register() method.
  4. Save the changes to your files.

Now, when you deploy your Angular application, the service worker will be registered and start running in the background, providing the desired functionality.

Adding Offline Capabilities to the PWA

One of the key features of Progressive Web Apps (PWAs) is the ability to work offline or in low-quality network conditions. This is achieved through the use of service workers, which act as a proxy between the web app and the network. In this section, we will explore how to add offline capabilities to a PWA built with Angular.

Caching static assets

To ensure that your PWA functions even when there is no network connection, it is important to cache the static assets of your app. These assets can include HTML, CSS, JavaScript files, and images. By caching these assets using service workers, your app can be loaded and run offline.

To cache static assets in an Angular project, you can utilize the service worker APIs provided by Angular. By default, Angular sets up a service worker file called ngsw-worker.js when generating a new project using the Angular CLI. This file is responsible for handling service worker logic.

To cache static assets using ngsw-worker.js:

  1. Open the ngsw-config.json file located in the src/ directory of your Angular project.
  2. Under the assetGroups section, add an entry for your static assets with the appropriate patterns and cacheConfig.strategy.
  3. Save the changes and rebuild your project.

With these configurations in place, your app's static assets will be cached by the service worker when the app is first loaded. Subsequent visits to your app will then have these static assets available even if there is no network connection.

Caching dynamic content

In addition to caching static assets, it is also possible to cache dynamic content in a PWA. This allows your app to display previously fetched data even when there is no network connectivity.

To cache dynamic content using service workers in an Angular project:

  1. Determine which parts of your app's dynamic content you want to cache. This can include API responses, database queries, or any other server-generated content.
  2. Implement caching logic in your service worker file (ngsw-worker.js) to handle the caching and retrieval of dynamic content.
  3. Configure the service worker to intercept requests for dynamic content and serve the cached responses when available.

By caching dynamic content, your app can provide a seamless user experience even in offline or low-quality network situations. Users will still be able to access and interact with previously loaded data, reducing frustration and enhancing usability.

In the next section, we will explore how to enhance your PWA with push notifications, allowing you to engage and communicate with your users even when they are not actively using your app.

Enhancing the PWA with Push Notifications

Setting up push notifications in the backend server

Push notifications are a powerful feature of progressive web apps that allow you to engage with your users even when they are not actively using your app. To set up push notifications in the backend server, follow these steps:

  1. Choose a push notification service provider: There are several push notification service providers available, such as Firebase Cloud Messaging (FCM) or OneSignal. Select a provider that suits your needs and set up an account.

  2. Configure your backend server: Depending on the push notification service provider you choose, you will need to configure your backend server to communicate with the provider's API. This usually involves setting up authentication credentials and configuring endpoints for sending push notifications.

  3. Integrate push notification functionality into your backend server code: Once your backend server is configured, you can integrate push notification functionality into your server code. This typically involves sending requests to the push notification service provider's API to send notifications to specific users or devices.

Configuring and subscribing to push notifications in the Angular app

After setting up push notifications in the backend server, you need to configure and subscribe to push notifications in your Angular app. Follow these steps:

  1. Import the necessary packages: To work with push notifications in Angular, you will need to import the necessary packages. Depending on the push notification service provider you are using, this may involve installing and importing libraries or SDKs provided by the provider.

  2. Request permission from the user: Before subscribing to push notifications, you need to request permission from the user to send them notifications. Use the Notification.requestPermission() method to prompt the user for permission.

  3. Subscribe to push notifications: Once the user grants permission, you can subscribe them to push notifications. This typically involves calling methods provided by the push notification service provider's library or SDK to register the user's device token and associate it with their account.

  4. Handle incoming push notifications: When a push notification is received by the user's device, your Angular app needs to handle it appropriately. This can involve displaying a notification banner, opening a specific page or component in the app, or performing any other custom action.

By following these steps, you can enhance your progressive web app with push notification functionality, allowing you to engage and re-engage with your users effectively.

Testing and Deploying the PWA

Testing the PWA on various devices and browsers

Before deploying your PWA, it is important to thoroughly test it on different devices and browsers to ensure a consistent and optimal user experience. Here are some steps to follow for testing:

  1. Responsive Design: Test the PWA on various devices with different screen sizes, including smartphones, tablets, and desktops. Ensure that the layout and content adapt well to different screen sizes.

  2. Cross-Browser Compatibility: Test the PWA on multiple browsers such as Chrome, Firefox, Safari, and Edge. Pay attention to any CSS or JavaScript compatibility issues that may arise.

  3. Performance Testing: Use tools like Lighthouse or WebPageTest to analyze the performance of your PWA. Check for issues related to loading speed, resource usage, and overall performance optimization.

  4. User Experience Testing: Perform user testing to gather feedback on the usability and navigation of your PWA. Identify any potential pain points or areas for improvement.

  5. Offline Testing: Test the offline capabilities of your PWA by disconnecting from the internet or simulating poor network conditions. Ensure that the PWA still functions properly and displays appropriate offline content.

  6. Accessibility Testing: Verify that your PWA meets accessibility standards by using tools like Axe or Chrome DevTools' Accessibility Audit. Check for any accessibility violations and make necessary improvements.

Deploying the PWA to a hosting platform

Once you have successfully tested your PWA, it's time to deploy it to a hosting platform so that it can be accessed by users worldwide. Here are some steps to follow for deployment:

  1. Build Optimization: Before deploying, optimize your Angular project for production by running the ng build --prod command. This will create a minimized and optimized build of your PWA.

  2. Choose a Hosting Platform: Select a hosting platform that supports static websites, as PWAs are essentially static HTML, CSS, and JavaScript files. Some popular hosting platforms include Netlify, GitHub Pages, Firebase Hosting, and AWS S3.

  3. Upload the Build: Connect to your chosen hosting platform and upload the build files generated in the previous step. Make sure to include all necessary files, including the index.html, assets, and the service-worker.js file.

  4. Configure DNS: If you have a custom domain, configure the DNS settings to point to your hosting platform. This will ensure that your PWA is served from your desired domain.

  5. SSL Certificate: Obtain an SSL certificate to enable HTTPS for your PWA. Many hosting platforms provide automatic SSL certificates, but you may need to configure it manually if required.

  6. Test the Deployment: After deploying your PWA, test it again on different devices and browsers to ensure that everything is functioning as expected.

  7. Continued Maintenance: Regularly monitor your deployed PWA for any issues or updates. Keep an eye on analytics to gather insights about user engagement and make improvements accordingly.

By following these steps, you can successfully test and deploy your Angular Progressive Web App (PWA) to make it available to users across various devices and browsers.


In this guide, we have explored the process of building Progressive Web Apps (PWAs) with Angular. We started with an introduction to PWAs and the benefits they offer. We then learned how to set up an Angular project using the Angular CLI.

Next, we built the basic structure of a PWA by creating a manifest file and registering a service worker in our Angular project. This enabled us to provide offline capabilities to our PWA by caching static assets and dynamic content using service workers.

We also enhanced our PWA by adding push notifications. We configured the backend server for push notifications and subscribed to them in our Angular app.

Lastly, we covered testing and deploying the PWA. We discussed testing the PWA on various devices and browsers, and then deployed it to a hosting platform.

By following this guide, you can now confidently build PWAs with Angular and offer enhanced user experiences through offline capabilities and push notifications. Start building your own PWAs today!