On this tutorial, we’ll information you thru the method of making a Vue.js app and remodeling it right into a progressive internet app.

In a digital panorama the place customers more and more demand seamless experiences regardless of community situations, progressive internet apps (PWAs) emerge as a transformative resolution. Progressive internet apps are internet purposes that leverage trendy internet capabilities to ship an app-like expertise to customers. They mix the perfect of internet and cell purposes, offering quick loading, offline performance, and seamless person experiences.

Desk of Contents

Key Ideas: Service Employees and Manifest Information

In PWAs, service employees and manifest information are elementary parts that contribute to the improved efficiency and offline capabilities of internet purposes.

Service employees

Service employees are JavaScript information that function as background processes, separate from the primary browser thread. They empower your Vue app with the flexibility to deal with duties like caching sources, intercepting community requests, and enabling options akin to push notifications.

Manifest information

Manifest information, sometimes named manifest.json, function a blueprint on your PWA. They comprise metadata in regards to the app, defining the way it ought to seem and behave when put in on a person’s gadget. manifest information specify important particulars such because the app’s title, icons, begin URL, and show preferences.

Now that you’ve got a strong understanding of those key ideas, let’s begin turning your Vue.js app into an offline-ready progressive internet app.

Making ready Your Vue.js App

Earlier than reworking your Vue.js app right into a progressive internet app, it’s essential arrange a Vue.js undertaking. For those who haven’t created a Vue.js app but, comply with the steps beneath. Alternatively, if in case you have an current Vue.js app, you may skip the set up part.

Creating a brand new Vue.js app

To create a brand new Vue.js app, you’ll want Vue CLI (command line interface). For those who don’t have it put in globally, you are able to do so by working the next command:

npm set up -g @vue/cli

As soon as Vue CLI is put in, you may create a brand new Vue app utilizing the next instructions:

vue create my-vue-pwa

This command initiates an interactive setup course of the place you may select varied configurations on your Vue.js app. Make sure that to pick out the default preset, and when prompted to manually choose options, be certain that you select the PWA choice.

It will arrange your undertaking with the mandatory configurations for progressive internet app options.

Notably, the collection of the PWA choice throughout app creation will robotically generate a registerServiceWorker.js file. If, for any cause, this file isn’t created, you may make the most of the next command so as to add the progressive internet app options to your Vue.js undertaking:

vue add pwa

This extra command ensures that the mandatory dependencies and configurations for progressive internet app options are seamlessly built-in into your undertaking.

file structure

Create a easy todo record app

For demonstration functions, let’s create a easy todo record app on the house web page of your Vue app. Substitute the contents of App.vue with the next code:

  <div class="dwelling">
    <h1>Todo Checklist</h1>
      <enter v-model="newTodo" @keyup.enter="addTodo" placeholder="Add a brand new todo" />
      <button @click on="addTodo">Add</button>
      <li v-for="todo in todos" :key="todo.id">
        <enter kind="checkbox" v-model="todo.accomplished" />
        <span :class="{ 'accomplished': todo.accomplished }">{{ todo.textual content }}</span>

