By Rajesh Kannan, Co-Founder & CTO, Gramosoft · Last updated: · Code tested in headless Chromium on November 22, 2026

Many businesses that ask for "an app" really need something their customers or staff can open with one tap, that loads fast on a weak 4G signal and keeps working when the network drops. A progressive web app (PWA) does that from one web codebase, without an app store review or a download.

This guide covers what a PWA is, how it compares with a native app and a plain website, what works on iPhone and Android today, the code to build one (a manifest, a service worker and an offline page, tested offline), when a PWA is the wrong choice, and what it costs in Chennai. We start with how Gramosoft builds them.

TL;DR

  • Gramosoft builds PWAs in Chennai: installable web apps with offline data, push notifications and an optional Play Store listing.
  • What it is: a website with a web app manifest and a service worker, served over HTTPS, that users can install and open like an app.
  • Where it wins: booking, ordering, field service, customer portals and internal tools, with one codebase and instant updates.
  • Where native wins: Bluetooth or NFC, background location, heavy graphics, or an audience that's mostly on iPhone and needs every iOS feature.
  • Code below: a manifest, a service worker with four caching rules, safe update handling, and a test that passed all 8 checks offline.

What is a progressive web app? A PWA is a website that users can install to their home screen and open like an app. A manifest gives it a name, icon and full-screen window, and a service worker caches files so it loads fast and works offline. One codebase serves Android, iPhone and desktop, with no app store. Gramosoft, a Chennai web and mobile company, builds PWAs.

Swipe the table sideways on mobile →

Option Install Works offline App stores Codebases
Gramosoft PWA build From the browser Yes, as designed Play Store optional One
Progressive web app From the browser Yes Optional One
Native app From a store Yes Required Two (or one cross-platform)
Responsive website No No No One

How Gramosoft builds progressive web apps in Chennai

Gramosoft is a Chennai software company that builds web applications, mobile apps and the backends behind them. When a client's users mostly need fast access, offline use and notifications, we build a PWA first instead of two native apps, and we tell them early if their features need native code.

A stacked steel tiffin carrier with tiers labelled web app, manifest and icons, service worker, offline data and sync, and push notifications, linked to Android, iPhone, desktop and an optional Play Store listing
The layers of a Gramosoft PWA, packed in one carrier.

Swipe the table sideways on mobile →

What you need From Gramosoft
The web app Built by our web application development team, often on Angular, whose @angular/pwa package adds the manifest and service worker, or on React
Offline data Caching rules for each kind of request, plus local storage for forms filled in without a signal that sync when the network returns
Design App-like screens, install prompts and offline states from our UI/UX design team
Backend APIs on Spring Boot or Node.js, shared later with a native app if you build one
When native is needed Our mobile app development team builds Flutter or native apps on the same backend
Hosting and security HTTPS, hosting and monitoring through our cloud services, with application security checks

Where we fall short: we don't build games or graphics-heavy apps, and we won't promise iPhone features Safari doesn't support. If your app depends on Bluetooth, NFC or tracking location in the background, we'll recommend a native or Flutter app instead. And we don't run app store marketing.

"Most clients who ask for an app want it to open fast and keep working when the network drops. A good PWA does that from one codebase. We only reach for native when the app needs the phone's hardware."

Rajesh Kannan, Co-Founder & CTO, Gramosoft

What a PWA is and how it works

A progressive web app is an ordinary website plus three things: HTTPS, a web app manifest that tells the device its name, icons and how to open, and a service worker that sits between the app and the network to cache files. Together they make the site installable, fast on repeat visits and usable offline.

A three-legged stool whose seat reads progressive web app and whose legs are labelled HTTPS, manifest and service worker
Three legs hold a PWA up: HTTPS, a manifest and a service worker.

As the web.dev guide puts it, once installed a PWA has an icon on the home screen, opens in its own window without the browser's address bar and can work offline. It's called "progressive" because it still works as a normal website in any browser, and adds the app features where the browser supports them. The MDN reference lists every manifest field and service worker API.

  • Manifest: name, short name, icons, start URL, theme colour and display mode (usually standalone).
  • Service worker: a script the browser runs in the background. It decides, request by request, whether to answer from the network or the cache.
  • HTTPS: service workers only run on secure origins (and on localhost for testing).

PWA vs native app vs website

