Saltar al contenido

Bajé la memoria de mi servidor Next.js de 1 GB a 0.29 GB

En la práctica/ 19 min de lectura

El optimizador de imágenes de Next.js tenía mi servidor de Railway cerca de 1 GB. Con images.unoptimized marcó 0.29 GB: cómo lo encontré, cómo lo medí y cuándo no conviene.

  • Next.js
  • Rendimiento
En este artículo (8)
  1. El síntoma: memoria cerca de 1 GB y una factura que no cuadraba
  2. Cómo encontré al culpable: el optimizador de imágenes de Next.js
  3. El cambio: images.unoptimized y por qué solo funciona con imágenes ya optimizadas
  4. Cómo lo medí (recorrido del sitemap y métricas de Railway)
  5. Cuándo NO hacer esto
  6. Errores comunes
  7. Preguntas frecuentes
  8. Checklist

Si tu servidor Next.js consume mucha memoria y todas tus imágenes salen de /public ya optimizadas, el culpable puede ser el optimizador de imágenes. En ecomlabs.dev, en Railway, el servicio web promediaba 0.99 GB aun con ajustes. Activé images.unoptimized: true y, tras recorrer las 276 páginas del sitemap, la memoria quedó en 0.29 GB.

Ya conté este arreglo como ejemplo en el artículo sobre Ponytail y el cambio mínimo que funciona. Aquí va la versión completa y medida: el síntoma, cómo encontré al culpable, la opción que cambié en next.config.ts, los dos scripts con los que medí y los casos en los que no deberías copiarlo.

El síntoma: memoria cerca de 1 GB y una factura que no cuadraba

ecomlabs.dev es una app de Next.js 15.5 que corre con next start en Railway, con una base de datos Postgres pequeña para el blog. Es un sitio de contenido: hace muy poco trabajo por petición. Aun así, la gráfica de memoria del servicio web nunca se quedaba quieta.

Hasta el 28 de septiembre de 2026 el servicio promediaba 1.25 GB. Después de cada deploy arrancaba en unos 0.5 GB y crecía hasta 1.5 o 2.2 GB antes del siguiente. Ese día hice un primer ajuste (lo detallo abajo) y el promedio bajó, pero poco: 0.99 GB en siete días, con el CPU casi en cero. La base de datos, mientras tanto, promediaba 54 MB.

La factura lo dejaba claro. Railway cobra la memoria a «$10 / GB / month ($0.000231 / GB / minute)», así que 0.99 GB son unos $10 USD al mes solo de memoria. En octubre, el uso del proyecto iba en $5.28 USD en lo que llevaba el periodo de facturación, y $5.12 de eso era memoria. Un sitio que casi no usaba CPU pagaba casi todo por RAM ocupada.

PeriodoConfiguración de imágenesMemoria del servicio webQué tipo de cifra es
Hasta el 28 sep 2026Optimizador con caché por defecto, AVIF y WebP1.25 GB; de 0.5 a 1.5–2.2 GB entre deploysPromedio en Railway
28 sep – 20 octCaché de 30 días, un hilo de libvips, MALLOC_ARENA_MAX=2, tope al heap0.99 GBPromedio de 7 días en Railway
Desde el 21 oct, 02:10 UTCimages.unoptimized: true0.29 GBLectura en vivo, justo después de recorrer las 276 páginas del sitemap

Fíjate en la última columna: 1.25 y 0.99 son promedios; 0.29 es una lectura puntual en la pestaña de métricas. No son el mismo tipo de cifra, y no las comparo como si lo fueran.

memoria del servicio web en Railway, en GB00.511.52 GBhasta 28 seppromedio1.25 GBajuste 28 seppromedio 7 días0.99 GBunoptimizeden vivo, 276 páginas0.29 GBentre deploys: de 0.5 a 1.5–2.2 GBajustes: 1.25 → 0.99 · sin optimizador: 0.29promedios de Railway; 0.29 GB es una lectura en vivo, no un promedio

