Saltar al contenido

Alertas para tu tienda en línea en el Buen Fin: avisos si el checkout deja de vender

En la práctica/ 17 min de lectura

Un script en Node que cada 10 minutos compara pedidos con la semana pasada, cuenta pagos fallidos y checkouts abandonados, prueba el checkout y avisa por Slack.

  • Shopify
  • Analítica
  • Node.js
  • Admin API
En este artículo (9)
  1. Por qué te enteras tarde en el Buen Fin
  2. Alerta 1: pedidos por hora contra la misma hora de la semana pasada
  3. Alerta 2: errores de pago
  4. Alerta 3: checkout caído
  5. Enviar el aviso por correo o Slack
  6. Probar las alertas
  7. Errores comunes
  8. Preguntas frecuentes
  9. Checklist

Para enterarte a tiempo de que tu checkout dejó de vender durante el Buen Fin, programa un script que cada 10 minutos revise tres alertas: pedidos de la última hora contra la misma hora de la semana pasada, errores de pago y una prueba del checkout. Si algo falla, te avisa por Slack y por correo.

El Buen Fin 2026 va del viernes 13 al martes 17 de noviembre, según las Reglas de Operación de El Buen Fin 2026 de la Secretaría de Economía. Aquí está el script completo en Node, sin dependencias, con las consultas validadas contra la versión 2026-10 de las APIs de Shopify y probado con respuestas simuladas. Complementa el smoke test del checkout y la fecha de congelamiento: aquel revisa antes de la fecha que se pueda comprar; este vigila durante la fecha que se siga vendiendo.

Por qué te enteras tarde en el Buen Fin

Shopify no te avisa cuando las ventas se caen. Analytics muestra la caída a quien lo abre, y en el Buen Fin el equipo está contestando mensajes y surtiendo pedidos. Lo normal es enterarse por un cliente que escribe «no me deja pagar», o al día siguiente. La causa suele ser un cambio pequeño: una app que se actualiza, un ajuste del tema, una regla de descuento, un proveedor de pagos con problemas.

No necesitas adivinar cuál. Basta con vigilar tres señales que puedes leer con las APIs de Shopify; cada una atrapa una falla distinta:

  • Pedidos por hora. Atrapa cualquier falla que termine en menos ventas, pero necesita volumen y llega tarde, porque mide una hora completa.
  • Errores de pago. Las transacciones fallidas y la proporción de checkouts abandonados apuntan al paso del pago.
  • Checkout caído. Una prueba sintética que no depende del volumen y avisa también de madrugada.

Un tablero necesita a alguien mirándolo. Este script corre solo, compara contra la historia de tu tienda y te escribe cuando algo se sale de lo normal. No instala apps ni toca tu tema.

Alerta 1: pedidos por hora contra la misma hora de la semana pasada

Las ventas tienen un ritmo diario, así que la comparación justa es con la misma hora del mismo día de la semana pasada: el viernes 13 a la 1 de la tarde contra el viernes 6 a la misma hora. En el Buen Fin deberías vender más que en una semana normal; caer por debajo de la mitad es una señal clara de que algo se rompió.

Acceso a la Admin API

El script necesita un token con el permiso read_orders. Según el changelog de Shopify, desde el 1 de enero de 2026 ya no se pueden crear apps personalizadas en el admin: se crean en el Dev Dashboard. Para una app así, el script pide el token con el client credentials grant, que da un token de 24 horas y solo funciona si la app y la tienda son de la misma organización.

const postJson = (url, payload, headers = {}) =>
  fetch(url, { method: "POST", headers: { "Content-Type": "application/json", ...headers }, body: JSON.stringify(payload) });

async function getToken() {
  if (SHOPIFY_ADMIN_TOKEN) return SHOPIFY_ADMIN_TOKEN;
  const res = await fetch(`https://${SHOP}/admin/oauth/access_token`, {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams({
      grant_type: "client_credentials",
      client_id: SHOPIFY_CLIENT_ID,
      client_secret: SHOPIFY_CLIENT_SECRET,
    }),
  });
  if (!res.ok) throw new Error(`token request: HTTP ${res.status}`);
  return (await res.json()).access_token;
}