A PWA sits between a responsive website and a native app. It keeps the website's reach, search visibility and instant updates, and adds installation, offline use and notifications. A native app still has deeper access to the phone's hardware, a store listing and the best performance for heavy graphics.

A mixing desk with horizontal faders comparing a website, a PWA and a native app on reach, working offline, device access and low cost
Website, PWA and native app compared on four qualities.

Swipe the table sideways on mobile →

Feature PWA Native app Website
Gramosoft's default for new clients First choice when it fits When hardware needs it For content-only sites
Installed icon Yes Yes No
Works offline Yes, what you cache Yes No
Push notifications Android, desktop, iPhone once installed Yes No
Bluetooth, NFC, background location Limited or none Yes No
Updates Next visit Store review, then user update Next visit
Found in Google search Yes No (store search instead) Yes
Download size Small Larger None

For a wider view of the choice, see Web App vs Mobile App: Which Should Your Business Build First?. Retail platform NewStore argues the other side for fashion brands, where a native app's richer visuals and store presence can justify the extra cost.

What PWAs can do on Android and iPhone in 2026

Android and desktop Chrome support PWAs well: install, offline use, push notifications and a Play Store listing through a wrapper. iPhone support has improved but still trails. Users install from the Share menu, and push notifications only work after the app is added to the home screen.

A two-part ticket comparing a PWA on Android with Chrome and on iPhone with Safari: install, push, offline, store listing and background sync
What a PWA gets on Android and on iPhone.
  • iPhone push: since iOS and iPadOS 16.4, Home Screen web apps can receive Web Push, and the permission request must come from a user action such as tapping a "subscribe" button. A PWA opened in a Safari tab can't ask.
  • iPhone install: there's no automatic install prompt on iPhone. Show a short "Share, then Add to Home Screen" hint to iPhone visitors.
  • Chrome install rules: Chrome dropped the fetch-handler requirement for installing from the browser menu in version 108 on mobile and 112 on desktop, but its automatic install prompt still needs a service worker with a fetch handler.
  • No Lighthouse PWA score: Chrome removed the PWA category from Lighthouse, so check installability in DevTools (Application, then Manifest) and test offline yourself, as the code below does.
  • Play Store: a PWA can be wrapped as a Trusted Web Activity with Google's Bubblewrap tool and listed on Google Play.

How to build a PWA: manifest, service worker and offline page

A working PWA needs four small files on top of your site: a manifest, a few tags in each page, a service worker with clear caching rules, and a registration script that handles updates safely. The code below is a complete example for a field-service job list, tested offline in headless Chromium.

Start with the manifest. The 192 and 512 pixel icons are the sizes browsers use for the home screen and splash screen. The maskable icon fills Android's adaptive icon shapes without white borders.

manifest.webmanifest

{
  "id": "/",
  "name": "Field Service by Example Co",
  "short_name": "FieldApp",
  "description": "Job sheets for field technicians, online or offline.",
  "start_url": "/?source=pwa",
  "scope": "/",
  "display": "standalone",
  "orientation": "portrait",
  "background_color": "#ffffff",
  "theme_color": "#0f766e",
  "icons": [
    { "src": "/icons/icon-192.png", "sizes": "192x192", "type": "image/png" },
    { "src": "/icons/icon-512.png", "sizes": "512x512", "type": "image/png" },
    { "src": "/icons/maskable-512.png", "sizes": "512x512", "type": "image/png", "purpose": "maskable" }
  ]
}

Add these tags to every page. The Apple touch icon gives iPhone a proper home screen icon.

head-tags.html

<!-- In the <head> of every page -->
<link rel="manifest" href="/manifest.webmanifest">
<meta name="theme-color" content="#0f766e">
<link rel="apple-touch-icon" href="/icons/icon-192.png">

<!-- Before </body> -->
<script src="/register-sw.js"></script>

The service worker applies a different rule to each kind of request. Pages come from the network first so users see fresh content, and fall back to the cache or an offline page. Static files come from the cache first. API reads answer from cache and refresh in the background. Payments, logins and every write go straight to the network and are never cached.

A wooden sorting rack with four slots for the service worker's caching rules: network only for writes and payments, network first for pages, stale while revalidate for API reads and cache first for static files
The four caching rules in sw.js.

sw.js