Desliza la figura para verla completa

Cómo encontré al culpable: el optimizador de imágenes de Next.js

Memoria que crece con el CPU en cero no parece tráfico ni renderizado. Parece algo que reserva memoria nativa y no la suelta. En un servidor Next.js autoalojado, el primer sospechoso es el optimizador de next/image, que corre dentro del mismo proceso. La guía de self-hosting de Next.js 15 dice que «works self-hosted with zero configuration when deploying using next start» y que las imágenes se optimizan en tiempo de ejecución, no durante el build.

Así trabaja con cada imagen. El componente no apunta a tu archivo: apunta a /_next/image?url=...&w=...&q=..., una URL por cada candidato del srcset. Cuando llega esa petición, el servidor busca una copia vigente en .next/cache/images. Si no la hay, lee el original, lo redimensiona y lo recodifica con sharp (que usa libvips), guarda la copia y responde.

«Vigente» es la palabra clave. En Next.js 15 el valor por defecto es minimumCacheTTL: 60, // 1 minute, y la documentación define la caducidad de la imagen optimizada como «either the minimumCacheTTL or the upstream image Cache-Control header, whichever is larger». Los archivos de /public salen con Cache-Control: public, max-age=0. El mayor entre 60 y 0 es 60: cada variante caducaba al minuto y se volvía a codificar en la primera petición después de ese minuto. Ese fue mi diagnóstico de septiembre.

No era un caso raro. En Next.js 16 el valor por defecto pasó a 4 horas, y la guía para actualizar a la versión 16 lo justifica así: «This caused revalidation to happen every 60 seconds, which increased CPU usage and cost.»

La otra mitad es la memoria nativa. La guía de self-hosting avisa: «On glibc-based Linux systems, Image Optimization may require additional configuration to prevent excessive memory usage», y enlaza a la sección de sharp sobre el asignador de memoria de Linux. Ahí se lee que el asignador por defecto de glibc «is unsuitable for long-running, multi-threaded processes that involve lots of small memory allocations». Un servidor Next.js que procesa imágenes durante días es justo ese tipo de proceso.

El ajuste del 28 de septiembre atacó las dos mitades:

  • Un minimumCacheTTL de 30 días, para que cada variante se codificara una vez por deploy y no una vez por minuto.
  • experimental.imgOptConcurrency: 1, un solo hilo de libvips. El propio código de Next.js 15.5 lo comenta donde ajusta la concurrencia de sharp: «Reducing concurrency should reduce the memory usage too.»
  • MALLOC_ARENA_MAX=2 en el comando de arranque. El manual de glibc describe su equivalente, el tunable glibc.malloc.arena_max, que fija cuántas arenas de malloc usa un proceso «regardless of the number of cores in the system».
  • --max-old-space-size=384, un tope en MiB para el heap de V8 (documentación de Node.js).

El promedio bajó de 1.25 a 0.99 GB. Pero cada una de esas líneas era código para mantener vivo un componente que nunca había cuestionado. Así que conté lo que estaba optimizando. Todas las imágenes del sitio salen de /public: 47 archivos WebP, ninguno de más de 1440 píxeles de ancho, 2.2 MB en total, más seis PNG que sí se usaban. No había nada que el servidor tuviera que redimensionar.

la misma imagen, con optimizador y sin élcon optimizador (next/image por defecto)GET /_next/image?url=%2Fshot.webp&w=640&q=751 · ¿copia vigenteen caché?sí: la envía y listo2 · no: lee /publicsharp (libvips)reescala y recodifica3 · guarda la copia.next/cache/imagesy respondeNext 15: la copia caduca a los 60 s = max(minimumCacheTTL 60, max-age=0)images.unoptimized: trueGET /shot.webplee el archivo de /public y lo envía tal cual: sin sharp, sin srcsetel mismo WebP, sin trabajo en el servidorsolo vale si el archivo de /public ya tiene el tamaño y el formato finales

Desliza la figura para verla completa

