App development / Progressive Web App Development
Progressive web apps built around real offline needs.
Make your web product useful across connections, installs and updates. Plan safe caching, clear server confirmation and a recovery path for the browsers your users actually use.
Discuss your PWA โContents ยท Progressive Web App Development
Decide what must stay useful offline.
Offline scope comes before the cache
Define which public assets/articles, drafts and actions may be stored, how fresh they must be and what needs a live server decision. A catalogue web app is not automatically an offline PWA. Workbox can implement selected strategies, but routes, permissions, data separation and failure recovery must be designed. No app count, simulated install popup or printed queue state proves a working product.
Install and browser support are separate tests
Manifest/name/icons and install behavior differ across browsers and operating systems. Offline features need a suitable implemented service worker; installability does not itself prove them. Test the actual navigation, installation/removal, storage, notifications and update path. A web distribution route can avoid an app-store submission, while an optional packaged store route has its own identity, policies and review.
A shared web build is not universal capability
PWA browser APIs, permissions, background work and storage have target-specific availability and constraints. Define a fallback when an API is absent or access is refused. Native or shared-native work may suit some required capabilities; do not categorically claim every browser lacks Bluetooth/audio/AR or that a PWA can replace every native app. Use current capability checks and representative tests, not a universal reach or speed claim.
Planning your PWA.
What should a progressive web app development company deliver?
Agree an offline/caching matrix, browser/device targets, manifest/install experience, service-worker scope/update path, allowed storage and backend contracts. Where push belongs, define subscription and credential ownership, consent and unsubscribe. Include dependencies/licences, source/history, host/configuration, tests and receiving recovery. A lab audit, runtime-caching snippet or install icon is not a complete PWA or proof every route works offline.
PWA or native app: which should you build?
Compare how users arrive, public content/SEO, install preference, actual APIs, offline data and background requirements with the receiving team. Browser distribution can suit some commerce, content, booking, forms and internal workflows. Native/shared-native routes may suit actual device integration, extensions or store presence. Neither is universally cheaper or better; different surfaces can share a backend only after identity/contracts and maintenance are designed.
What can a PWA do on iPhone in 2026, and what can it not?
Verify the selected iOS/browser and installed-versus-tab context directly. WebKit documents Home Screen web-app push from iOS/iPadOS 16.4 with permission requested from direct user interaction. Browser install UX is not a universal script-triggered prompt; MDN says beforeinstallprompt is not supported on iOS. Storage and background capability should be checked per feature, with a foreground retry route. Check the specific feature on the selected target.
How do service workers make a PWA work offline?
An implemented/registered worker can intercept controlled requests and use selected cached/network responses. Precaching, runtime routes, fallback UI, allowed methods, expiry and update/lifecycle behavior are distinct work. Offline writes need explicit durable records, authorization, idempotency and reconciliation; a cached GET is not a queued order. First load, partial cache, storage clearing, stale prices and account switches need tests. A worker is not guaranteed to run indefinitely after the UI closes.
Do PWAs rank on Google, and what does Lighthouse measure?
PWA status and offline caching do not guarantee indexing or rank. Define discoverable URLs/links, meaningful HTTP responses, metadata and accessible rendered public content; test actual indexing/rendering needs. Lighthouse can audit selected lab performance, accessibility, best-practice and SEO checks, not certify security, all-device quality or field experience. Chrome documentation removed the PWA category, so inspect actual install behavior separately rather than promise a PWA score.
Can you add a PWA to our existing website?
Audit host/origin/path scope, routing, authentication, assets, API responses, current worker/cache and browser targets before retrofitting. A manifest and registration alone do not provide safe offline behavior. Secure contexts are required for service workers, with local-development exceptions documented by MDN; do not claim every possible HTTP context is forbidden. Agree how old workers/caches and released clients transition, how private pages avoid persistence, and how to recover a bad update.
What does a PWA cost to run after launch?
Include host/CDN, backend/database, provider/messaging, diagnostics, backups, browser compatibility and service-worker upgrades. Direct web distribution avoids the corresponding store submission but still requires downloads, cache/update logic and ongoing operation. Check current push-provider and platform terms, assign operating owners and measure the actual costs.
Architecture that keeps the boundaries clear.
App shell, cache and API are different boundaries
Decide which actual navigation/assets are precached, which requests use runtime strategies and which require fresh authenticated responses. Define worker scope, origin, version and error boundaries. A feature package cannot independently change shared worker lifecycle or IndexedDB schema without compatibility coordination. Keep ownership and receiving recovery visible rather than promise a new module cannot break the existing product.
Lifecycle and durable state need designed rules
Installation, waiting, activation and control affect when new code reaches existing tabs. Specify cache names/content, schema migration, account separation, expiry/deletion and update UX, and test multiple tabs and rollback. Deleting old caches indiscriminately can break still-running clients. A worker strategy does not automatically manage every application version or preserve unsent data. Storage can be cleared or evicted, so acknowledge server state and recoverable drafts explicitly.
Measure actual first and repeat visits
Test cold/return navigation, large images, slow/flaky networks, missing cache entries, updates and online/offline transitions on actual browsers/devices. Use production-like bundles and suitable lab/field measurements with permitted telemetry. Lazy loading and cache-first can change work but do not guarantee instant first paint or a chosen score everywhere. A high Lighthouse run is evidence of that run, not authenticated client outcomes or all-user performance.
Plan for the target, not only the framework.
Background sync is not a delivery guarantee
Browser support and execution limits vary. MDN describes browser termination and bounded retries; Workbox Background Sync is a separate module, absent from this fragment, with its own failure/replay behavior. Its documented default failure path is a thrown network error, not every HTTP error status. Design foreground retry, queue expiry, re-authentication, duplicate prevention and visible pending/failed states. Never treat reconnection as proof every deferred action completed.
Browser delivery and optional store packaging differ
Direct web hosting, installed desktop/mobile windows and Trusted Web Activities have distinct capability and release expectations. TWA verification uses Digital Asset Links with the correct signing identity and owned origin; failure can fall back to a browser tab. A wrapper does not establish Play/App Store acceptance or remove current policies. Service-worker updates still download and activate under lifecycle rules, so deployment is not an instant update for every existing client.
If a related project uses Flutter web, plan offline caching separately: current Flutter documentation says it no longer generates or manages a caching service worker by default.
Technical example: runtime cache routes.
Illustrative code. Registration, offline navigation, private-data rules and update behavior need their own implementation.
Scroll the code sideways if a line does not fit your screen.
import { registerRoute } from
'workbox-routing';
import { CacheFirst, StaleWhileRevalidate }
from 'workbox-strategies';
registerRoute(
new RegExp('/assets/*'),
new CacheFirst()
);
registerRoute(
new RegExp('/api/*'),
new StaleWhileRevalidate()
);Only two runtime GET routes are supplied
The fragment imports registerRoute and CacheFirst/StaleWhileRevalidate, then registers asset and API patterns. It shows no worker registration/build integration, scope, manifest, install/activate logic, precache list or offline navigation fallback. Workbox route registration defaults to GET unless another method is specified; this sample does not cache/queue POST orders, comments or payments. Registration, lifecycle and offline navigation need a complete implementation.
The regular expressions are broader than path globs
The strings /assets/* and /api/* are passed to RegExp, not a glob matcher. The star repeats the slash rather than mean every child path, and these unanchored patterns can match unrelated prefixes. Actual JavaScript checks confirm /api/* matches /apiculture and /assets/* matches /assetsXYZ. Workbox also distinguishes same-origin partial matching from cross-origin full-URL-prefix matching. Inspect explicit URL/method/origin predicates rather than assume intended route boundaries.
Stale API responses can cross a safety boundary
StaleWhileRevalidate can serve a cached response while fetching an update; that is not an appropriate blanket freshness rule for balances, prices, inventory or account records. The sample supplies no cache-name/expiration plugin, private-route exclusion, account cleanup, durable write queue, push, idempotency or schema validation. It does not establish automatic versioning or precaching merely by importing Workbox. Define cache contents and success/error behavior deliberately before enabling it on real traffic.
Privacy, storage and authoritative state.
Classify public cacheable responses separately from account pages, tokens, payment states and personal records. Cache API/IndexedDB are persistence mechanisms, not an authorization or encryption guarantee. Sign-out/account-switch cleanup, retention, protected keys and sensitive error/analytics fields need actual implementation. Hosted payment fields or HTTPS alone do not establish PCI DSS compliance or safe application logic. Review push endpoint/subscription exposure, consent and actual diagnostic recipients.
Move the product without losing its working behavior.
Audit the existing host, route/origin, worker scope, cache/schema versions, authentication and deployed tabs before introducing or replacing a PWA layer. Preserve allowed offline drafts and do not silently replay old mutations into incompatible APIs. Test account switches, clear/evict, offline-to-online, multiple tabs and interrupted updates with a recovery route. Review the selected worker scope and release through the authorized hosting account.
Agree what a successful handover looks like.
Use representative records and the agreed browser/device matrix to test setup, sign-in, denied permissions, malformed responses, stale data, offline-to-online recovery, account changes and interrupted updates. Include keyboard/screen-reader access, build/release ownership and a receiving-team recovery exercise. Document unresolved limits alongside the accepted behavior.
Six product patterns and the work behind them.
These are planning examples, not claims of available software inventory. Inspect an actual base, licence and working product before relying on reuse. Familiar product names describe a business model, not affiliation or permission to copy protected assets.
Airbnb concept
Listings, dynamic pricing, booking calendar and reviews require availability, transaction and host/guest recovery; offline and update behavior must be implemented for the browser product.
Swiggy concept
Discovery, location, scheduled ordering and vendor dashboards need freshness and merchant/courier state across connections.
inDrive concept
Negotiated fare, tracking and ratings need accepted price, matching and safety/cancellation boundaries.
Rover concept
Walking, boarding, sitting and grooming booking needs provider availability, handover and dispute handling.
Tinder concept
Swipe matching, chat, location, verification and premium access need age/privacy, moderation and purchase rules.
Cameo concept
Personalized-video ordering and delivery need rights, creator/customer state, entitlement and payout/dispute design.
Compare routes against the actual requirement.
On smaller screens, scroll the table sideways to read every column.
| Decision | PWA / browser | Shared-native app | Native app |
|---|---|---|---|
| Interface | Browser layout and APIs. | Framework UI plus native modules. | Platform toolkit interfaces. |
| Offline | Explicit worker/cache/local-data design. | Explicit local records and synchronization. | Explicit local records and synchronization. |
| Device features | Check browser, installed context and permission support. | Check plugins/modules, native lifecycle and signing. | Check OS/API, permission and account availability. |
| Distribution | Direct web; optional packaging has separate rules. | Selected store or approved distribution channel. | Selected store or approved distribution channel. |
| Fit | Match user arrival, content and browser capability. | Match shared-code and integration needs. | Match target-specific depth and team capability. |
No route is universally fastest, cheapest or most secure. Compare the same workload, constraints, team and acceptance evidence.
Choose the engagement around the existing product.
Inspected application base
Review the actual source, licence, features and dependencies before choosing branding or configuration. Separate existing web/mobile/admin work from missing integrations and custom features.
Custom product build
Define your interface, domain, server, integration and release requirements. Set acceptance, named responsibilities and receiving-team handover around those flows.
Continuing development
Agree feature changes, compatibility work, releases, maintenance and incident ownership with current capacity, change control and support terms.
Seven areas to review before release.
Architecture
Separate interface, domain rules, network and persistence. Review dependency direction and error contracts with the actual product flows.
State
Represent loading, available, empty, stale, denied and failed states. Handle cancellation, retries and account changes without displaying another user's records.
Performance
Measure startup, navigation, input response, memory and network behavior using packaged or production-like builds on agreed devices. Keep measurements and acceptance conditions together.
Target testing
Use the agreed browser, OS and physical-device matrix with keyboard, screen reader, permissions, interruptions and poor networks. Include real integration and recovery behavior.
Build and release
Keep reproducible dependencies, reviewed configuration and automated tests. Separate a passing build, a testing release, external review and a customer launch.
Security and privacy
Review server authorization, credential handling, local storage, diagnostics and SDK data flows. Client configuration is not a safe place for privileged secrets.
Handover
Demonstrate setup, build, account access, release, stopping and recovery with the receiving team. Deliver the agreed source, dependencies and operating documentation.
Six release and handover checks.
Review changes
Review application, server, dependency and release-configuration changes under named owners. Track unresolved findings alongside passing tests.
Test critical paths
Combine domain, interface and integration tests for the product's important actions, denied access and failure/recovery cases. Coverage helps locate gaps; it does not replace meaningful scenarios.
Measure representative builds
Profile the selected release paths under realistic data and network conditions. Record target, build, environment and acceptance thresholds.
Prepare the handover
Supply agreed source/history, dependency locks, setup/API documentation, configuration and runbooks. Transfer secrets through a protected route and demonstrate receiving operation.
Authorize distribution
Verify the correct hosting or developer account, signing, domain and listing configuration, privacy declarations and review access. Keep external review and launch approvals separate.
Assign operation
Agree error/performance monitoring, diagnostic privacy, alert ownership, maintenance and incident response before handover.
Technology choices for the agreed product.
On smaller screens, scroll the table sideways to read every column.
| Area | Potential role | Project check |
|---|---|---|
| Workbox | Worker libraries | Choose routing/precache/expiry/queue modules explicitly. |
| Lighthouse | Lab audits | Separate measured run from field results and install tests. |
| Service Worker API | Controlled request/events | Respect scope, lifecycle, limits and secure contexts. |
| IndexedDB | Local structured records | Design schema, retention, account and eviction recovery. |
| Firebase | Possible auth/push/diagnostics | Verify actual web support, purpose and access. |
| Google Maps | Map/location UI | Check freshness, permissions, keys and terms. |
| Stripe / Razorpay | Payment integration | Keep server confirmation and eligible provider boundaries. |
| WebSockets | Live events | Reconcile reconnect, order, freshness and auth. |
| GraphQL / REST | API contracts | Validate responses, mutations and client compatibility. |
| Cache API | Request/response storage | Classify actual allowable private/public contents. |
| Web Push | Notification delivery | Respect permission, subscription and unsubscribe/failure. |
| Node.js API | Possible backend | Define access, persistence and operating scope. |
| React / Angular | Possible UI | Inspect actual routes, rendering and compatible tooling. |
| Sentry | Diagnostics | Limit personal data and assign response. |
| Web App Manifest | Identity/install metadata | Test selected browser/name/icons/start/display behavior. |
| Docker / AWS | Possible hosting | Verify target configuration, access and recovery. |
From requirements to receiving-team handover.
Brief and confidentiality
Describe the users, workflows, target devices, existing systems and permitted source material. Agree confidentiality and decision owners before sharing sensitive data.
Scope and plan
Choose the shared/native/browser boundary, inspected components, backend/admin work, integrations and acceptance matrix. Put dependencies, rights, milestones and an itemized quote in writing.
Build and review
Implement in versioned code with tests and a suitable review environment. Agree progress demonstrations that show complete flows as well as individual screens.
QA and release preparation
Check permissions, accessibility, privacy, external integrations, failure and recovery on the selected targets. Profile release builds and verify current distribution requirements.
Handover and launch
Transfer the agreed work and access, demonstrate receiving operation and release only through the approved account and channel. Keep provider onboarding and commercial launch decisions visible.
Scope the build and its ongoing costs.
Application base
Identify which source, interface, backend/admin, integration and distribution work actually exists and what must change. Verify rights and dependencies before estimating reuse.
Custom work
Estimate the flows, targets, integrations, permissions, data migration, offline recovery, evaluation and handover. Separate provider onboarding and external review from engineering.
Continuing operation
Include hosting, storage, API/messaging use, diagnostics, framework/native/browser upgrades, incident response and maintenance where needed. Request a current written scope review and itemized quote before a commitment.
Project planning examples.
News and offline reading
Design readable public news routes, permitted offline articles and intermittent-network recovery. An Angular/Workbox implementation can separate app resources from content freshness. Plan topic push, Firebase Cloud Messaging where supported, image variants at the required breakpoints and lazy loading without hiding public article content from readers or crawlers.
Bills and receipts
Treat saved receipts as records of confirmed server transactions, not proof that a pending payment completed. Plan due-date Web Push with permission and delivery limits, a contextual install invitation after repeat use where supported, hosted payment fields and Arabic/English right-to-left layouts. Define online confirmation and recovery for interrupted or duplicate submissions.
Shared product and operations
Separate the customer browser app, merchant/provider interface, admin and API. Define which existing web/mobile components can actually be reused, which APIs are missing and which routes may store data locally. Assign ownership for catalogue content, account permissions, push campaigns and cache/update diagnostics.
Different industries need different operating rules.
Healthcare and life sciences
Protect patient access, purpose and health-data flows. Review clinical, legal and security requirements; a framework or offline feature is not a compliance certification.
Telemedicine
Define appointment, consultation, camera/microphone, notification and connectivity behavior. Keep clinical decisions and session/payment confirmation with the appropriate service.
Finance
Use authoritative server records for balances and transactions. Review identity, regulated provider eligibility, authentication, duplicate prevention and reconciliation.
Retail and commerce
Handle inventory freshness, prices, substitutions, orders, refunds and fulfilment states. A cached product or pending request must not look like a confirmed purchase.
Media and entertainment
Plan permitted content, playback, downloads, subscriptions and accessibility. Test actual browser/device media and background constraints.
Creator platforms
Design content rights, moderation, age/access rules, entitlement, payouts and disputes. Keep third-party payment and store requirements in the scope.
Transport and mobility
Model location age, permission refusal, matching, accepted fares, cancellation and dispatch recovery. Review foreground/background behavior on the real targets.
Food and beverage
Connect menu, merchant availability, ordering, kitchen and courier states. Define substitutions, cancellation and recovery when connectivity or a provider fails.
Check the supplier and the work you will receive.
Contracting identity
Verify the legal entity, registration evidence and matching contract/invoice details.
Relevant delivery evidence
Ask for dated, permitted examples tied to the target technology and actual responsibilities. Review source, build, dependencies and recovery behavior.
Independent reviews
Read the actual profile, reviewer, date and engagement rather than a rating printed on a supplier site.
A second reference
Compare another independent review or client-authorized reference and resolve identity or scope differences.
Working product
Inspect the agreed device/browser flows, access control, failure recovery and receiving setup, not only screenshots.
Rights and exit
Check source and asset licences, third-party dependencies, account ownership, handover and exit terms in writing.
Put three working terms in the agreement.
Responsibilities
Name the product, engineering, review, QA, release and operating owners. Agree decision paths and review responsibilities.
Evidence and acceptance
Identify the actual components, targets, dependencies, permitted data and acceptance checks. Keep unresolved limits visible.
Rights and support
Define source and asset rights, account access, receiving handover, exit, maintenance, defects and support in current terms.
Questions about PWA development.
Can a PWA truly replace a native app for my use case?
Only if the actual browser/device, install, offline data, media, background and integration requirements pass representative tests. Cached assets are not universal instant loading, and push/storage have permission and platform limits. Native/shared-native work may suit some features or distribution needs. A PWA label alone does not prove it matches or exceeds a native product.
How much does PWA development cost at Omnistu?
Obtain a current written scope review and itemized quote for the inspected base, custom interface/server/plugin work, backend/admin, integrations, target QA and receiving. Include hosting, provider/accounts and continuing operation where relevant. Confirm the selected work, dependencies and ongoing costs in the quote.
Does Omnistu deliver the full source code?
Agree the actual repository/history, worker/configuration, manifest, assets/licences, API/setup/host documentation and receiving rebuild/update/recovery. Identify reusable/third-party components and transfer allowed hosting/push roles and secrets securely. A source-code badge does not prove IP assignment, zero lock-in or an immediately operable receiver deployment.
How fast can a PWA realistically be delivered?
Estimate from the inspected code and missing functionality, target/role matrix, integrations, migration, evaluation and receiving work. Separate engineering, external account verification, provider onboarding and store review. Set milestones around that work and the prerequisites in current written terms.
PWA vs Native App - which does Omnistu recommend?
Compare actual public content/user arrival, browser APIs, install preference, offline writes, target compatibility and receiver. A direct-web PWA and store-distributed client can address different needs on an agreed backend. Neither is the universal right answer for content, commerce, audio or hardware; inspect the selected capability/support rather than decide from a broad category label.
What admin panel features are included with a PWA delivery?
Define content/users, permitted analytics, push subscription/campaign operation and service-worker/cache diagnostics that are actually needed. A browser admin is a separate deliverable with roles, audit and API integration, not guaranteed by a PWA build. Install/usage/CTR measurements need real lawful collection and defined denominators; a counter or mock dashboard proves none of them.
Does Omnistu handle App Store and Google Play submission?
Direct browser distribution does not require submitting that website to an app store. Optional TWA/packaged/native-shell routes have signing, owned-origin verification and actual store-policy/review requirements; none guarantees acceptance. Inspect the chosen route rather than categorically assume every wrapper is forbidden or approved. Decide listing, packaging and submission work in the scope.
What happens after the app is delivered if there are bugs?
Agree supported environments, accepted defects, diagnostic privacy, incident ownership and authorized fixes/releases in current terms. Separate maintenance and new scope. Assign a response owner and put support coverage, escalation and maintenance in the agreement.
How does Omnistu handle NDA and confidentiality?
Agree confidentiality, permitted source/data access, reusable-component/licence rights and receiving/exit terms before sensitive disclosure. Restrict account roles and transfer secrets securely. A printed NDA or ownership badge does not prove a signed agreement or ownership of third-party code, assets or vendor services.
Can a PWA be installed on desktop computers?
Check the selected desktop OS/browser version, install or Add to Dock route, manifest/identity, keyboard, window behavior and actual layout. Support and store-packaging options differ; a website can be usable without an installed standalone window. Test install/update/uninstall and account/data behavior rather than promise every browser or desktop uses the same flow.
How do updates reach users of a PWA?
Deployment makes new resources available, but an existing worker/client follows fetch/install/wait/activate/control and cache rules. Users may retain old tabs, be offline or decline an update prompt. New bytes still download. Test compatible assets/API/schema, multiple tabs, in-progress drafts, cleanup and recovery. A cache name alone does not ensure every client instantly updates or never serves stale content.
Is a PWA secure enough for logins and payments?
Use secure transport, suitable authentication/passkeys, protected server-side secrets, authorization and deliberate cache/storage boundaries, with an eligible payment provider and server-confirmed state. Hosted fields, Payment Request or HTTPS are not a complete security model or PCI DSS assessment. Define actual browser support, threat tests and provider/account rules. Never equate an offline draft/receipt or queued request with a completed payment.
Platform and implementation references.
Use the documentation for the versions, targets and configuration selected for your product.
- developer.chrome.com
- developer.chrome.com
- developer.chrome.com
- developer.chrome.com
- Service Worker API - Web APIs | MDN - developer.mozilla.org
- Making PWAs installable - Progressive web apps | MDN - developer.mozilla.org
- Caching - Progressive web apps | MDN - developer.mozilla.org
- Offline and background operation - Progressive web apps | MDN - developer.mozilla.org
- Web Push for Web Apps on iOS and iPadOS | WebKit - webkit.org (2023-02-16)
- developer.chrome.com
- Understand JavaScript SEO Basics | Google Search Central ย |ย Documentation ย |ย Google for Developers - developers.google.com
- Platform documentation
- Flutter web FAQ
Bring your product and target requirements.
Share your users, existing code, device/browser targets, integrations, offline needs and the team that will maintain the product. Agree the build boundaries, acceptance evidence, rights and operating responsibilities before implementation.
Discuss your project โ