PWA, aplicaciones web progresivas: qué son y cómo crear una
Una PWA (aplicación web progresiva) es una web que se instala en el móvil o en el ordenador como si fuera una app, sin pasar por Google Play ni por la App Store y sin escribir dos aplicaciones nativas.
Sigue siendo la misma web, pero tiene su propio icono en la pantalla de inicio y se abre en su propia ventana, como cualquier app.
¿Qué es una PWA o aplicación web progresiva?
PWA son las siglas de Progressive Web App, «aplicación web progresiva». MDN la define como una app construida con tecnologías de la web que ofrece una experiencia parecida a la de una app propia de cada plataforma: como una web, funciona en varios sistemas con un solo código; como una app, se instala, puede funcionar sin conexión y en segundo plano, y se integra con el dispositivo.
Lo de «progresiva» significa que se parte de una web normal y se le añaden capacidades de app poco a poco: la web funciona en cualquier navegador y, en los que lo permiten, gana extras.
Esos extras pueden ser:
- Icono en el móvil o en el escritorio, como una aplicación nativa, y ventana propia sin la barra del navegador.
- Funcionar sin conexión a Internet, o con una conexión mala, gracias a la caché.
- Notificaciones push, incluso con la app cerrada.
- Usar características del dispositivo a las que da acceso el navegador: cámara, ubicación, compartir, etc.
- Se actualiza sola: no hay que publicar versiones en una tienda; el usuario recibe la última al visitarla.
- Carga rápido en las visitas siguientes, porque reutiliza lo que ya está en caché.
PWA frente a app nativa
Una app nativa se escribe para un sistema concreto (Kotlin o Java para Android, Swift para iOS) y se distribuye por su tienda. Una PWA es una sola web que se instala desde el navegador. La tabla resume la diferencia; es una explicación nuestra a partir de la guía de MDN, que compara las PWA con las webs tradicionales y con las apps de cada plataforma:
| PWA | App nativa | |
|---|---|---|
| Código | Uno solo para todos los sistemas | Uno por sistema (Android, iOS…) |
| Cómo llega al usuario | Con un enlace; también se puede publicar en tiendas | Desde la tienda de cada sistema |
| Buscadores | Sus páginas se indexan como cualquier web | Se busca dentro de la tienda |
| Actualizaciones | El usuario recibe la última versión al abrirla | Hay que publicar cada versión en la tienda |
| Acceso al dispositivo | Lo que permita cada navegador: cámara, ubicación, notificaciones… | Todo lo que ofrece el sistema |
Cuándo conviene cada una (criterio nuestro):
- PWA: si tu producto ya es una web, si quieres llegar a Android, iOS y escritorio con un solo equipo, o si te importa que te encuentren en Google.
- App nativa: si dependes de funciones del sistema que el navegador no ofrece, o de un rendimiento muy ajustado, como un juego exigente.
Entre las dos están las apps híbridas, que empaquetan una web dentro de una app nativa (Capacitor o Cordova) para publicarla en las tiendas.
¿Qué no es una PWA?
- No es una extensión de navegador.
- No es un framework, un plugin ni una librería: es un conjunto de técnicas estándar de la web. Hay librerías que ayudan, como Workbox, del equipo de Chrome, que simplifica las estrategias de caché del service worker; pero ninguna es obligatoria.
- No es una aplicación nativa ni una híbrida.
- No es solo una web responsive. Una PWA debe adaptarse a cualquier pantalla, pero además se instala y puede funcionar sin conexión.
Ejemplos de PWA
Estas webs publican un manifiesto de aplicación y Chrome no les pone ninguna pega para instalarlas (comprobado el 9 de noviembre de 2026 con Chrome 157):
| Web | Qué es | Service worker |
|---|---|---|
| Squoosh | Compresor de imágenes de Google Chrome Labs | Sí |
| Excalidraw | Pizarra para dibujar diagramas a mano alzada | Sí |
| Spotify | El reproductor web de Spotify | Registrado, pero no activo en la prueba |
| La versión web de Pinterest | No, en la visita sin sesión |
Fíjate en la última columna: Chrome no le pone pegas a Pinterest aunque no tenga service worker. El service worker no es obligatorio para instalar una PWA; es lo que le permite funcionar sin conexión. Esa diferencia entre «instalable» y «funciona sin conexión» la verás en el ejemplo.
Cómo crear una PWA paso a paso
- Sirve tu web por HTTPS.
- Crea el manifiesto y enlázalo desde tus páginas.
- Añade un service worker para que funcione sin conexión.
- Comprueba que se puede instalar.
El ejemplo completo son seis ficheros en la misma carpeta:
mi-pwa/
├── index.html
├── manifest.webmanifest
├── app.js
├── sw.js
├── icon-192.png
└── icon-512.png
1. HTTPS
Las PWA y los service workers solo funcionan en páginas servidas por HTTPS. Para desarrollar hay una excepción: localhost y 127.0.0.1 también valen, así que puedes probar en tu ordenador sin certificado.
2. El manifiesto
El manifiesto (en inglés, web app manifest) es un fichero JSON que le cuenta al navegador cómo es tu app: su nombre, sus iconos, desde qué página arranca y cómo se muestra. Sin él, el navegador no sabe qué está instalando.
{
"name": "Mi primera PWA",
"short_name": "Mi PWA",
"start_url": "/",
"display": "standalone",
"background_color": "#ffffff",
"theme_color": "#1a73e8",
"icons": [
{ "src": "/icon-192.png", "sizes": "192x192", "type": "image/png" },
{ "src": "/icon-512.png", "sizes": "512x512", "type": "image/png" }
]
}
| Campo | Para qué sirve |
|---|---|
name y short_name |
Nombre completo y nombre corto, el que aparece bajo el icono |
start_url |
Página que se abre al lanzar la app |
display |
standalone abre la app en su propia ventana, sin la barra del navegador; minimal-ui deja unos controles mínimos |
icons |
Iconos de la app; Chrome, Edge y Samsung Internet piden uno de 192 px y otro de 512 px |
background_color y theme_color |
Color de la pantalla de carga y de la barra del sistema |
Guárdalo como manifest.webmanifest, que es la extensión del estándar, y sírvelo con el tipo application/manifest+json. Los navegadores también aceptan manifest.json. Después, enlázalo en el <head> de cada página:
<link rel="manifest" href="/manifest.webmanifest">
3. El service worker
Un service worker es un pequeño programa en JavaScript que el navegador ejecuta aparte de tu página. Se coloca entre tu web y la red, y decide qué hacer con cada petición.
Normalmente deja pasar la petición a la red; si no hay conexión, puede responder con lo que guardó antes en la caché. Solo puede servir lo que guardó: si un fichero nunca se guardó, sin conexión no carga.
Primero, regístralo desde tu página con app.js:
if ("serviceWorker" in navigator) {
navigator.serviceWorker
.register("/sw.js")
.then(() => console.log("Service worker registrado"))
.catch((error) => console.error("No se pudo registrar:", error));
}
La comprobación "serviceWorker" in navigator hace que, en un navegador sin soporte, la web siga funcionando con normalidad, solo que sin los extras. Eso es lo «progresivo».
Ahora, el service worker (sw.js). Este primero intenta la red y, si falla, tira de la caché:
const CACHE = "mi-pwa-v1";
const ARCHIVOS = ["/", "/app.js", "/manifest.webmanifest", "/icon-192.png"];
// Al instalarse, guarda en caché lo imprescindible.
self.addEventListener("install", (event) => {
event.waitUntil(caches.open(CACHE).then((cache) => cache.addAll(ARCHIVOS)));
});
// Al activarse, borra las cachés de versiones anteriores.
self.addEventListener("activate", (event) => {
event.waitUntil(
caches.keys().then((claves) =>
Promise.all(claves.filter((c) => c !== CACHE).map((c) => caches.delete(c)))
)
);
});
// En cada petición: primero la red; si no hay conexión, la caché.
self.addEventListener("fetch", (event) => {
if (event.request.method !== "GET") return;
event.respondWith(
fetch(event.request).catch(() => caches.match(event.request))
);
});
Tres detalles que conviene saber:
- Dónde lo pones importa. Un service worker solo controla las páginas de su carpeta y las de debajo. Si está en
/js/sw.js, solo controla/js/.... Por eso va en la raíz. - Cada versión, su caché. Cuando cambies los ficheros, sube el nombre (
mi-pwa-v2). Así el eventoactivateborra la caché vieja. - Las actualizaciones no son inmediatas. La nueva versión del service worker espera a que cierres todas las pestañas que usan la anterior.
4. Pruébalo en local
Para servir los ficheros sin instalar nada más que Node.js, guarda esto como server.mjs en la misma carpeta:
// Servidor mínimo para probar en local. No lo uses en producción.
import { createServer } from "node:http";
import { readFile } from "node:fs/promises";
import { extname, join, normalize } from "node:path";
const TIPOS = {
".html": "text/html; charset=utf-8",
".js": "text/javascript; charset=utf-8",
".webmanifest": "application/manifest+json",
".png": "image/png",
};
createServer(async (req, res) => {
const { pathname } = new URL(req.url, "http://localhost");
const ruta = normalize(pathname === "/" ? "/index.html" : pathname);
try {
const contenido = await readFile(join(import.meta.dirname, ruta));
res.writeHead(200, { "Content-Type": TIPOS[extname(ruta)] ?? "application/octet-stream" });
res.end(contenido);
} catch {
res.writeHead(404).end("No encontrado");
}
}).listen(8080, "127.0.0.1", () => console.log("Abre http://localhost:8080"));
Y el index.html más sencillo posible:
<!doctype html>
<html lang="es">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Mi PWA</title>
<link rel="manifest" href="/manifest.webmanifest">
<link rel="icon" href="/icon-192.png">
</head>
<body>
<h1>Hola, PWA</h1>
<script src="/app.js"></script>
</body>
</html>
Para los iconos, cualquier PNG cuadrado de 192 × 192 y de 512 × 512 píxeles sirve.
Antes de abrir el navegador, comprueba que no hay errores tontos:
node --check sw.js # sin salida: el service worker no tiene errores de sintaxis
node -e 'JSON.parse(require("fs").readFileSync("manifest.webmanifest","utf8")); console.log("Manifiesto OK")'
node server.mjs # arranca el servidor
Manifiesto OK
Abre http://localhost:8080
Si el puerto 8080 está ocupado, aquí tienes cómo liberar un puerto en Windows.
Abre http://localhost:8080 en Chrome o Edge y ve a las herramientas de desarrollo (F12), pestaña Application:
- En Manifest ves si el navegador ha leído bien el manifiesto y qué le falta para ser instalable.
- En Service workers ves si está activo. Marca Update on reload mientras desarrollas para que cada recarga instale la versión nueva.
- En Cache storage ves lo que ha guardado: la caché
mi-pwa-v1con/,/app.js,/manifest.webmanifesty/icon-192.png. - Para simular que no tienes conexión, marca Offline en la sección Service workers y recarga. Una prueba todavía más directa: para el servidor con Ctrl + C y recarga. La página sigue apareciendo, servida desde la caché.
Si es la primera vez que abres las DevTools, tienes una guía en Chrome DevTools.
Errores típicos al crear una PWA
- «Mi página no está controlada por el service worker». En la primera visita, el service worker se instala, pero no controla la página que lo ha registrado: empieza a hacerlo a partir de la siguiente carga. Si necesitas que tome el control en el acto, MDN explica
clients.claim(), que se llama en el eventoactivate. - «Sin conexión, una página da error». El service worker solo puede servir lo que guardó antes. Con el ejemplo y el servidor apagado,
/carga desde la caché, pero una página que nunca se guardó, como/contacto.html, falla connet::ERR_FAILED. Añade aARCHIVOSlo que deba funcionar sin conexión, o una página propia de «sin conexión». - «Chrome no me ofrece instalarla». En la pestaña Manifest de DevTools aparece el motivo. Motivos habituales: falta el icono de 192 o el de 512 px, el
start_urlestá mal escrito o la web se sirve porhttp://en un dominio que no eslocalhost. - «El service worker no ve mis páginas» o «no veo los cambios». Repasa los tres detalles del apartado del service worker: dónde está el fichero, el nombre de la caché y que la versión nueva espera a que cierres las pestañas.
Cómo se instala una PWA
En Chrome, el navegador ofrece instalarla cuando se cumplen sus criterios: HTTPS, un manifiesto con los campos de la tabla anterior, que no esté ya instalada y que el usuario haya interactuado con la página (al menos un clic y 30 segundos de visita, en cualquier momento). Aparece un icono de instalar en la barra de direcciones o la opción Instalar en el menú.
El service worker no es obligatorio para instalarla, aunque es lo que permite que la app funcione sin conexión.
Soporte de PWA en Chrome, Edge, Firefox y Safari
Según MDN, en noviembre de 2026:
| Navegador | Escritorio | Móvil |
|---|---|---|
| Chrome | Instala PWA en Windows, macOS, Linux y ChromeOS | Android: la instala como una app más (WebAPK) |
| Edge | Instala PWA (usa el mismo motor que Chrome) | Android: crea un acceso directo que abre el navegador |
| Samsung Internet | — | Android, en móviles Samsung: la instala como una app más (WebAPK) |
| Firefox | No instala PWA a partir del manifiesto | Android: crea un acceso directo que abre el navegador |
| Safari | macOS Sonoma (Safari 17) o posterior: Archivo > Añadir al Dock | iPhone y iPad: Compartir > Añadir a pantalla de inicio |
PWA en Android
En Android, Chrome convierte la PWA en una WebAPK: una app de verdad que aparece en el cajón de aplicaciones y en los ajustes del sistema. Necesita un móvil con los servicios de Google. Samsung Internet hace lo mismo en móviles Samsung. Otros navegadores, como Firefox o Edge, se limitan a poner un acceso directo en la pantalla de inicio.
PWA en iPhone y iPad (iOS)
En iOS el soporte ha mejorado mucho desde 2019, cuando se publicó la primera versión de este artículo:
- Safari ya permitía añadir una web a la pantalla de inicio desde su menú Compartir. Desde iOS 16.4 también se puede hacer desde Chrome, Edge, Firefox y Orion (MDN). Según WebKit, las apps añadidas así pueden recibir notificaciones push y mostrar un número en el icono. El permiso para notificaciones solo se puede pedir después de que el usuario pulse algo, como un botón de «Suscribirme».
- Con Safari 26 (iOS 26), según WebKit, toda web que añades a la pantalla de inicio se abre como app por defecto, aunque no tenga manifiesto. El usuario puede desactivar «Abrir como app web» para que sea un simple marcador.
- iOS no muestra un aviso automático de instalación: el usuario tiene que hacerlo desde el menú Compartir. Si quieres que tu público la instale, explícaselo.
Tu chuleta
| Paso | Qué hacer |
|---|---|
| HTTPS | Sirve la web por HTTPS (en local, localhost vale) |
| Manifiesto | manifest.webmanifest con name, start_url, display e iconos de 192 y 512 px |
| Enlace | <link rel="manifest" href="/manifest.webmanifest"> en cada página |
| Service worker | sw.js en la raíz, registrado desde la página |
| Sin conexión | Lo que no esté en la caché, no carga |
| Comprobar | DevTools > Application > Manifest, Service workers y Cache storage |
Si quieres ir más allá con las notificaciones, en Push API tienes un vídeo y un ejemplo con el código de esta API.
Fuentes
Documentación oficial comprobada en noviembre de 2026:
- MDN, Progressive web apps (modificada el 31 de agosto de 2026): definición de PWA.
- MDN, What is a progressive web app? (modificada el 4 de diciembre de 2025): comparación con las webs tradicionales y las apps de cada plataforma, y distribución en tiendas.
- MDN, Making PWAs installable (modificada el 6 de octubre de 2026): requisitos de instalación, HTTPS y
localhost, service worker no obligatorio y soporte por navegador y sistema. - MDN, Clients: claim(): la página que registra el service worker no queda controlada hasta la siguiente carga.
- MDN, Web application manifest: extensión
.webmanifest, tipoapplication/manifest+jsony enlace desde cada página. - MDN, Using Service Workers (modificada el 25 de septiembre de 2026): ciclo de vida, ámbito según la carpeta y registro.
- web.dev, What does it take to be installable?: criterios de instalación de Chrome, con el clic y los 30 segundos de visita.
- Chrome for Developers, Workbox, y su repositorio: versión 7.4.1 (mayo de 2026), mantenida por el equipo Aurora de Chrome.
- web.dev, The service worker lifecycle: la recarga forzada se salta el service worker y la opción Update on reload.
- WebKit, Web Push for Web Apps on iOS and iPadOS: notificaciones push e insignias en iOS 16.4.
- WebKit, News from WWDC25: Safari 26: webs añadidas a la pantalla de inicio que se abren como app por defecto.
Ejecutado el 9 de noviembre de 2026 con Node.js 24.21.0 y Google Chrome 157 sin interfaz (automatizado con puppeteer-core 24.43.1) en Linux, con los ficheros tal como aparecen en el artículo: el servidor entrega cada fichero con su tipo y responde 404 a rutas que no existen; el service worker se registra y se activa, no controla la primera visita y sí la recarga; la caché mi-pwa-v1 guarda los cuatro ficheros; Chrome lee el manifiesto sin errores y no informa de ningún error de instalabilidad; con el servidor apagado, / carga desde la caché y /contacto.html falla con net::ERR_FAILED. Los ejemplos de PWA se comprobaron con el mismo Chrome, leyendo su manifiesto y su service worker. No se ha probado la instalación en un móvil Android ni en iOS: lo que depende de ellos sigue la documentación anterior.