async function admin(token, query, variables) {
  const url = `https://${SHOP}/admin/api/${API_VERSION}/graphql.json`;
  const res = await postJson(url, { query, variables }, { "X-Shopify-Access-Token": token });
  const body = await res.json().catch(() => ({}));
  if (!res.ok || body.errors) throw new Error(`HTTP ${res.status} ${JSON.stringify(body.errors ?? "")}`);
  return body.data;
}
  1. postJson manda un POST con un cuerpo JSON. Lo usan la Admin API, la prueba del checkout y el aviso a Slack.
  2. Si tienes el token de una app personalizada creada antes de 2026, ponlo en SHOPIFY_ADMIN_TOKEN y getToken lo usa tal cual.
  3. Si no, pide uno a /admin/oauth/access_token con grant_type=client_credentials, client_id y client_secret, en application/x-www-form-urlencoded. Dura 86399 segundos y el script pide uno nuevo en cada ejecución.
  4. admin usa la versión 2026-10, la última estable según la página de versiones de Shopify: salió el 1 de octubre de 2026 y funciona hasta el 16 de octubre de 2027.
  5. Lanza un error si el HTTP falla o si la respuesta trae errors: la referencia de la Admin API explica que GraphQL puede responder 200 OK en casos que en REST serían errores, como THROTTLED.

La consulta

Una sola petición trae los cuatro números de las alertas 1 y 2:

const COUNTS = `query Counts($now: String!, $lastWeek: String!) {
  ordersNow: ordersCount(query: $now) { count }
  ordersLastWeek: ordersCount(query: $lastWeek) { count }
  abandonedNow: abandonedCheckoutsCount(query: $now) { count }
  abandonedLastWeek: abandonedCheckoutsCount(query: $lastWeek) { count }
}`;

const between = (end) =>
  `created_at:>='${new Date(end - HOUR).toISOString()}' created_at:<'${new Date(end).toISOString()}'`;
  1. Counts pide cuatro conteos con alias: pedidos y checkouts abandonados, en la ventana actual y en la de hace una semana.
  2. ordersCount y abandonedCheckoutsCount devuelven un Count y aceptan el filtro created_at. Cuentan hasta 10.000 por defecto.
  3. between arma el filtro con la sintaxis de búsqueda de Shopify: fechas entre comillas, como pide la documentación, y un espacio entre términos, que equivale a AND.

La ventana dura una hora y termina 15 minutos antes de la ejecución: a las 13:00 mira de 11:45 a 12:45, y en la semana pasada, el mismo tramo. Ese retraso lo necesita la alerta 2, y las dos comparten ventana para que sus números cuadren.

La regla

const DROP_RATIO = 0.5; // alert 1: fewer than half of last week's orders...
const MIN_BASELINE = 10; // ...when last week had at least 10 in that hour

// Alert 1: orders in the hour vs the same hour last week.
function ordersAlert({ ordersNow, ordersLastWeek }) {
  if (ordersLastWeek.count >= MIN_BASELINE && ordersNow.count < ordersLastWeek.count * DROP_RATIO) {
    return `Orders: ${ordersNow.count} in the hour vs ${ordersLastWeek.count} same hour last week`;
  }
}
  1. Avisa si hay menos de la mitad de pedidos que la semana pasada (DROP_RATIO), solo si esa hora tuvo al menos 10 (MIN_BASELINE).
  2. El mínimo evita el ruido de la madrugada: de 2 a 0 pedidos no significa nada, y una alerta que suena por nada acaba silenciada.
  3. Devuelve el texto del aviso, o undefined si todo está bien.

Los dos números son un ejemplo ilustrativo: busca en tus reportes la peor hora normal de las últimas semanas y ajústalos. Si vendes poco por hora, usa 3 * HOUR en between para una ventana de tres horas.

pedidos por hora: hoy contra la misma hora de la semana pasadahoy (Buen Fin)semana pasadaumbral: 50 % de la semana pasada0204010:0011:0012:0013:0014:0015:0016:0017:00alerta: 6 pedidos < 11una caída contra la semana pasada dispara la alertaejemplo ilustrativo: datos inventados, umbral = 50 % de la misma hora

Desliza la figura para verla completa

Alerta 2: errores de pago