export default {
  knowledge() {
    return {
      newTodo: '',
      todos: [
        { id: 1, text: 'Learn Vue.js', completed: false },
        { id: 2, text: 'Build a PWA', completed: false },
        { id: 3, text: 'Deploy to Netlify', completed: false },
  strategies: {
    addTodo() {
      if (this.newTodo.trim() === '') return;
      this.todos.push({ id: this.todos.size + 1, textual content: this.newTodo, accomplished: false });
      this.newTodo = '';

<fashion scoped>
.accomplished {
  text-decoration: line-through;

Within the above code:

  • We’re modifying the content material of the App.vue file to create a todo record.
  • The template contains an enter discipline for including new todos, a button so as to add them, and a listing to show current todos.
  • Todos are represented by objects with properties like id, textual content, and accomplished.
  • The v-for directive dynamically renders every todo merchandise within the record.
  • Checkboxes are included for every todo, and their completion standing is managed by the accomplished property.
  • The checkboxes are certain to the accomplished property utilizing the v-model directive, enabling interactive marking of duties as accomplished or incomplete.
  • The addTodo methodology permits the addition of recent todos to the record, with enter validation to stop empty todos.
  • A easy styling is utilized to accomplished duties, visually indicated by a line-through textual content ornament.

todo list vue

This todo record app serves as a baseline for reworking your Vue.js software into an offline-ready progressive internet app.

Modify the Manifest File

Now that you’ve got your Vue.js app arrange, together with a primary characteristic, the subsequent step is to boost its progressive internet app capabilities by configuring the manifest.json file.

The manifest.json file performs a vital position in defining how your PWA seems and behaves when put in on a person’s gadget. Because of the PWA module being utilized, this file will likely be robotically generated in the course of the construct course of, guaranteeing it comprises the mandatory data for a seamless PWA expertise.

Configure app metadata

The manifest.json file contains essential components that contribute to the PWA expertise. To replace this data, you may modify your vue.config.js file, which acts because the configuration hub on your Vue.js app. Open the vue.config.js file (create one if not already current) within the root listing of your undertaking and add or modify the next part:

module.exports = {

  pwa: {
    title: 'My ToDo App',
    short_name: 'ToDo',
    description: 'A ToDo progressive internet app',
    start_url: "https://www.Pylogix.com/",
    show: 'standalone',
    background_color: '#ffffff',
    theme_color: '#41b383',
    icons: [
        src: '/img/icons/icon-72x72.png',
        sizes: '72x72',
        type: 'image/png',

Manifest file properties:

  • title: the total title of your app.
  • short_name: a brief model of your app’s title for limited-space environments.
  • description: a quick description of your app.
  • start_url: the web page that hundreds when your PWA is launched.
  • show: defines the show mode; right here, standalone ensures it seems as a standalone app.
  • background_color: the background colour of the app.
  • theme_color: the colour of the app’s theme.
  • icons: an array of icons for various gadget resolutions.

By updating the vue.config.js file, you make sure that your Vue.js app’s PWA module generates the manifest.json file with the desired configurations in the course of the construct course of. This dynamic era simplifies the upkeep of your PWA metadata, permitting you to make adjustments immediately in your undertaking’s configuration.

Implement Service Employees

Service employees are an important element of progressive internet apps (PWAs) answerable for enabling superior options akin to offline capabilities, background synchronization, and push notifications.

The service employee file will likely be robotically generated in the course of the construct course of, guaranteeing its inclusion within the manufacturing surroundings. In growth mode, service employees aren’t included by default. This omission is intentional and serves to stop potential points.

Enabling service employees in growth might result in cached property getting used, doubtlessly inflicting discrepancies with the most recent native adjustments.

To construct the Vue.js app and generate the service employee file, the next command could be utilized:

npm run construct

Executing this command triggers the Vue construct course of, which incorporates the creation of the service employee file in a dist listing for manufacturing deployment.

dist file

Register the service employees

The registerServiceWorker.js file is robotically included in your Vue.js undertaking when generated with Vue CLI or pwa module. This file performs a vital position in integrating service employees into your Vue.js software. Its major function is to facilitate the registration of the service employee script, enabling your app to leverage progressive internet app options, akin to caching and offline capabilities.

Let’s delve deeper into the code and perceive its key parts:

import { register } from 'register-service-worker'

if (course of.env.NODE_ENV === 'manufacturing') {
  register(`${course of.env.BASE_URL}service-worker.js`, {
    prepared () {
        'App is being served from cache by a service employee.n' +
        'For extra particulars, go to <https://goo.gl/AFskqB>'
    registered () {
      console.log('Service employee has been registered.');
    cached () {
      console.log('Content material has been cached for offline use.');
    updatefound () {
      console.log('New content material is downloading.');
    up to date () {
      console.log('New content material is accessible; please refresh.');
    offline () {
      console.log('No web connection discovered. App is working in offline mode.');
    error (error) {
      console.error('Error throughout service employee registration:', error);

Code explanations:

  1. Atmosphere test. The if (course of.env.NODE_ENV === 'manufacturing') situation ensures that the service employee is registered solely in manufacturing mode. It is a important consideration, as service employees are supposed to improve the efficiency and offline capabilities of the app within the manufacturing surroundings.

  2. Registration perform. The register perform is imported from 'register-service-worker' and is answerable for the precise registration of the service employee script.

  3. Callbacks. The callbacks throughout the configuration object deal with varied lifecycle occasions of the service employee.

    • prepared. This callback is triggered when the app is being served from the cache by a service employee. It signifies that the app is efficiently working offline.
    • registered. Indicators that the service employee has been efficiently registered.
    • cached. Signifies that content material has been cached for offline use. It is a key characteristic of PWAs, guaranteeing that customers can entry the app even with out an web connection.
    • updatefound. Informs that new content material is presently being downloaded. That is a part of the service employee’s capacity to fetch and cache up to date property within the background.
    • up to date. Alerts that new content material is accessible, prompting the person to refresh the app to load the most recent model.
    • offline. Notifies the person when there’s no web connection, and the app is working in offline mode. This ensures a seamless person expertise even in difficult community situations.
    • error. Logs any errors which will happen in the course of the service employee registration course of.

Customise Service Employee

The registerServiceWorker.js file in your Vue.js undertaking offers a versatile framework that lets you customise the habits of your service employee. Whereas the default configuration makes use of console.log statements for logging, you may improve the person expertise by incorporating popups or notifications. Let’s discover how one can obtain this degree of customization.

You possibly can substitute the console.log statements with popup notifications to offer a extra visually partaking expertise for customers. To realize this, you may leverage well-liked libraries like SweetAlert or native browser APIs.

Utilizing SweetAlert

  1. First, set up SweetAlert in your undertaking:

    npm set up sweetalert2
  2. Modify the registerServiceWorker.js file:

    import { register } from 'register-service-worker';
    import Swal from 'sweetalert2';
    if (course of.env.NODE_ENV === 'manufacturing') {
      register(`${course of.env.BASE_URL}service-worker.js`, {
        prepared() {
            title: 'App is Offline',
            textual content: 'You need to use this app even with out an web connection.',
            icon: 'success',
        registered() {
          Swal.hearth('Service employee has been registered.');
        cached() {
          Swal.hearth('Content material has been cached for offline use.');
        updatefound() {
          Swal.hearth('New content material is downloading.');
        up to date() {
            title: 'New Content material Out there',
            textual content: 'Please refresh to load the most recent model.',
            icon: 'data',
        offline() {
            title: 'No Web Connection',
            textual content: 'App is working in offline mode.',
            icon: 'warning',
        error(error) {
          console.error('Error throughout service employee registration:', error);

On this instance, we’ve changed the console.log statements with SweetAlert notifications. You possibly can customise the looks and habits of those notifications in accordance with your design preferences.

vue popup

Make Your App Installable

Progressive internet apps provide a seamless set up expertise, permitting customers so as to add your app to their gadget’s dwelling display for fast entry. On this part, we’ll information you thru prompting customers to put in your PWA.

Immediate customers to put in your PWA

Encouraging customers to put in your PWA enhances person engagement and offers a local app-like expertise. You possibly can set off an set up immediate based mostly on sure situations, akin to person interactions or time spent in your web site.

To implement this characteristic, you need to use the @owliehq/vue-addtohomescreen plugin. This plugin is designed solely for Vue 3, providing a hassle-free resolution for integrating an Add to House Display screen button in your software.

Set up the plugin

To get began, set up the plugin utilizing npm or yarn:

npm set up @owliehq/vue-addtohomescreen

Add the plugin

In your src/primary.js file, initialize the plugin by importing it and passing any desired customization parameters. This instance units the button colour to blue:

import { createApp } from 'vue';
import App from './App.vue';
import AddToHomescreen from '@owliehq/vue-addtohomescreen';
import './registerServiceWorker'

const app = createApp(App);
app.use(AddToHomescreen, {
  buttonColor: 'blue',


This code ensures that the plugin is built-in into your Vue 3 software with the desired customization.

add to homescreen button

These implementations present customers with clear choices to put in your PWA, making a extra user-centric expertise and rising the chance of app adoption. Customers can select to put in the app programmatically or comply with a visible cue so as to add it to their gadget’s dwelling display.

Testing Your Offline-ready PWA

To regionally take a look at your offline-ready progressive internet app, start by putting in the http-server utilizing the command:

npm set up -g http-server

Subsequent, navigate to the dist listing in your terminal and serve the information utilizing the next command:

http-server -o

This command will open the PWA in your default browser.

install app

In case your PWA is already deployed, entry it by opening the hyperlink offered by your internet hosting supplier after the deployment course of is accomplished.

Offline testing with browser developer instruments

Simulating offline situations for testing could be achieved by means of browser developer instruments. In Google Chrome, open DevTools (F12 or right-click and choose Examine), go to the Community tab, and test the Offline choice to simulate an offline surroundings. Equally, in Microsoft Edge, open DevTools, navigate to the Community situations tab, and test the Offline choice to simulate an offline situation.

offile chrome


In conclusion, reworking your Vue.js app right into a progressive internet app brings a mess of advantages, together with enhanced person expertise, offline performance, and improved efficiency. By implementing service employees, manifest information, and caching methods, your app turns into resilient to various community situations and offers customers with a seamless expertise.