El cambio: images.unoptimized y por qué solo funciona con imágenes ya optimizadas

El 20 de octubre, en el commit 0b18567, quité los ajustes y dejé una sola opción. Este es el bloque images de mi next.config.ts, tal cual está en el repositorio:

images: {
  // No runtime optimizer. Every image comes from /public and is already a
  // small WebP (≤1440 px, ~2 MB in total), so sharp only bought memory: even
  // with a 30-day cache and one libvips thread, its native allocations kept
  // the Railway container near 1 GB, which was nearly the whole bill.
  // Add new images to /public as WebP sized for their largest display.
  // shortcut: no srcset, so phones get the desktop-sized file; turn the
  // optimizer back on if /public gains large photos.
  unoptimized: true,
},
  1. unoptimized: true aplica a todas las imágenes del sitio. La documentación de next/image lo describe así: «The source image will be served as-is from the src instead of changing quality, size, or format.» Existe como opción de next.config.js desde Next.js 12.3.0.
  2. Los primeros comentarios dicen por qué: todo viene de /public y ya son WebP pequeños, así que sharp solo compraba memoria, incluso con la caché de 30 días y un solo hilo.
  3. La regla para el futuro: las imágenes nuevas entran a /public como WebP, del tamaño de su visualización más grande.
  4. La línea shortcut: deja escrito el precio (sin srcset, un celular descarga el mismo archivo que una computadora) y cuándo volver atrás: si /public recibe fotos grandes.

El mismo diff borró formats: ["image/avif", "image/webp"], el minimumCacheTTL de 30 días y experimental.imgOptConcurrency: sin optimizador no queda nada que configurar. Lo que no cambió es el comando de arranque de railway.json, que todavía pone MALLOC_ARENA_MAX=2 y --max-old-space-size=384 desde septiembre (más --expose-gc, que agregué una semana después para otra parte del sitio). La lectura de 0.29 GB se tomó con esas dos opciones de septiembre puestas.

Revisé en el código de Next.js 15.5 qué hace el componente con la opción activa: devuelve el src sin tocarlo y deja srcSet y sizes vacíos. El <img> conserva su width y su height, pero apunta directo a /shot.webp, sin pasar por /_next/image.

Esto solo funciona porque las imágenes ya estaban optimizadas. Los 47 WebP ya tenían su tamaño final. Los seis PNG los convertí a WebP una sola vez, en mi laptop, con el sharp que el proyecto ya tenía instalado. El logo era un PNG de 6345 píxeles de ancho y 164 KB que se dibuja a 30 píxeles de alto; como WebP de 96 píxeles de alto pesa 10 KB. El ícono de la app pasó de 281 KB a 6 KB, y las cuatro capturas de unos 180 KB cada una a unos 40 KB. Hacer ese trabajo una vez, antes del deploy, es lo que permite apagar el optimizador sin que la página pese más. Si tus originales son fotos de 3 MB, unoptimized las manda de 3 MB, y tu LCP lo va a notar: lo explico en cómo hacer que la imagen principal cargue primero.

Cómo lo medí (recorrido del sitemap y métricas de Railway)

Medí en dos lugares, y cada medición dice algo distinto.

En local, compilé el sitio, lo arranqué en modo producción y recorrí las 274 páginas de su sitemap. El proceso del servidor quedó en 173 MB en reposo y 197 MB después del recorrido, frente a un pico de 344 MB en la misma prueba con el optimizador ajustado. Esa prueba no reproduce el problema: corre en mi computadora, no en el Linux con glibc de Railway. Sirve para comparar dos configuraciones en las mismas condiciones, no para predecir producción.

En producción, el cambio salió el 21 de octubre de 2026 a las 02:10 UTC. Justo después recorrí las 276 páginas que el sitemap listaba entonces, y la memoria del servicio en Railway marcaba 0.29 GB. Esa cifra se lee en la pestaña Metrics del servicio. Según la documentación de métricas de Railway, se llega «by clicking on a service in the project canvas, and going to the "Metrics" tab», y hay «Up to 30 days of data» por proyecto. Si tienes réplicas, la vista Sum las combina y la vista Replica las separa.