Aquí hay que ser preciso. El Centro de ayuda de Shopify dice que un pago que falla en el checkout normalmente no crea un pedido: queda registrado como checkout abandonado, con el intento en su línea de tiempo, y solo cuenta como abandonado después de más de 10 minutos incompleto. La Admin API define un checkout abandonado como uno donde el cliente dejó su contacto y no compró, y ese objeto no tiene campos de pago.

Qué pasó¿Se ve en la Admin API?Dónde
Se creó un pedidoSíordersCount, orders
Una transacción de un pedido falló o dio errorSí, con un código de error estándarOrderTransaction.status en FAILURE o ERROR, y errorCode
El banco rechazó la tarjeta y no hubo pedidoSolo como checkout abandonado, sin el motivo, y si el cliente dejó su contactoabandonedCheckoutsCount; el motivo, en la línea de tiempo del checkout en el admin
El checkout no cargaNoSolo con una prueba sintética (alerta 3)

Por eso la alerta 2 mira dos cosas: las transacciones fallidas de los pedidos recientes y la proporción de checkouts abandonados.

const MAX_FAILED = 3; // alert 2: failed or errored transactions in the hour
const ABANDON_JUMP = 0.2; // alert 2: abandoned share up 20 points vs last week

const RECENT_ORDERS = `query RecentOrders($q: String!) {
  orders(first: 50, query: $q, sortKey: CREATED_AT, reverse: true) {
    nodes { name transactions(first: 5) { status kind gateway errorCode } }
  }
}`;

// Alert 2: failed transactions on recent orders, and abandoned checkouts (where declines land).
async function paymentAlerts(token, q, c) {
  const alerts = [];
  // shortcut: reads the latest 50 orders of the hour; page with `after` if you sell more per hour.
  const { orders } = await admin(token, RECENT_ORDERS, { q });
  const failed = orders.nodes.flatMap((o) =>
    o.transactions
      .filter((t) => t.status === "FAILURE" || t.status === "ERROR")
      .map((t) => `${o.name} ${t.kind} ${t.gateway} ${t.errorCode ?? t.status}`),
  );
  if (failed.length >= MAX_FAILED) alerts.push(`Payments: ${failed.length} failed (${failed.slice(0, 3).join("; ")})`);
  const share = (abandoned, orders) => (abandoned + orders ? abandoned / (abandoned + orders) : 0);
  const now = share(c.abandonedNow.count, c.ordersNow.count);
  const before = share(c.abandonedLastWeek.count, c.ordersLastWeek.count);
  if (c.abandonedNow.count >= MIN_BASELINE && now - before > ABANDON_JUMP) {
    alerts.push(`Abandoned checkouts: ${Math.round(now * 100)}% vs ${Math.round(before * 100)}% last week`);
  }
  return alerts;
}
  1. RecentOrders usa la consulta orders para leer los 50 pedidos más recientes de la ventana, con hasta 5 transacciones cada uno. Es un atajo: si vendes más de 50 por hora, pagina con after.
  2. failed se queda con las transacciones en FAILURE o ERROR, estados de OrderTransaction, con su errorCode estándar: CARD_DECLINED, PAYMENT_PROVIDER_ERROR, CONFIG_ERROR y otros. Con 3 o más en la hora, avisa.
  3. share es abandonados entre abandonados más pedidos: una aproximación, calculada igual para las dos semanas. Si hay al menos 10 abandonados y sube más de 20 puntos, avisa; en nuestra prueba, 67 % contra 25 %.

Se comparan proporciones porque en el Buen Fin, con más visitas, habrá más abandonos aunque todo funcione. Si la proporción salta, abre en el admin la línea de tiempo de algunos de esos checkouts para leer el mensaje del banco. Y por eso la ventana termina 15 minutos antes: un checkout de hace 5 minutos todavía no cuenta como abandonado.

Alerta 3: checkout caído

Las dos primeras alertas necesitan clientes; esta no. Es una prueba sintética que crea un carrito y abre su checkout con la Storefront API sin token: según la documentación de la Storefront API, ese acceso permite leer y escribir carritos.

const PROBE = `mutation Probe($variantId: ID!) {
  cartCreate(input: { lines: [{ merchandiseId: $variantId, quantity: 1 }] }) {
    cart { checkoutUrl totalQuantity }
    userErrors { message }
  }
}`;