// sw.js: one service worker, four caching rules.
// Bump VERSION on every release so old caches are deleted.
const VERSION = "v3";
const SHELL = `shell-${VERSION}`;
const RUNTIME = `runtime-${VERSION}`;
const SHELL_FILES = ["/", "/offline.html", "/app.css", "/app.js", "/manifest.webmanifest", "/icons/icon-192.png"];

self.addEventListener("install", (event) => {
  event.waitUntil(caches.open(SHELL).then((cache) => cache.addAll(SHELL_FILES)));
});

self.addEventListener("activate", (event) => {
  event.waitUntil(
    caches.keys()
      .then((keys) => Promise.all(keys.filter((k) => k !== SHELL && k !== RUNTIME).map((k) => caches.delete(k))))
      .then(() => self.clients.claim())
  );
});

// The page asks for this when the user taps "Update now".
self.addEventListener("message", (event) => {
  if (event.data === "SKIP_WAITING") self.skipWaiting();
});

self.addEventListener("fetch", (event) => {
  const req = event.request;
  const url = new URL(req.url);

  // Rule 1: never cache writes, other sites, payments or login.
  if (req.method !== "GET" || url.origin !== self.location.origin ||
      url.pathname.startsWith("/api/pay") || url.pathname.startsWith("/api/auth")) {
    return; // the browser handles it normally (network only)
  }

  // Rule 2: pages are network-first, so users see fresh content, with the offline page as a fallback.
  if (req.mode === "navigate") {
    event.respondWith(
      fetch(req)
        .then((res) => {
          const copy = res.clone();
          caches.open(RUNTIME).then((c) => c.put(req, copy));
          return res;
        })
        .catch(async () => (await caches.match(req)) || caches.match("/offline.html"))
    );
    return;
  }

  // Rule 3: API reads are stale-while-revalidate: answer from cache at once, refresh in the background.
  if (url.pathname.startsWith("/api/")) {
    event.respondWith(
      caches.open(RUNTIME).then(async (cache) => {
        const cached = await cache.match(req);
        const fresh = fetch(req)
          .then((res) => { if (res.ok) cache.put(req, res.clone()); return res; })
          .catch(() => cached || new Response('{"offline":true}', { headers: { "Content-Type": "application/json" } }));
        return cached || fresh;
      })
    );
    return;
  }

  // Rule 4: static files (CSS, JS, icons, fonts) are cache-first.
  event.respondWith(
    caches.match(req).then((cached) => cached || fetch(req).then((res) => {
      if (res.ok) { const copy = res.clone(); caches.open(RUNTIME).then((c) => c.put(req, copy)); }
      return res;
    }))
  );
});

The registration script shows an "Update now" bar when a new version is ready, instead of switching versions in the middle of someone's work. Our first test run caught a common bug here: clients.claim() fires controllerchange on the very first install too, so a naive "reload on controllerchange" reloads the page on a user's first visit. The hadController check fixes that.

register-sw.js

// register-sw.js: load this from every page.
if ("serviceWorker" in navigator) {
  window.addEventListener("load", async () => {
    // Remember whether an older version was already in control before this load.
    const hadController = !!navigator.serviceWorker.controller;
    const reg = await navigator.serviceWorker.register("/sw.js");

    // A new version finished installing while an old one is still in control.
    reg.addEventListener("updatefound", () => {
      const next = reg.installing;
      next.addEventListener("statechange", () => {
        if (next.state === "installed" && navigator.serviceWorker.controller) {
          const bar = document.getElementById("update-bar");
          if (bar) bar.hidden = false; // show "A new version is ready. Update now"
        }
      });
    });

    document.getElementById("update-now")?.addEventListener("click", () => {
      reg.waiting?.postMessage("SKIP_WAITING");
    });

    // Reload once when an updated service worker takes over.
    // Skip it on the very first install, or clients.claim() would reload the page mid-use.
    let reloaded = false;
    navigator.serviceWorker.addEventListener("controllerchange", () => {
      if (hadController && !reloaded) { reloaded = true; window.location.reload(); }
    });
  });
}

The test script serves the example on localhost, opens it in headless Chromium, goes offline, opens a page it has never seen, tries a payment request offline, then releases a new version and checks that the old caches are deleted. All 8 checks passed:

Output

PASS  service worker controls the page
PASS  jobs load online (2 rows)
PASS  manifest has name, start_url, standalone and 192/512 icons
      caches: ['shell-v3', 'runtime-v3']