Para repetir la prueba en tu app escribí crawl-sitemap.mjs, sin dependencias. Pide el sitemap, recorre cada <loc> y, con --images, también cada imagen de cada página, que es lo que de verdad pone a trabajar al optimizador:

// Requests every <loc> in a sitemap, on the sitemap's own host, and prints a summary.
// usage: node crawl-sitemap.mjs <sitemap-url> [--concurrency 1-4] [--images]
import { pathToFileURL } from "node:url";

const decode = (s) => s.replaceAll("&amp;", "&");

export function pageUrls(xml, sitemapUrl) {
  const host = new URL(sitemapUrl);
  // A local build's sitemap still lists the production domain: keep the path, swap the host.
  return [...xml.matchAll(/<loc>\s*([^<]+?)\s*<\/loc>/g)].map((m) => {
    const u = new URL(decode(m[1]), host);
    return new URL(u.pathname + u.search, host.origin).href;
  });
}

export function imageUrls(html, pageUrl) {
  const found = [];
  for (const [tag] of html.matchAll(/<img\b[^>]*>/gi)) {
    for (const [, name, value] of tag.matchAll(/\s(src|srcset)="([^"]*)"/gi)) {
      const list = name.toLowerCase() === "srcset" ? value.split(",").map((c) => c.trim().split(/\s+/)[0]) : [value];
      for (const v of list) if (v && !v.startsWith("data:")) found.push(new URL(decode(v), pageUrl).href);
    }
  }
  // Same host only: the crawl measures your server, never someone else's CDN.
  return found.filter((u) => new URL(u).origin === new URL(pageUrl).origin);
}

export async function crawl(sitemapUrl, { concurrency = 1, images = false, log = () => {} } = {}) {
  const started = performance.now();
  const res = await fetch(sitemapUrl);
  if (!res.ok) throw new Error(`sitemap: HTTP ${res.status}`);
  const pages = pageUrls(await res.text(), sitemapUrl);
  if (pages.length === 0) throw new Error("no <loc> found (a sitemap index is not supported)");

  const statuses = {};
  const seen = new Set();
  let bytes = 0;
  const get = async (url) => {
    try {
      const r = await fetch(url, { signal: AbortSignal.timeout(30_000) });
      const body = Buffer.from(await r.arrayBuffer());
      bytes += body.length;
      statuses[r.status] = (statuses[r.status] ?? 0) + 1;
      if (r.status >= 400) log(`${r.status} ${url}`);
      return { r, body };
    } catch (err) {
      statuses.error = (statuses.error ?? 0) + 1;
      log(`error ${url}: ${err.message}`);
      return null;
    }
  };

  let next = 0;
  const worker = async () => {
    while (next < pages.length) {
      const url = pages[next++];
      const got = await get(url);
      if (!images || !got?.r.headers.get("content-type")?.includes("text/html")) continue;
      for (const img of imageUrls(got.body.toString("utf8"), url)) {
        if (seen.has(img)) continue;
        seen.add(img);
        await get(img);
      }
    }
  };
  await Promise.all(Array.from({ length: Math.min(concurrency, pages.length) }, worker));
  return { pages: pages.length, images: seen.size, statuses, bytes, ms: Math.round(performance.now() - started) };
}