// Alert 3: a synthetic check. Creates a cart (never an order) and loads its checkout URL.
async function probeCheckout() {
  const variables = { variantId: PROBE_VARIANT_ID };
  const res = await postJson(`https://${SHOP}/api/${API_VERSION}/graphql.json`, { query: PROBE, variables });
  const body = await res.json().catch(() => ({}));
  const cart = body.data?.cartCreate?.cart;
  if (!res.ok || !cart?.totalQuantity) {
    return `cartCreate: HTTP ${res.status} ${JSON.stringify(body.errors ?? body.data?.cartCreate?.userErrors ?? "")}`;
  }
  const page = await fetch(cart.checkoutUrl);
  if (!page.ok) return `checkout page: HTTP ${page.status}`;
}

async function checkoutAlert(sleep) {
  const first = await probeCheckout().catch((err) => err.message);
  if (!first) return;
  await sleep(30_000); // one retry, so a single blip does not page anyone
  const second = await probeCheckout().catch((err) => err.message);
  if (second) return `Checkout probe failed twice: ${second}`;
}
  1. cartCreate agrega una unidad de PROBE_VARIANT_ID y devuelve checkoutUrl y totalQuantity. Un carrito vacío cuenta como falla: la variante se agotó o ya no existe.
  2. Luego carga checkoutUrl con fetch, que sigue las redirecciones, y falla si la respuesta final no es 2xx.
  3. checkoutAlert reintenta a los 30 segundos y solo avisa si fallan los dos intentos. Cada error, incluso de red, se vuelve texto y no tumba el script.

Detecta una Storefront API caída o con errores, una variante que ya no entra al carrito y una página de checkout con error HTTP o sin respuesta. No detecta:

  • Tarjetas rechazadas ni un proveedor de pagos caído: la prueba nunca paga. Eso lo vigila la alerta 2.
  • Un botón de pago roto o una extensión que bloquea el paso: fetch no ejecuta la página.
  • Fallas del tema antes del carrito, que cubre el smoke test con Playwright en un navegador real.
  • Problemas de un solo país, código de descuento o dirección.
  • Una respuesta 200 que no es el checkout, como una redirección a otra página: pasa como buena.

Usa una variante que no se vaya a agotar en el Buen Fin. Cada ejecución crea un carrito real, nunca un pedido.

Enviar el aviso por correo o Slack

El script usa dos canales sin dependencias. Slack, con un webhook entrante: un POST con un JSON que lleva text, al que Slack responde 200 y ok. Y correo a través de GitHub: si hay alertas, el script sale con código 1, la ejecución falla y GitHub te notifica.

export async function runChecks({ now = Date.now(), sleep = (ms) => new Promise((r) => setTimeout(r, ms)) } = {}) {
  const alerts = [];
  const end = now - 15 * MINUTE; // a checkout counts as abandoned after 10+ minutes
  try {
    const token = await getToken();
    const counts = await admin(token, COUNTS, { now: between(end), lastWeek: between(end - WEEK) });
    alerts.push(ordersAlert(counts), ...(await paymentAlerts(token, between(end), counts)));
  } catch (err) {
    alerts.push(`Monitor could not read the Admin API: ${err.message}`);
  }
  alerts.push(await checkoutAlert(sleep));
  return alerts.filter(Boolean);
}

export async function main() {
  const alerts = await runChecks();
  if (!alerts.length) return console.log("ok");
  const text = `Checkout alert for ${SHOP}\n- ${alerts.join("\n- ")}`;
  console.log(text);
  const res = SLACK_WEBHOOK_URL && (await postJson(SLACK_WEBHOOK_URL, { text }));
  if (res && !res.ok) console.error(`Slack: HTTP ${res.status} ${await res.text()}`);
  process.exitCode = 1; // a failed run also emails you through GitHub Actions
}

if (process.argv[1] === fileURLToPath(import.meta.url)) await main();
  1. runChecks corre las alertas 1 y 2 dentro de un try: si el token o la Admin API fallan, eso mismo es una alerta, porque un monitor roto debe avisar en vez de callarse.
  2. La prueba del checkout corre fuera del try, así que se ejecuta aunque la Admin API falle.
  3. main imprime ok si no hay alertas. Si hay, imprime un solo mensaje con todas, lo manda a Slack si existe SLACK_WEBHOOK_URL (un error de Slack solo queda en el registro) y deja process.exitCode = 1. La última línea solo ejecuta main desde la terminal, no cuando las pruebas importan el archivo.

