Nivel inicial17 min de lectura · Publicado el

PWA, aplicaciones web progresivas: qué son y cómo crear una

PWA: una web en el navegador, con HTTPS, manifiesto y service worker, se instala y aparece como el icono Mi PWA en la pantalla de inicio del móvil. PWA: tu web, instalablerubentejera.com Instalartu webHTTPSmanifestsw.jsMi PWA
Es la misma web: con HTTPS, un manifiesto y un service worker, el navegador ofrece «Instalar» y la deja como icono en la pantalla de inicio, con ventana propia y, gracias al service worker, a veces sin conexión.

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
Pinterest 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

  1. Sirve tu web por HTTPS.
  2. Crea el manifiesto y enlázalo desde tus páginas.
  3. Añade un service worker para que funcione sin conexión.
  4. 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.

Service worker con la estrategia «primero la red». Con conexión, la página pide un fichero, el service worker deja pasar la petición a la red y siempre se ve lo último. Sin conexión, la petición a la red falla y el service worker responde a la página con la caché, que solo sirve lo que guardó antes.
El service worker, en magenta, está entre la página y la red. Arriba, con conexión, todo pasa a la red; abajo, cuando la red falla, responde a la página con lo que tiene en la caché. Es la estrategia del ejemplo de más abajo.

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 evento activate borra 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-v1 con /, /app.js, /manifest.webmanifest y /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 evento activate.
  • «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 con net::ERR_FAILED. Añade a ARCHIVOS lo 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_url está mal escrito o la web se sirve por http:// en un dominio que no es localhost.
  • «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:

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.