if (import.meta.url === pathToFileURL(process.argv[1]).href) {
  const args = process.argv.slice(2);
  const url = args.find((a) => /^https?:\/\//.test(a));
  const i = args.indexOf("--concurrency");
  const concurrency = Math.min(4, Math.max(1, Number(i >= 0 ? args[i + 1] : 1) || 1));
  if (!url) {
    console.error("usage: node crawl-sitemap.mjs <sitemap-url> [--concurrency 1-4] [--images]");
    process.exit(2);
  }
  const s = await crawl(url, { concurrency, images: args.includes("--images"), log: console.log });
  const codes = Object.entries(s.statuses).map(([code, n]) => `${code} x ${n}`).join(", ");
  console.log(`pages:     ${s.pages}`);
  console.log(`images:    ${s.images}`);
  console.log(`responses: ${codes}`);
  console.log(`received:  ${(s.bytes / 1024 / 1024).toFixed(1)} MB`);
  console.log(`time:      ${(s.ms / 1000).toFixed(1)} s (concurrency ${concurrency})`);
  process.exitCode = Object.keys(s.statuses).some((c) => c === "error" || Number(c) >= 400) ? 1 : 0;
}
  1. pageUrls saca cada <loc> y le pone el host del sitemap. Hace falta: el sitemap de un build local lista el dominio de producción (el mío arma cada URL con https://ecomlabs.dev), y sin ese cambio el recorrido «local» iría a producción.
  2. imageUrls lee el src y cada candidato del srcset de cada <img>, descarta los data: y se queda solo con las del mismo host, para no medir el CDN de nadie más.
  3. get descarga cada respuesta completa, cuenta los códigos de estado y anota los errores sin detener el recorrido. Cada petición tiene un límite de 30 segundos.
  4. Los worker toman URLs de una lista compartida. --concurrency (de 1 a 4) decide cuántas peticiones van a la vez; por defecto es 1, una tras otra.
  5. seen hace que cada imagen se pida una sola vez en todo el recorrido.
  6. Al final imprime páginas, imágenes, códigos, megabytes y tiempo, y sale con código 1 si hubo un error o una respuesta 4xx o 5xx.

Lo probé contra un servidor falso hecho con node:http (test-server.mjs): un sitemap de 13 URLs con el dominio example.com, 12 páginas con imágenes y una que responde 404. Nunca contra el sitio en producción. Esta es la salida real de node crawl-sitemap.mjs http://localhost:4321/sitemap.xml --concurrency 2 --images:

404 http://localhost:4321/gone
pages:     13
images:    10
responses: 200 x 22, 404 x 1
received:  0.4 MB
time:      0.1 s (concurrency 2)
  1. La primera línea es el 404 de /gone, que puse a propósito. Aunque el sitemap decía example.com, todas las peticiones fueron a localhost:4321.
  2. 13 páginas y 10 imágenes únicas: el logo, tres capturas y los dos anchos del srcset de cada captura. La imagen remota y la data: se ignoraron.
  3. 22 respuestas 200 (12 páginas y 10 imágenes) y un 404. Por ese 404 el script salió con código 1.

Mis cinco pruebas con node --test pasaron: el cambio de host, la lectura del srcset, los conteos con concurrencia 1 y 3, y el error con un sitemap sin <loc>.

Mientras corre el recorrido, mide la memoria del proceso del servidor. sample-rss.mjs la imprime cada N segundos:

// Prints a process's resident memory every N seconds until it exits (or Ctrl+C).
// usage: node sample-rss.mjs <pid> [seconds=2]
import { execFileSync } from "node:child_process";

const [pid, every = "2"] = process.argv.slice(2);
if (!/^\d+$/.test(pid ?? "")) {
  console.error("usage: node sample-rss.mjs <pid> [seconds]");
  process.exit(2);
}

const quiet = { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] };

function residentBytes() {
  if (process.platform === "win32") {
    // Windows has no ps -o rss; the working set is the closest number.
    const out = execFileSync("powershell", ["-NoProfile", "-Command", `(Get-Process -Id ${pid}).WorkingSet64`], quiet);
    return Number(out.trim());
  }
  return Number(execFileSync("ps", ["-o", "rss=", "-p", pid], quiet).trim()) * 1024; // ps prints KiB
}

const mb = (b) => (b / 1024 / 1024).toFixed(0);
let peak = 0;
const tick = () => {
  let bytes = 0;
  try {
    bytes = residentBytes();
  } catch {}
  if (!bytes) {
    console.log(`pid ${pid} is gone, peak ${mb(peak)} MB`);
    process.exit(0);
  }
  peak = Math.max(peak, bytes);
  console.log(`${new Date().toISOString().slice(11, 19)}  ${mb(bytes)} MB  (peak ${mb(peak)} MB)`);
};
tick();
setInterval(tick, Number(every) * 1000);
  1. Recibe el PID del servidor y el intervalo en segundos (2 por defecto).
  2. En Linux y macOS llama a ps -o rss= -p <pid>, que imprime la memoria residente en KiB.
  3. En Windows no hay un ps con -o rss, así que le pide a PowerShell el WorkingSet64 del proceso, en bytes, que es la cifra más cercana.
  4. Guarda el pico y, cuando el proceso termina, lo imprime y sale.

Contra mi servidor de prueba imprimió 61 y 62 MB durante el recorrido, con muestras no del todo regulares porque en Windows cada lectura abre un PowerShell. Si no quieres el script, en PowerShell basta con este bucle (el PID es el que imprimió mi servidor de prueba):

$id = 95172
1..3 | ForEach-Object { "{0:N0} MB" -f ((Get-Process -Id $id).WorkingSet64 / 1MB); Start-Sleep 2 }
  1. $id es el PID del proceso que quieres medir.
  2. WorkingSet64 viene en bytes; al dividir entre 1MB queda en megabytes, y {0:N0} lo redondea.
  3. Son tres lecturas, una cada 2 segundos. Mi servidor de prueba marcó 62, 62 y 61 MB.

En Linux o macOS, lo mismo es un bucle con ps -o rss= -p <pid> y sleep 2. El working set de Windows y el RSS de Linux no son idénticos, así que compara siempre en la misma máquina. Y la cifra que manda en producción es la de la pestaña Metrics de Railway: haz el recorrido en producción y mira la gráfica de memoria en ese momento y durante la semana siguiente.

Cuándo NO hacer esto

images.unoptimized cambia trabajo del servidor por trabajo tuyo antes del deploy. Aplica a Next.js autoalojado con next start (Railway, un VPS, Docker), donde el optimizador corre dentro de tu proceso. Antes de copiarlo, ubica tu caso:

Tu caso¿unoptimized?Por qué
Todas las imágenes en /public, ya en WebP o AVIF y del tamaño finalSíNo queda nada que optimizar en el servidor
Fotos grandes en /public, como originales de cámaraNo, o conviértelas antesSe servirían tal cual, con todo su peso
Imágenes remotas de un CMS o de un bucketNo, salvo que ya lleguen del tamaño finalSe sirven desde el src original, sin cambiar tamaño ni formato
Imágenes que suben tus usuariosNoNo controlas su tamaño ni su formato
Fotos grandes que necesitan srcset en celularNo, o escribe el srcset a manoSin optimizador no se genera srcset
Ya tienes un servicio externo que optimiza imágenesMejor un loaderLa guía de self-hosting propone «configure an image loader»
La memoria crece igual al recorrer sin --imagesTodavía noEl optimizador solo trabaja cuando se piden imágenes: busca la causa en otro lado

La última fila es la prueba más barata: recorre tu sitemap primero sin --images y luego con --images, mirando la memoria. Si solo sube en el segundo recorrido, el optimizador es tu sospechoso. Si sube en los dos, el problema está en otra parte y apagar el optimizador no lo va a arreglar.

lo que cuesta la memoria en Railway$0.000231 / GB / min × 43 200 min = $9.98 por GB en 30 díasperiodomemoriacálculo, 30 díasmemoria / mesajuste 28 sep0.99 GB prom.0.99 × $9.98$9.88unoptimized0.29 GB0.29 × $9.98$2.89la facturaoctubre, antes del cambio: $5.28 en el periodo, $5.12 de memoriadespués: unos $3–3.5 al mes en totalla memoria era casi toda la facturatarifa de Railway: $10 / GB / mes ($0.000231 / GB / min)

Desliza la figura para verla completa

Errores comunes

  • Apagar el optimizador con originales pesados en /public. El servidor baja de memoria y la página sube de peso. Convierte antes, una vez, y luego apágalo.
  • Recorrer solo el HTML. Pedir una página no descarga sus imágenes; eso lo hace el navegador. Si tu recorrido nunca pide /_next/image, no está midiendo el optimizador. Para eso es --images.
  • Recorrer producción sin querer. El sitemap de un build local lista tu dominio real. Si tu script usa cada <loc> tal cual, tu prueba «local» carga producción.
  • Dar por buena la cifra local. Mis 197 MB locales no son una cifra de Railway: mi computadora no reproduce el asignador de glibc. La cifra que cuenta es la de producción.
  • Comparar un promedio con una lectura puntual. 0.99 GB es un promedio de siete días; 0.29 GB, una lectura justo después del recorrido. Para cerrar la comparación, mira el promedio de la semana siguiente.
  • Olvidar que la regla ahora es para personas. Un PNG de 2 MB que alguien agregue el mes que viene se va a servir de 2 MB. Revisa el peso de cada imagen nueva al revisar el cambio.

Preguntas frecuentes

¿Con images.unoptimized dejo de usar next/image?

No. Sigues usando el componente; solo cambia a qué URL apunta. La guía de self-hosting de Next.js 15 dice que puedes «disable Image Optimization and still retain other benefits of using next/image», por ejemplo si optimizas tus imágenes por separado, que es lo que hice.

¿Puedo desactivarlo solo en algunas imágenes?

Sí, con la prop unoptimized en cada Image. La documentación la recomienda para imágenes que no ganan nada con la optimización: «small images (less than 1KB), vector images (SVG), or animated images (GIF)». En mi sitio ninguna imagen ganaba algo, así que la puse global en next.config.ts.

¿Next.js 16 lo resuelve con su nuevo minimumCacheTTL?

Resuelve el recodificado de cada minuto: el valor por defecto pasó de 60 segundos a 4 horas. No sé si basta para la memoria nativa de sharp en glibc, porque no lo probé: mi sitio sigue en Next.js 15.5. Si te quedas con el optimizador en Next.js 15, sube minimumCacheTTL tú mismo.

¿Cómo vuelvo atrás si algo sale mal?

Quita unoptimized: true de next.config.ts, o revierte el commit, y vuelve a desplegar. En Next.js 15.5, sharp viene como dependencia opcional de next, así que no hay que instalar nada. Si regresas al optimizador en Next.js 15, vuelve a poner un minimumCacheTTL largo; si no, regresas al recodificado de cada minuto.

Checklist

  • Leíste la memoria del servicio en la pestaña Metrics de Railway durante al menos una semana.
  • Todas tus imágenes salen de /public: no hay imágenes remotas ni subidas por usuarios.
  • Cada imagen ya está en WebP o AVIF y del tamaño de su visualización más grande.
  • Aceptas no tener srcset, o lo escribes a mano para las imágenes grandes.
  • Recorriste el sitemap sin y con --images, midiendo la memoria del proceso.
  • Pusiste images: { unoptimized: true } y quitaste la configuración que solo servía al optimizador.
  • Después del deploy recorriste producción y leíste la memoria en Metrics.
  • Una semana después comparaste promedio con promedio.
  • Dejaste escrito, en un comentario, cuándo volver a activar el optimizador.

Este arreglo salió de una sola pregunta: ¿tiene que existir este componente? La cuento con más contexto en Ponytail: cómo enseñarle a un agente de IA a escribir menos código. Y antes de convertir tus imágenes a mano, revisa el artículo sobre la imagen principal que retrasa el LCP, donde explico el tamaño, el formato y el srcset. Y si revisas el servidor, revisa también su runtime: cómo actualizar Node en Docker.

¿Viste esto en Instagram? Comenta RAM en el Reel y te mando la guía.

Escrito por

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 2 de noviembre de 2026 · actualizado el 3 de noviembre de 2026

← Blog