Programarlo cada 10 minutos con GitHub Actions

# .github/workflows/checkout-monitor.yml
name: Checkout monitor
on:
  schedule:
    - cron: "5,15,25,35,45,55 * * * *"
  workflow_dispatch:
jobs:
  monitor:
    runs-on: ubuntu-latest
    timeout-minutes: 5
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-node@v7
        with:
          node-version: 22
      - run: node monitor.mjs
        env:
          SHOP: ${{ secrets.SHOP }}
          SHOPIFY_CLIENT_ID: ${{ secrets.SHOPIFY_CLIENT_ID }}
          SHOPIFY_CLIENT_SECRET: ${{ secrets.SHOPIFY_CLIENT_SECRET }}
          PROBE_VARIANT_ID: ${{ secrets.PROBE_VARIANT_ID }}
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
  1. 5,15,25,35,45,55 * * * * corre seis veces por hora, en UTC, y evita el minuto 0: según la documentación de schedule, los workflows programados pueden retrasarse con alta carga, que incluye el inicio de cada hora, y algunos trabajos en cola se pueden descartar. El mínimo es cada 5 minutos.
  2. workflow_dispatch agrega el botón para correrlo a mano.
  3. Los valores van en secretos del repositorio: Slack advierte que la URL del webhook es un secreto.

Para el correo, activa las notificaciones de Actions: según la documentación de notificaciones, las de un workflow programado le llegan a quien lo creó o a quien cambió el cron después, y puedes pedir solo las de ejecuciones fallidas. El workflow solo corre en la rama por defecto, se desactiva en repositorios públicos tras 60 días sin actividad y, en uno privado, consume el uso de Actions de tu plan: puedes activarlo solo la semana del Buen Fin.

el script programado: cada 10 minutos, tres revisiones y un avisoGitHub Actionsschedule5,15,…,55 * * * *monitor.mjsnode monitor.mjsventana de 1 h1 · pedidos/horaAdmin · ordersCount2 · errores de pagotransactions · abandoned3 · checkout caídoStorefront · cartCreatesi hay alertasPOST a Slack · exit 1 → correo de GitHubsin alertasimprime «ok» · run en verdeun fallo de la Admin API también avisala prueba del checkout corre aunque falle la Admin API; reintenta una vez a los 30 s

Desliza la figura para verla completa

Probar las alertas

Probamos el script en local con el ejecutor de pruebas de Node y fetch simulado: ninguna llamada salió a Shopify, a Slack ni a un servicio de correo. Una de las pruebas:

const NOW = Date.parse("2026-11-13T19:00:00Z"); // Buen Fin, Friday 13:00 in Mexico City
const noSleep = async () => {};

test("alert 1: orders drop below half of the same hour last week", async () => {
  stub({ counts: { ordersNow: 4, ordersLastWeek: 31, abandonedNow: 3, abandonedLastWeek: 9 } });
  const alerts = await runChecks({ now: NOW, sleep: noSleep });
  assert.deepEqual(alerts, ["Orders: 4 in the hour vs 31 same hour last week"]);
});
  1. NOW es el viernes 13 a la 1 de la tarde en la Ciudad de México (19:00 UTC); noSleep salta la espera del reintento.
  2. stub reemplaza globalThis.fetch y contesta según la URL; aquí, 4 pedidos contra 31 de la semana pasada.
  3. La prueba exige exactamente ese aviso.

Con node --test, las 12 pruebas pasaron: hora normal, con la ventana exacta de 17:45 a 18:45 UTC; caída de pedidos; poco volumen sin aviso; tres pagos fallidos; salto de abandonos; checkout que falla dos veces; una falla aislada que no avisa; carrito vacío; error de red; token roto, que avisa y deja correr la prueba del checkout; y un solo mensaje a Slack con salida 1. Al quitar el reintento del código, fallaron 4. Desde la terminal, con fetch simulado, imprimió ok con salida 0 en una hora normal y el aviso con salida 1 ante una caída.