PASS  offline: home page and jobs load from cache
PASS  offline: unvisited page shows offline.html
PASS  offline: payment POST is never served from cache
PASS  update: 'new version' bar appears
PASS  update: page reloads once and v3 caches are deleted

8/8 checks passed

The download also includes index.html, offline.html, the icons and test_pwa.py. Two habits keep a PWA healthy in production: change VERSION in sw.js on every release, and never cache anything personal or payment-related.

When a PWA is the right choice, and when it isn't

A PWA fits when users come back often, need speed on weak networks, and don't need the phone's hardware beyond the camera and location. It's the wrong choice when the app depends on Bluetooth, NFC, background tracking or heavy graphics, or when store presence matters more than reach.

A weather forecast strip rating app types for a PWA: sunny for booking, field service, portals and catalogues; cloudy for iPhone-heavy audiences; rain for payment terminals and games
How well each kind of app suits a PWA.

Swipe the table sideways on mobile →

Good fit for a PWA Why
Gramosoft client portals and field apps Staff and customers open them daily, often on patchy networks
Booking and appointments Users come back often, and links from WhatsApp or SMS open straight into the app
Ordering and catalogues Search brings visitors, and installing takes one tap
Field service and inspections Forms filled in offline sync later
Dealer, partner and staff portals No store accounts, and every user gets updates at once
Dashboards and internal tools Work on desktop and phone from one codebase

Choose native or Flutter instead if you need Bluetooth or NFC (device pairing, payment terminals), location tracking in the background, rich media or games, or if most users are on iPhone and you need every iOS feature. Our Android App Development Company in Chennai: Cost, Timeline & Team guide covers that route.

What a PWA costs in Chennai

Adding installation and offline support to a well-built web app is a small project, often a few weeks. A new PWA is priced like a web application of the same scope, plus the offline and sync work. In both cases it usually costs much less than two native apps with the same features.

Swipe the table sideways on mobile →

Project Typical Chennai budget Timeline
Gramosoft: PWA features on your existing web app ₹50,000–1.5 lakh 2–4 weeks
New PWA, simple (one user type, light offline) ₹2–5 lakh 6–8 weeks
New PWA with offline sync, roles and payments ₹5–10 lakh 8–12 weeks

GST at 18% is extra. Innovatrix Infotech puts a PWA at ₹5–13 lakh against ₹12–35 lakh for native apps on both platforms, and Bugfender gives US-dollar bands for the same split. For full breakdowns, see Web Application Development Cost in Chennai (2026): What Drives the Price and Mobile App Development Cost in Chennai.

Frequently asked questions

Which company builds progressive web apps in Chennai?

Gramosoft, a Chennai web and mobile company, builds PWAs with offline data, push notifications and optional Play Store listing, and recommends native or Flutter apps when a project needs the phone's hardware.

Do PWAs work on iPhone?

Yes. Users install them with Share, then Add to Home Screen. Since iOS 16.4, installed web apps can receive push notifications after the user taps to allow them. Some features still lag behind Android.

Can a PWA be listed on the Google Play Store?

Yes. Wrap it as a Trusted Web Activity, for example with Google's Bubblewrap tool, and publish it like any Android app. The app content still comes from your website.

Does a PWA work offline?

It works offline for whatever its service worker caches: pages, files and API data you choose. Forms can be saved on the device and sent when the connection returns.

Are PWAs good for SEO?

Yes, if pages render properly for search engines. A PWA is still a website, so each screen can have its own URL and be indexed, unlike content inside a native app.

Can I turn my existing website into a PWA?

Usually, yes. Add a manifest, a service worker and an offline page, serve it over HTTPS, then fix anything slow, because a slow site makes a slow app.

How much does a PWA cost in Chennai?

Adding PWA features to an existing web app typically costs ₹50,000–1.5 lakh. A new PWA costs about ₹2–10 lakh depending on offline sync, roles and payments, plus 18% GST.

RK

Rajesh Kannan M

Rajesh Kannan M is Co-Founder & CTO of Gramosoft in Chennai, where he leads the teams building custom AI, document AI, enterprise search and automation, including GsearchAI, GdoczAI and GcrawlAI, an open-source web scraping, crawling and Search API platform for developers and AI agents, alongside web and mobile applications.

PWA or native app?

Tell us what your users need to do and on which phones. After a free call you'll know whether a PWA covers it, which features would need native code, and a budget band for each route.

CTA Illustration