las tres alertas: qué miran y cuándo avisanalertaseñalumbral (ejemplo)ventana1 · pedidos/horaordersCountcreated_at< 50 % de la semanapasada, si hubo ≥ 101 h, hastahace 15 min2a · pagos fallidostransactionsFAILURE o ERROR≥ 3 en la horaúltimos 50pedidos2b · abandonadosabandonedCheckoutsCount+20 puntos deabandono, si ≥ 101 h, hastahace 15 min3 · checkout caídocartCreate +checkoutUrlfalla 2 vecesseguidas30 s entreintentosumbrales de ejemplo: ajústalos con tu historialejemplo ilustrativo; probados con respuestas simuladas, no con una tienda real

Desliza la figura para verla completa

No lo probamos contra una tienda real. Hazlo tú antes del viernes: corre el workflow a mano y verifica que termine en verde. Luego pon en PROBE_VARIANT_ID un ID que no exista y córrelo otra vez: debe llegar el aviso a Slack, la ejecución debe quedar en rojo y debe llegarte el correo. Regresa el secreto. Así pruebas todo sin tocar un pedido.

Errores comunes

  • Avisar por cualquier caída. Sin un mínimo de pedidos, la madrugada llena el canal de ruido y alguien lo silencia.
  • Comparar con la hora anterior. Compara con la misma hora de la semana pasada.
  • Buscar las tarjetas rechazadas en las transacciones. Sin pedido, solo las ves como checkouts abandonados, sin el motivo y después de 10 minutos.
  • Medir hasta el minuto actual. Los checkouts recientes todavía no cuentan como abandonados.
  • Confiar a ciegas en el cron. GitHub puede retrasar o descartar ejecuciones; revisa la pestaña Actions el primer día.
  • Probar con un producto que se puede agotar, o dejar la URL de Slack en el código. Lo primero da falsas alarmas; lo segundo expone un secreto.

Preguntas frecuentes

¿Por qué no usar webhooks en lugar de consultar cada 10 minutos?

Un webhook avisa cuando algo pasa, y estas alertas buscan que algo deje de pasar: si el checkout se cae, no llega ningún webhook de pedidos. order_transactions/create, que según la lista de temas de webhook solo se envía con transacciones en éxito, falla o error, sirve para reaccionar a cada fallo, pero igual necesitas un reloj.

Mi tienda vende pocos pedidos por hora, ¿me sirve?

La alerta 1 no avisará si esa hora de la semana pasada tuvo menos de 10 pedidos. Amplía la ventana o baja MIN_BASELINE, aceptando más falsas alarmas. La alerta 3 no depende del volumen: es la que más te protege.

¿Puedo correrlo sin GitHub Actions?

Sí. Usa el fetch nativo de Node 18 o superior y corre en cualquier computadora o servidor con cron, con la misma línea y las mismas variables de entorno. Fuera de GitHub, la salida 1 ya no te manda un correo: usa el aviso de Slack.

¿La prueba del checkout ensucia mis reportes?

Crea unos 144 carritos al día y ningún pedido. Como no escribe datos de contacto, no cumple la definición de checkout abandonado. No verificamos si Shopify cuenta esas visitas en sus reportes de sesiones: revísalos tras el primer día y, si te estorban, espacia el cron.

Checklist

  • La app tiene read_orders y el script obtiene su token sin errores.
  • La API es la 2026-10 o una estable posterior.
  • La alerta 1 compara con la misma hora de la semana pasada y pide un mínimo de pedidos.
  • La alerta 2 cuenta transacciones fallidas y la proporción de abandonos, con la ventana 15 minutos atrás.
  • La variante de la alerta 3 no se va a agotar.
  • El cron evita el minuto 0, los secretos no están en el código y existe workflow_dispatch.
  • Forzaste una alerta y llegaron el mensaje de Slack y el correo.

Con las tres alertas, una falla del checkout en el Buen Fin te cuesta minutos y no una tarde. Antes de la fecha, corre el smoke test del checkout y congela los cambios. Y si después los números de tu analítica no coinciden con los de Shopify, revisa por qué GA4 y Shopify no cuadran en ventas.

Antes del Buen Fin y de Black Friday, revisa también cuándo salen tus correos de carrito abandonado y qué congelar en tu código.

¿Viste esto en Instagram? Comenta MONITOREO 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 11 de noviembre de 2026 · actualizado el 18 de noviembre de 2026

← Blog