Arquitecto de automatización con IA: Día 20

Día 20. Caso de otro negocio II: el mapa de automatización de una tienda en línea

Introducción

Ayer, en el Día 19 (La creación democrática: desarrolladores ciudadanos y gobierno de las automatizaciones), vio quién puede automatizar hoy en un negocio pequeño, por qué un flujo sin dueño acaba roto y cómo se gobierna lo que construyen los desarrolladores ciudadanos, y Trigo Lento ganó su inventario de flujos con dueño, propósito y criticidad, y la ficha de flujo que permite que otra persona mantenga lo que hizo Valeria. Mañana, en el Día 21, Valeria cerrará el módulo 2 dibujando el mapa de automatización completo de la panadería. Hoy lo ensaya en un negocio ajeno, porque un método que solo se ha probado en casa todavía no es un método.

Es viernes 20 de febrero, las cuatro de la tarde. Valeria sube al tercer piso de una casa en la colonia Portales donde huele a café recién tostado. Ahí trabaja Inés Cabrera, dueña de Café Altura, el tostador que surte el café que se toma cada mañana en el obrador de Trigo Lento. Inés tuesta en una máquina de cinco kilos, Paco empaca y lleva las cajas a la paquetería, y Lucía contesta mensajes, sube fotos a Instagram y responde, una y otra vez, la misma pregunta: "¿dónde viene mi paquete?". Esa semana, Paco empacó hasta la medianoche tres días seguidos. Inés lo cuenta sin dramatismo, mientras pesa un lote de Oaxaca: “No me falta venta, Valeria. Me falta noche.”

Valeria le propone un trato: ella mide los procesos de la tienda con el mismo método que usó en la panadería y en la Clínica Dental Sonrisa Norte del Día 7, y a cambio se queda con la práctica para hacer mañana el mapa de Trigo Lento. Por la noche, en la panadería, se lo cuenta a su padre. Don Ernesto no levanta la vista de la masa: “Su café aguanta meses en la bolsa; mi pan dura un día. No me compare peras con hogazas.” Tiene razón en la mitad que importa. Una tienda en línea cobra por adelantado, envía por paquetería y vende un producto que aguanta semanas; una panadería cobra al recoger, entrega en mostrador y vende algo que caduca al día siguiente. Lo que se compara hoy no son los negocios, sino las preguntas que se les hacen.

En la presente entrada, descubrirá cómo se levanta el mapa de automatización de una tienda en línea. Fijará el perfil de Café Altura y lo que le cuesta vender en línea con las comisiones de octubre de 2026; recorrerá los cinco procesos de cualquier tienda (pedidos, inventario, envíos, devoluciones y carritos abandonados) con lo que entra, lo que sale, quién es el dueño y qué falla; medirá horas antes y después con un diagrama de Pareto y simulará un mes de pedidos. Después contará los créditos de Make del mapa completo y verá cómo un iterador rompe la cuota del plan Core; diseñará el recordatorio de carrito abandonado con consentimiento, un solo aviso y baja inmediata; valorará el riesgo de cada proceso y lo ordenará todo por meses de recuperación. Al final escribirá la especificación del flujo de guías con la plantilla del Día 18, dibujará el mapa de Café Altura y lo pondrá al lado de Trigo Lento para decidir qué viaja al Día 21 y qué se queda en el tostador.

Objetivos de aprendizaje

Al terminar esta entrada, usted podrá:

• Levantar el mapa de procesos de una tienda en línea (pedidos, inventario, envíos, devoluciones y carritos abandonados) con volúmenes, tiempos y dueños.
  
• Estimar para cada proceso las horas ahorradas, los créditos de Make, el coste en pesos y el riesgo, y ordenarlos por meses de recuperación.
  
• Diseñar la recuperación de carritos abandonados solo con consentimiento, con un único recordatorio y baja inmediata.
  
• Comparar el mapa de Café Altura con el de Trigo Lento y llevar el método al Día 21.

Café Altura en cifras

Igual que el Día 7 se fijó la ficha de la clínica antes de medir nada, hoy se fija la de Café Altura, porque todas las cifras de la entrada se derivan de ella y se reutilizarán el Día 73, cuando el tostador genere el contenido de sus fichas de producto, y el Día 85, cuando la serie reúna los tres negocios de otros sectores. Café Altura es un tostador de especialidad ficticio con tres personas: Inés Cabrera tuesta y compra el café verde a cooperativas de Chiapas, Veracruz, Oaxaca, Puebla, Nayarit y Guerrero; Paco Mena empaca y envía; Lucía Robles atiende a los clientes y lleva las redes. Vende 8 cafés, cada uno en bolsas de 250 g y de 1 kg, solo en línea: no tiene mostrador.

Recibe 620 pedidos al mes con un ticket medio de 540 MXN, lo que da $620 \cdot 540 = 334,800$ MXN de ventas mensuales. Todos los pedidos se pagan por adelantado en la tienda en línea: el $70%$ llega directo a la tienda, el $20%$ desde el enlace del perfil de Instagram y el $10%$ por WhatsApp, donde Lucía envía un enlace de pago. Los pedidos salen por paquetería a domicilio y llegan en dos a cuatro días hábiles. Para pasar horas a pesos se usa un valor de la hora de 90 MXN, un supuesto didáctico algo mayor que los 75 MXN de Valeria, porque en el tostador la hora que se pierde empacando es una hora que no se tuesta. La Tabla 1 reúne el perfil.

Tabla 1. Perfil de Café Altura (negocio ficticio; todas las cifras son inventadas y se declaran como supuestos).

Como en todos los días de la serie, el primer bloque prepara las importaciones, la semilla global $2026$ y una carpeta. Igual que la clínica tuvo sonrisa_norte/, los archivos del tostador viven en una subcarpeta propia, cafe_altura/, dentro del cuaderno del día: ningún bloque toca trigo_lento.sqlite ni los archivos de la panadería, porque los datos de dos negocios no se mezclan aunque los analice la misma persona:

# Importaciones base, semilla de la serie y carpeta del caso de Café Altura en Python:
import warnings
warnings.filterwarnings('ignore')
import json
from pathlib import Path
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Generador aleatorio con la semilla global de la serie:
rng = np.random.default_rng(2026)
pd.set_option('display.width', 120)
pd.set_option('display.max_columns', 12)
cafe = Path('trigo_lento') / 'dia_20' / 'cafe_altura'
cafe.mkdir(parents = True, exist_ok = True)
MXN_POR_USD = 18.50          # tipo de cambio didáctico de la serie (supuesto)
print('numpy', np.__version__, '| pandas', pd.__version__)
print('Carpeta del caso:', cafe.as_posix())

numpy 2.4.6 | pandas 3.0.3
Carpeta del caso: trigo_lento/dia_20/cafe_altura

Las versiones son las mismas con las que se calcularon todas las cifras del día. El tipo de cambio didáctico de la serie, $18.50$ MXN por dólar, servirá para pasar a pesos el precio de Make y el de las plataformas que cobran en dólares.

Lo que cuesta vender en línea

Antes de hablar de automatizar, conviene saber cuánto le cuesta a Café Altura la infraestructura que ya usa, porque es la escala contra la que se juzgará el gasto en flujos. Una tienda en línea paga dos cosas: la plataforma donde vive el catálogo y el carrito, y la pasarela de pago que cobra con tarjeta. Las comisiones que se usan a continuación son las publicadas en las páginas oficiales de México en octubre de 2026:

• Shopify, plan Basic: $19$ USD al mes en pago mensual ($14$ en pago anual); con su pasarela propia, Shopify Payments, cobra $3.5%$ más $3$ MXN por venta en línea con tarjeta; con un proveedor de pago externo, añade un cargo del $2%$ (del $1%$ en el plan Grow y del $0.6%$ en Advanced).
  
• Mercado Pago, enlace de pago con el dinero disponible al instante: $3.49%$ más $4$ MXN por cobro (la tasa fija, más IVA), y comisiones menores si se espera 7 o 30 días a que se libere el dinero.
  
• Stripe: $3.6%$ más $3$ MXN por tarjeta nacional, sin IVA, la opción habitual de una tienda propia hecha con WooCommerce, cuyo complemento es gratuito pero cuyo hospedaje no.
  
• Tiendanube: planes de $0$, $149$, $374$ y $999$ MXN al mes. Su blog de precios dice que no cobra comisión por venta, pero su centro de ayuda (actualizado en septiembre de 2026) describe un costo por transacción del $2%$, $1%$, $0.6%$ o $0.5%$ según el plan, que no se cobra en las ventas pagadas con su pasarela propia. Ante dos páginas oficiales que no coinciden, el análisis no usa la cifra y recomienda leer el contrato antes de firmar.
  
• Mercado Libre, como mercado y no como tienda propia: su página para vendedores anuncia un cargo por venta de entre el $8%$ y el $18%$ según la categoría, más un costo fijo por unidad en productos baratos.

El siguiente bloque guarda el catálogo en cafe_altura/catalogo_cafe.csv, reparte los pedidos por canal y calcula el coste mensual de tres maneras de cobrar los $620$ pedidos, más el de Make Core, la plataforma de automatización que la serie eligió el Día 13. El coste mensual de cada opción es $n \cdot t \cdot p + n \cdot f + c$, con $n$ pedidos, $t$ ticket medio, $p$ comisión porcentual, $f$ cargo fijo por cobro y $c$ cuota mensual:

# Perfil, catálogo y coste de vender en línea de Café Altura (datos inventados) en Python:
perfil = {
    'negocio': 'Café Altura (tostador de especialidad, ficticio)',
    'equipo': 'Inés (tueste y compras), Paco (empaque y envíos), Lucía (atención y redes)',
    'pedidos_mes': 620,
    'ticket_medio_mxn': 540,
    'pago': 'Anticipado en la tienda en línea',
    'entrega': 'Paquetería a domicilio, de 2 a 4 días hábiles',
    'canales': {'Tienda en línea': 0.70, 'Instagram (enlace a la tienda)': 0.20, 'WhatsApp (enlace de pago)': 0.10},
    'valor_hora_mxn': 90,                     # supuesto didáctico
}
catalogo = pd.DataFrame({
    'clave': [f'C{i:02d}' for i in range(1, 9)],
    'cafe': ['Chiapas Altura', 'Veracruz Coatepec', 'Oaxaca Pluma', 'Puebla Cuetzalan',
             'Nayarit Jalcocotán', 'Guerrero Atoyac', 'Descafeinado Chiapas', 'Mezcla Espresso'],
    'bolsa_250g': [165, 175, 185, 170, 160, 165, 180, 155],
    'bolsa_1kg': [560, 590, 630, 575, 540, 560, 610, 520],
})
catalogo.to_csv(cafe / 'catalogo_cafe.csv', index = False)
ventas_mes = perfil['pedidos_mes'] * perfil['ticket_medio_mxn']
print(catalogo.to_string(index = False))
print('Ventas al mes:', f'{ventas_mes:,} MXN', '| pedidos por canal:',
      {c: round(p * perfil['pedidos_mes']) for c, p in perfil['canales'].items()})

# Comisiones publicadas en octubre de 2026 (porcentaje, fijo por cobro en MXN, cuota mensual en MXN):
n, t = perfil['pedidos_mes'], perfil['ticket_medio_mxn']
opciones = {
    'Shopify Basic con Shopify Payments': (0.035, 3.00, 19 * MXN_POR_USD),
    'Shopify Basic con Mercado Pago (cargo externo 2 %)': (0.0349 + 0.02, 4.00, 19 * MXN_POR_USD),
    'Tienda propia con Stripe (hospedaje supuesto 300 MXN)': (0.036, 3.00, 300.0),
    'Make Core para todas las automatizaciones': (0.0, 0.0, 10.59 * MXN_POR_USD),
}
costes = pd.DataFrame([{'opcion': k, 'porcentaje': p * 100, 'fijo_mxn': f, 'cuota_mxn': c,
                        'total_mxn': round(n * t * p + n * f + c, 2)} for k, (p, f, c) in opciones.items()])
costes['pct_ventas'] = (costes['total_mxn'] / ventas_mes * 100).round(2)
print(costes.to_string(index = False))

clave                 cafe  bolsa_250g  bolsa_1kg
  C01       Chiapas Altura         165        560
  C02    Veracruz Coatepec         175        590
  C03         Oaxaca Pluma         185        630
  C04     Puebla Cuetzalan         170        575
  C05   Nayarit Jalcocotán         160        540
  C06      Guerrero Atoyac         165        560
  C07 Descafeinado Chiapas         180        610
  C08      Mezcla Espresso         155        520
Ventas al mes: 334,800 MXN | pedidos por canal: {'Tienda en línea': 434, 'Instagram (enlace a la tienda)': 124, 'WhatsApp (enlace de pago)': 62}
                                               opcion  porcentaje  fijo_mxn  cuota_mxn  total_mxn  pct_ventas
                   Shopify Basic con Shopify Payments        3.50       3.0    351.500   13929.50        4.16
   Shopify Basic con Mercado Pago (cargo externo 2 %)        5.49       4.0    351.500   21212.02        6.34
Tienda propia con Stripe (hospedaje supuesto 300 MXN)        3.60       3.0    300.000   14212.80        4.25
            Make Core para todas las automatizaciones        0.00       0.0    195.915     195.91        0.06

La salida es la Tabla 2. Vender en línea le cuesta a Café Altura entre $13,929.50$ MXN y $21,212.02$ MXN al mes, entre el $4.16%$ y el $6.34%$ de sus ventas, según cómo cobre. Usar una pasarela externa dentro de Shopify es la opción más cara porque se pagan dos comisiones: la de Mercado Pago y el $2%$ que Shopify cobra por no usar la suya. La tienda propia con Stripe queda a $283.30$ MXN de Shopify con su pasarela, una diferencia que el tiempo de mantener un servidor se come enseguida.

Tabla 2. Coste mensual de cobrar 620 pedidos de 540 MXN con cada opción, y de Make Core (comisiones publicadas en México, revisado en octubre de 2026, sin IVA; el hospedaje de la tienda propia es un supuesto).

La última fila es la que Valeria subraya en su cuaderno. Todo el plan Core de Make cuesta $195.92$ MXN al mes, el $0.06%$ de las ventas, setenta veces menos que cobrar con tarjeta. No es un argumento para gastar sin mirar, sino para mirar donde está el dinero: en una tienda en línea el gasto en automatización es casi invisible frente al de cobrar, y lo que decide si un flujo vale la pena no es su cuota, sino las horas que libera y los errores que puede provocar.

Los cinco procesos de una tienda en línea

Una panadería por encargo tiene un proceso dominante: recibir el encargo, apuntarlo y avisar al obrador. Una tienda en línea tiene cinco, encadenados a lo largo de la vida de un pedido, y cada uno con un dueño distinto. La Figura 1 recorre esa cadena del café verde a la puerta del cliente y cuelga de cada eslabón el proceso que lo atiende, con su volumen y su dueño.

Figura 1. Del tueste a la puerta: la cadena de valor de Café Altura, del café verde al cliente, con los cinco procesos de la tienda en línea, su volumen mensual y la persona dueña de cada uno.

Para cada proceso, Valeria se hace las mismas cuatro preguntas del Día 1: qué entra, qué sale, quién es el dueño y qué falla. Las respuestas son las de Café Altura, pero las preguntas sirven para cualquier tienda.

Pedidos

Qué entra: la notificación de la tienda de que un pedido se pagó, con los renglones, la dirección y el correo del cliente. Qué sale: el pedido registrado en la hoja de tueste de Inés, que agrupa por café los gramos que hay que tostar, y un mensaje de confirmación con la fecha estimada de envío. Dueña: Lucía. Qué falla: hoy Lucía copia cada pedido a mano de la tienda a la hoja, unos tres minutos por pedido; cuando el día se llena, se salta pedidos o los copia dos veces, y la hoja de tueste deja de coincidir con la tienda.

La tienda ya envía un correo automático de confirmación de compra, así que automatizar este proceso no consiste en “confirmar al cliente”, sino en que el pedido pagado llegue solo a la hoja de tueste y en que el mensaje personal que Lucía añade por WhatsApp a los clientes frecuentes salga con la fecha correcta. Es un proceso de bajo riesgo: si falla, el pedido sigue en la tienda y la hoja se puede corregir.

Inventario

Qué entra: cada pedido pagado resta gramos de café tostado de cada origen; cada tueste suma un lote. Qué sale: el inventario por origen y por lote, con su fecha de tueste, y un aviso de reorden cuando un café baja de su punto de reorden. Dueña: Inés. Qué falla: el café de especialidad se vende fresco, y la fecha de tueste impresa en la etiqueta es parte del producto. Un inventario que no distingue lotes manda bolsas tostadas hace seis semanas mientras las de esta semana esperan en el estante.

Aquí está la primera diferencia de fondo con Trigo Lento: Don Ernesto tiene razón en que el café aguanta meses, pero para quien lo compra, la frescura es el producto. El inventario de Café Altura no cuenta solo kilos, cuenta días desde el tueste. El flujo que resta gramos es fácil; la decisión de cuándo tostar es de Inés, porque depende del café verde que tenga, de la máquina y de los pedidos de la semana.

Envíos

Qué entra: el pedido empacado, con peso, medidas y dirección. Qué sale: una guía de la paquetería, es decir, la etiqueta con el número de rastreo; el número escrito en el pedido de la tienda, para que el cliente lo vea; y un aviso de envío con el enlace de rastreo. Dueño: Paco. Qué falla: hoy Paco entra al portal de la paquetería, teclea la dirección, imprime la guía, copia el número a la tienda y avisa al cliente: cinco minutos por pedido, más de cincuenta horas al mes. Las direcciones incompletas producen entregas fallidas que vuelven al tostador semanas después, y los avisos que no salen producen la pregunta que Lucía contesta todo el día: "¿dónde viene mi paquete?".

Las paqueterías que trabajan con tiendas en línea suelen ofrecer una API para crear guías y consultar el rastreo. Ese es el paso que convierte cinco minutos en uno: el flujo pide la guía, la manda a la impresora y escribe el número; Paco pesa la caja y pega la etiqueta. Es un proceso de riesgo medio, porque mueve direcciones, datos personales que solo pueden ir a la paquetería y solo para entregar, y porque depende de un tercero que a veces falla.

Devoluciones

Qué entra: un mensaje del cliente con una bolsa rota, un café equivocado o un paquete que nunca llegó, a veces con una foto. Qué sale: una decisión (reenvío, reembolso o nada), la devolución registrada y, si procede, el reembolso en la pasarela. Dueña: Inés. Qué falla: son pocas, $19$ al mes, pero cada una se lleva veinte minutos entre leer, buscar el pedido, pedir la foto, decidir y responder.

La regla de este proceso cabe en una línea: el reembolso lo aprueba Inés, nunca el flujo. Un modelo de lenguaje puede leer el mensaje, clasificar el motivo y preparar un borrador de respuesta con el pedido ya buscado, y eso baja de $20$ a $12$ minutos el trabajo de Inés; pero mover dinero y responder a una queja son acciones con efecto económico y reputacional, y el código de honor del Día 6 las reserva para una persona.

Carritos abandonados

Qué entra: un carrito con productos que alguien llenó y no pagó. Qué sale: como mucho, un recordatorio. Dueña: Lucía. Qué falla: hoy nada, porque nadie hace nada: no hay trabajo manual previo que ahorrar, y por eso es el único proceso cuyo valor no se mide en horas, sino en ventas recuperadas.

Es también el proceso más delicado del mapa. Un recordatorio de carrito es comunicación comercial, no transaccional: el cliente no pidió nada todavía. Por eso solo se envía a quien dio consentimiento expreso y separado para recibir mensajes de marketing de Café Altura, solo una vez, con un enlace de baja que funciona al instante, y nunca a un visitante anónimo que no dejó su correo. La sección de riesgos convierte esta regla en un filtro con números.

Medir antes de automatizar

Con los procesos descritos, toca medirlos. Valeria pasa dos días en el tostador con el cronómetro del teléfono, igual que hizo en la panadería el Día 1, y apunta cuántos casos hay al mes y cuántos minutos se lleva cada uno hoy; después, con Inés, estima cuántos minutos de atención humana quedarían con el flujo. Las horas que ahorra cada proceso al mes se calculan así:

$$ H = \frac{n \cdot (t_a - t_d)}{60} $$

La lógica de la fórmula es la del Día 1, con una columna más:

• $n$ es el número de casos al mes del proceso: pedidos, guías, devoluciones.
  
• $t_a$ son los minutos por caso antes de automatizar, medidos con cronómetro; $t_d$, los minutos por caso después, que nunca son cero porque casi siempre queda una persona que revisa, pesa, pega o decide.
  
• Se divide entre $60$ para pasar de minutos a horas, y $H$ se multiplica por el valor de la hora para pasarlo a pesos.
  
• En conclusión, un proceso puede tener muchos casos y ahorrar poco (si el flujo solo quita segundos) o pocos casos y ahorrar mucho (si cada uno se lleva media hora): la fórmula pesa las dos cosas a la vez.

El siguiente bloque escribe los cinco procesos con su volumen, sus minutos y su dueño, calcula las horas a mano, las horas con flujos y las horas ahorradas, y dibuja el diagrama de Pareto de las horas a mano, ordenadas de mayor a menor con la línea del porcentaje acumulado. Los carritos llevan los $282$ recordatorios que el plan supone (el $30%$ de $940$ carritos) con cero minutos, porque hoy nadie los atiende:

# Procesos con volumen y minutos, horas manuales, horas ahorradas y diagrama de Pareto en Python:
procesos = pd.DataFrame({
    'proceso': ['Confirmar y registrar pedido', 'Guía de envío y rastreo', 'Inventario y reorden de tueste',
                'Devoluciones', 'Carritos abandonados'],
    'n_mes': [620, 620, 620, 19, 282],
    't_antes': [3.0, 5.0, 1.5, 20.0, 0.0],      # minutos por caso hoy
    't_despues': [0.5, 1.0, 0.2, 12.0, 0.0],    # minutos por caso con el flujo
    'dueno': ['Lucía', 'Paco', 'Inés', 'Inés', 'Lucía'],
})
procesos['h_antes'] = procesos['n_mes'] * procesos['t_antes'] / 60
procesos['h_despues'] = procesos['n_mes'] * procesos['t_despues'] / 60
procesos['H_ahorro'] = procesos['n_mes'] * (procesos['t_antes'] - procesos['t_despues']) / 60
print(procesos.round(2).to_string(index = False))
H_total = procesos['H_ahorro'].sum()
print(f'Horas a mano: {procesos["h_antes"].sum():.2f} | con flujos: {procesos["h_despues"].sum():.2f} | '
      f'ahorradas: {H_total:.2f} h = {H_total * perfil["valor_hora_mxn"]:,.2f} MXN al mes')

# Pareto de las horas a mano, de mayor a menor, con la línea acumulada:
pareto = procesos.sort_values('h_antes', ascending = False)
acumulado = pareto['h_antes'].cumsum() / pareto['h_antes'].sum() * 100
fig, ax = plt.subplots(figsize = (9, 5))
ax.bar(range(len(pareto)), pareto['h_antes'], color = '#2a78d6')
for i, v in enumerate(pareto['h_antes']):
    ax.text(i, v + 1, f'{v:.1f} h', ha = 'center', fontsize = 10)
ax.set_xticks(range(len(pareto)))
ax.set_xticklabels([p.replace(' y ', '\ny ') for p in pareto['proceso']], fontsize = 9)
ax.set_ylabel('Horas a mano al mes')
ax2 = ax.twinx()
ax2.plot(range(len(pareto)), acumulado, color = '#eb6834', marker = 'o', linewidth = 2)
ax2.axhline(80, color = '#8a8986', linestyle = '--', linewidth = 1)
ax2.set_ylim(0, 105)
ax2.set_ylabel('Porcentaje acumulado')
ax.set_title('Café Altura: Pareto de horas a mano por proceso', fontsize = 16)
ax.spines[['top']].set_visible(False)
plt.tight_layout()
plt.show()
print('Acumulado (%):', dict(zip(pareto['proceso'], acumulado.round(1))))

                       proceso  n_mes  t_antes  t_despues dueno  h_antes  h_despues  H_ahorro
  Confirmar y registrar pedido    620      3.0        0.5 Lucía    31.00       5.17     25.83
       Guía de envío y rastreo    620      5.0        1.0  Paco    51.67      10.33     41.33
Inventario y reorden de tueste    620      1.5        0.2  Inés    15.50       2.07     13.43
                  Devoluciones     19     20.0       12.0  Inés     6.33       3.80      2.53
          Carritos abandonados    282      0.0        0.0 Lucía     0.00       0.00      0.00
Horas a mano: 104.50 | con flujos: 21.37 | ahorradas: 83.13 h = 7,482.00 MXN al mes
Acumulado (%): {'Guía de envío y rastreo': 49.4, 'Confirmar y registrar pedido': 79.1, 'Inventario y reorden de tueste': 93.9, 'Devoluciones': 100.0, 'Carritos abandonados': 100.0}

La salida es la Tabla 3. Café Altura dedica $104.50$ horas al mes a mano a estos procesos; con los flujos quedarían $21.37$, y el ahorro es de $83.13$ horas, $7,482.00$ MXN al mes al valor de $90$ MXN la hora.

Tabla 3. Procesos de Café Altura con volumen mensual, minutos por caso antes y después, horas a mano, horas ahorradas y dueño (minutos medidos y estimados como supuestos didácticos).

El diagrama de Pareto cuenta lo mismo con una sola mirada. Las guías de envío son, por sí solas, el $49.4%$ de las horas a mano, y con la confirmación de pedidos suman el $79.1%$: dos procesos de cinco concentran cuatro quintas partes del trabajo, casi exactamente la proporción que da nombre al diagrama. Las devoluciones, que son las que más le pesan a Inés por el mal rato, son apenas el $6%$ de las horas. Y los carritos, que serán la tentación de la sección de prioridades, no ocupan ni una hora, porque hoy nadie los atiende.

Fíjese en lo que significa la noche de Paco. Las $51.67$ horas de guías son casi trece horas a la semana: la diferencia entre salir a las ocho y salir a medianoche tres días. Cuando Valeria se lo enseña, Inés lo resume mejor que el gráfico: “Entonces lo que me falta no es noche. Me sobran guías.”

Un mes de pedidos simulado

Los promedios esconden la forma de un mes. Los pedidos de una tienda no llegan de veinte en veinte, sino de manera irregular, y cada pedido trae uno, dos o más renglones (cada café distinto del pedido es un renglón), lo que importará mucho al contar créditos. El siguiente bloque simula un mes de $30$ días con llegadas de Poisson de media $620/30$ pedidos al día; para cada pedido, el número de renglones es $1 + \text{Poisson}(0.8)$, con media $1.8$; y los carritos abandonados llegan también como Poisson, con $940$ al mes. Guarda el mes en cafe_altura/mes_simulado.csv:

# Un mes simulado de pedidos, renglones por pedido y carritos abandonados en Python:
DIAS_MES = 30                                   # la tienda vende todos los días
pedidos_dia = rng.poisson(620 / DIAS_MES, DIAS_MES)
renglones = 1 + rng.poisson(0.8, pedidos_dia.sum())
carritos_dia = rng.poisson(940 / DIAS_MES, DIAS_MES)
mes = pd.DataFrame({'dia': range(1, DIAS_MES + 1), 'pedidos': pedidos_dia, 'carritos': carritos_dia})
mes.to_csv(cafe / 'mes_simulado.csv', index = False)
r_simulado = renglones.mean()
print('Pedidos del mes:', pedidos_dia.sum(), '| por día: media', round(pedidos_dia.mean(), 2),
      'mín', pedidos_dia.min(), 'máx', pedidos_dia.max())
print('Renglones por pedido: media', round(r_simulado, 3), '| pedidos con 3 o más renglones:',
      f'{(renglones >= 3).mean():.1%}', '| máximo', renglones.max())
print('Carritos abandonados del mes:', carritos_dia.sum(), '| por día: media', round(carritos_dia.mean(), 2),
      'máx', carritos_dia.max())
print('Carritos por pedido pagado:', round(carritos_dia.sum() / pedidos_dia.sum(), 2))

Pedidos del mes: 624 | por día: media 20.8 mín 11 máx 28
Renglones por pedido: media 1.856 | pedidos con 3 o más renglones: 20.4% | máximo 5
Carritos abandonados del mes: 968 | por día: media 32.27 máx 43
Carritos por pedido pagado: 1.55

El mes simulado tuvo $624$ pedidos, con días de $11$ y días de $28$: un día malo trae más del doble de pedidos que uno bueno, y el flujo debe aguantar el día de $28$, no el promedio de $20.8$. Los renglones salieron con una media de $1.856$, cerca del $1.8$ teórico, y uno de cada cinco pedidos ($20.4%$) trae tres cafés o más. Los carritos abandonados fueron $968$, unos $32$ al día, $1.55$ por cada pedido pagado.

Esa última cifra merece un comentario. El Baymard Institute, que reúne medio centenar de estudios sobre carritos abandonados, documenta una tasa media cercana al $70%$ de los carritos que se abandonan. La de Café Altura es menor: con $940$ carritos abandonados y $620$ pedidos, abandona el $940 / (940 + 620) = 60.3%$. Es una tienda pequeña con clientes que repiten, y tiene sentido que abandone menos que el promedio, pero la cifra es un supuesto del caso, no una medición, y el primer trabajo del flujo de carritos será medirla de verdad.

Créditos y coste en Make

El Día 12 tradujo el flujo de mensajes de Trigo Lento a la unidad de cobro de Make: un crédito por cada acción de un módulo. Para el mapa de Café Altura, Valeria hace la misma cuenta, proceso por proceso, con los módulos que tendría cada escenario:

• Confirmar y registrar pedido, $4$ créditos por pedido: el webhook del pedido pagado, la búsqueda del cliente, la fila en la hoja de tueste y el mensaje.
  
• Guía de envío y rastreo, $5$ por pedido: el webhook, la petición de la guía a la paquetería, el número de rastreo escrito en la tienda, el registro en la hoja de envíos y el aviso al cliente.
  
• Inventario y reorden, $2 + 2r$ por pedido con un iterador: el webhook y la lectura del pedido, y después, por cada uno de los $r$ renglones, la resta de gramos y la comprobación del punto de reorden.
  
• Devoluciones, $4$ por caso; carritos, $1$ crédito por cada carrito revisado más $3$ por cada recordatorio enviado.

El total del mes es una suma de productos:

$$ K = \sum_{i} n_i \cdot k_i, \qquad k_{\text{inventario}} = 2 + 2r $$

• $n_i$ es el número de casos al mes del proceso $i$ y $k_i$ los créditos que consume cada caso, es decir, el número de módulos que se ejecutan.
  
• El término $2r$ es el que hace crecer el inventario: un iterador reparte el pedido en $r$ paquetes, y cada módulo que viene después se ejecuta una vez por paquete, como advirtió la Tabla B de la serie.
  
• $K$ se compara con la cuota del plan: $10,000$ créditos al mes en Make Core, a $10.59$ USD en pago mensual (revisado en octubre de 2026).

El siguiente bloque calcula los créditos de cada proceso con el iterador y con una alternativa: en lugar de recorrer los renglones, un solo módulo calcula los gramos de todo el pedido con una función y hace una sola actualización agregada del inventario, con $3$ créditos por pedido. Dibuja las dos versiones en barras apiladas frente a la cuota de Core:

# Créditos de Make por proceso, con iterador de inventario y con actualización agregada, en Python:
R_PLAN = 1.8                                    # renglones medios por pedido: 1 + 0.8
CUOTA_CORE = 10_000
def creditos(r, inventario_agregado, recordatorios = 282, carritos_mes = 940):
    k_inventario = 3 if inventario_agregado else 2 + 2 * r
    return {'Confirmar y registrar pedido': 620 * 4,
            'Guía de envío y rastreo': 620 * 5,
            'Inventario y reorden de tueste': round(620 * k_inventario),
            'Devoluciones': 19 * 4,
            'Carritos abandonados': carritos_mes * 1 + recordatorios * 3}

escenarios = pd.DataFrame({'con iterador': creditos(R_PLAN, False),
                           'con actualización agregada': creditos(R_PLAN, True)})
print(escenarios.to_string())
print('Totales:', escenarios.sum().to_dict(), '| cuota de Core:', CUOTA_CORE)
print('Con los renglones simulados (r =', round(r_simulado, 3), '):', sum(creditos(r_simulado, False).values()))
usd_por_credito = 10.59 / CUOTA_CORE
print('Coste por crédito:', round(usd_por_credito * MXN_POR_USD, 5), 'MXN')

# Barras apiladas de los dos diseños frente a la cuota de Make Core:
colores = ['#2a78d6', '#3a9d5d', '#eb6834', '#c8423b', '#7b5ea7']
fig, ax = plt.subplots(figsize = (11, 5))
base = np.zeros(2)
for color, (proceso, fila) in zip(colores, escenarios.iterrows()):
    ax.bar(escenarios.columns, fila.values, bottom = base, color = color, label = proceso, width = 0.55)
    base += fila.values
for i, total in enumerate(base):
    ax.text(i, total + 150, f'{total:,.0f}'.replace(',', ' '), ha = 'center', fontsize = 11, fontweight = 'bold')
ax.axhline(CUOTA_CORE, color = '#52514e', linestyle = '--', linewidth = 1.5)
ax.text(0.5, CUOTA_CORE + 200, 'Cuota de Make Core: 10 000', ha = 'center', fontsize = 10)
ax.set_ylim(0, 12_500)
ax.set_ylabel('Créditos al mes')
ax.legend(fontsize = 9, loc = 'upper left', bbox_to_anchor = (1.01, 1.0), frameon = False)
ax.set_title('Créditos del mapa completo de Café Altura', fontsize = 16)
ax.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.show()

                                con iterador  con actualización agregada
Confirmar y registrar pedido            2480                        2480
Guía de envío y rastreo                 3100                        3100
Inventario y reorden de tueste          3472                        1860
Devoluciones                              76                          76
Carritos abandonados                    1786                        1786
Totales: {'con iterador': 10914, 'con actualización agregada': 9302} | cuota de Core: 10000
Con los renglones simulados (r = 1.856 ): 10983
Coste por crédito: 0.01959 MXN

Con el iterador, el mapa completo pide $10,914$ créditos, $914$ por encima de la cuota de Core; con la actualización agregada, $9,302$, que caben con un margen del $7%$. El culpable se ve en la gráfica sin leer un número: la franja naranja del inventario pasa de $3,472$ a $1,860$ créditos. Con los renglones del mes simulado ($r = 1.856$) el diseño con iterador sube a $10,983$, porque cada renglón de más es un par de créditos de más; el diseño agregado no cambia, porque cuesta lo mismo con un café que con cinco. Un iterador convierte el tamaño de cada pedido en coste; una actualización agregada lo convierte en una constante.

Cada crédito de Core cuesta $0.01959$ MXN, así que los $914$ créditos sobrantes no son caros en sí mismos: unos $18$ MXN. El problema es otro. Al agotar la cuota, los escenarios dejan de ejecutarse hasta el siguiente ciclo de facturación, salvo que alguien compre créditos adicionales o suba de plan, y un escenario detenido el día $27$ del mes significa guías que no se generan. El diseño no se cambia para ahorrar dieciocho pesos, sino para no depender de que alguien compre créditos un sábado por la noche.

Riesgos de cada automatización

Las horas y los créditos dicen cuánto se gana y cuánto se paga, pero no qué puede salir mal. Valeria valora cada proceso con una escala de riesgo de $1$ (bajo) a $3$ (alto) y con el tipo de daño que puede causar un fallo. En una tienda en línea, los daños se reparten en cuatro familias:

• Dinero: un reembolso duplicado o hecho a quien no correspondía. Es dinero que sale y casi nunca vuelve.
  
• Datos personales: las direcciones de envío, que dicen dónde vive una persona. Solo pueden ir a la paquetería y solo para entregar, como exige la Ley Federal de Protección de Datos Personales en Posesión de los Particulares que la serie usa desde el Día 6.
  
• Reputación: un mensaje que llega a quien no lo pidió, o dos veces, o después de que la persona pidió que no le escribieran.
  
• Dependencia de terceros: la paquetería o la tienda cambian su API, o se caen, y el flujo se detiene con ellas.

El filtro de los carritos

De los cinco procesos, el de carritos concentra el riesgo reputacional, y por eso Valeria lo convierte en un filtro antes de contar cuánto vale. Un carrito solo recibe un recordatorio si pasa cuatro condiciones: que la persona dejó su correo (nunca se rastrea a un visitante anónimo); que tiene consentimiento de marketing vigente, otorgado aparte de la compra y no como una casilla premarcada; que no compró por su cuenta antes de las $24$ horas ni pidió la baja; y que no ha recibido otro recordatorio ese mes, porque un cliente con tres carritos abandonados no debe recibir tres avisos. La Figura 3 dibuja la vida de un carrito que pasa los filtros: un único aviso a las $24$ horas, con enlace de baja, y después silencio.

Figura 3. El recordatorio que no persigue: un carrito abandonado pasa cuatro filtros, recibe a lo sumo un aviso a las 24 horas con enlace de baja y, después, silencio; de 940 carritos, 198 avisos al mes.

El siguiente bloque simula los $940$ carritos del plan con proporciones declaradas como supuestos: el $70%$ deja su correo antes de abandonar; de ellos, el $43%$ tiene consentimiento de marketing (el $30%$ de todos los carritos, la cifra del plan); el $15%$ compra por su cuenta y el $2%$ pide la baja; y cada cliente recibe como mucho un recordatorio al mes, el de su carrito más antiguo. Guarda la lista en cafe_altura/recordatorios_elegibles.csv, solo con identificadores seudónimos:

# Elegibilidad de los carritos abandonados para un único recordatorio en Python:
carritos = pd.DataFrame({
    'id_carrito': [f'K{i:04d}' for i in range(1, 941)],
    'identificado': rng.random(940) < 0.70,          # dejó su correo antes de abandonar
    'cliente': rng.integers(1, 620, 940),             # identificador seudónimo del cliente
})
consiente = rng.random(940) < 0.43                     # consentimiento de marketing vigente
carritos['consentimiento'] = carritos['identificado'] & consiente
carritos['compro_despues'] = rng.random(940) < 0.15   # compró por su cuenta antes de 24 horas
carritos['baja'] = rng.random(940) < 0.02             # pidió la baja de los avisos
filtro = carritos['consentimiento'] & ~carritos['compro_despues'] & ~carritos['baja']
# Un recordatorio como máximo por cliente en el mes, al carrito más antiguo:
elegibles = carritos[filtro].drop_duplicates('cliente', keep = 'first')
embudo = pd.Series({
    'Carritos abandonados': len(carritos),
    'Con correo (no anónimos)': int(carritos['identificado'].sum()),
    'Con consentimiento de marketing': int(carritos['consentimiento'].sum()),
    'Sin compra posterior ni baja': int(filtro.sum()),
    'Un recordatorio por cliente': len(elegibles),
})
print(embudo.to_string())
E = len(elegibles)
print(f'Recordatorios: {E} ({E / len(carritos):.1%} de los carritos) frente a 282 (30 %) del plan')
elegibles[['id_carrito', 'cliente']].to_csv(cafe / 'recordatorios_elegibles.csv', index = False)
print('Créditos de carritos con la cifra real:', 940 + 3 * E)

Carritos abandonados               940
Con correo (no anónimos)           656
Con consentimiento de marketing    289
Sin compra posterior ni baja       239
Un recordatorio por cliente        198
Recordatorios: 198 (21.1% de los carritos) frente a 282 (30 %) del plan
Créditos de carritos con la cifra real: 1534

El embudo deja $198$ recordatorios al mes, el $21.1%$ de los carritos, frente a los $282$ ($30%$) que suponía el plan. La diferencia se explica fila por fila: $284$ carritos son de visitantes anónimos, $367$ de personas sin consentimiento de marketing, $50$ de personas que compraron solas o pidieron la baja y $41$ de clientes que ya tenían otro carrito en el mes. El consentimiento no recorta un poco el volumen: lo recorta en casi un tercio respecto a la cifra que se habría usado sin filtro, y con él los créditos de carritos bajan de $1,786$ a $1,534$.

Esa reducción no es un coste del cumplimiento, es la cifra correcta. Un recordatorio enviado a quien no lo pidió no recupera una venta: genera una queja, una baja o, peor, la sensación de que la tienda vigila. En México, además, el artículo 76 Bis de la Ley Federal de Protección al Consumidor, que regula las transacciones por medios electrónicos, obliga al proveedor a respetar la decisión del consumidor de no recibir avisos comerciales.

La tabla de riesgos

Con el filtro de carritos resuelto, Valeria escribe la tabla de riesgos completa. Cada proceso lleva su nivel, el tipo de daño principal, el control que lo reduce y el paso humano obligatorio, la puerta que ningún flujo salta. La Tabla 4 es la versión final:

Tabla 4. Riesgo por proceso de Café Altura (1 bajo, 3 alto), con su tipo, el control propuesto y el paso humano obligatorio.

Dos detalles de la tabla vienen de días anteriores. Las claves de la API de la paquetería y de la tienda no se escriben en ningún escenario: van en las conexiones de Make con el alcance mínimo, como pide el Día 17 (Seguridad I: OAuth, secretos y mínimo privilegio en las conexiones). Y cada fila tiene una persona dueña, como pidió ayer el Día 19, para que ningún flujo de Café Altura quede huérfano cuando alguien se vaya de vacaciones.

El mapa priorizado

Con horas, créditos y riesgos en la mano, falta lo que Inés quiere saber: "¿por dónde empiezo?". La respuesta clásica es el tiempo de recuperación de la inversión: cuántos meses tarda un flujo en devolver las horas que costó construirlo. Para Café Altura se escribe así:

$$ m = \frac{h_c \cdot c_h}{A - C} $$

• $h_c$ son las horas de construcción del flujo, estimadas por Valeria: $6$ para la confirmación, $10$ para las guías (la API de la paquetería es la pieza más laboriosa), $8$ para el inventario, $6$ para las devoluciones y $8$ para los carritos.
  
• $c_h$ es el valor de la hora, $90$ MXN, así que $h_c \cdot c_h$ es lo que cuesta construir el flujo.
  
• $A$ es el valor mensual que produce: las horas ahorradas por el valor de la hora o, en los carritos, el margen de las ventas recuperadas; $C$ es lo que cuesta el flujo al mes en créditos de Make.
  
• En conclusión, $m$ dice cuántos meses de ahorro neto pagan la construcción: menos de uno significa que el flujo se paga en el primer mes.

Los carritos necesitan una fórmula propia para $A$, porque no ahorran horas, sino que recuperan ventas:

$$ A_{\text{carritos}} = E \cdot p \cdot t \cdot g $$

• $E$ es el número de recordatorios elegibles al mes, los $198$ que dejó el filtro.
  
• $p$ es la tasa de recuperación, la fracción de recordatorios que termina en compra, un supuesto del $6%$ que se pondrá a prueba enseguida.
  
• $t$ es el ticket medio, $540$ MXN, y $g$ el margen bruto del café, un supuesto del $45%$: lo que gana el tostador no es la venta, sino su margen.

El siguiente bloque junta todo: calcula $A$, $C$ y $m$ para cada proceso con el diseño agregado del inventario y los $198$ recordatorios reales, ordena los procesos por meses de recuperación, aplica una regla de prioridad que tiene en cuenta el riesgo, mide la sensibilidad de los carritos a la tasa de recuperación y dibuja el valor neto de cada proceso frente a su riesgo:

# Riesgo, coste en pesos y meses de recuperación por proceso en Python:
valor_hora = perfil['valor_hora_mxn']
mxn_por_credito = usd_por_credito * MXN_POR_USD
TASA_RECUPERACION, MARGEN = 0.06, 0.45                 # supuestos declarados
recuperados = E * TASA_RECUPERACION
margen_carritos = recuperados * perfil['ticket_medio_mxn'] * MARGEN
cred = creditos(R_PLAN, True, recordatorios = E)
mapa = procesos[['proceso', 'H_ahorro', 'dueno']].copy()
mapa['A_mxn'] = mapa['H_ahorro'] * valor_hora
mapa.loc[mapa['proceso'] == 'Carritos abandonados', 'A_mxn'] = round(margen_carritos, 2)
mapa['creditos'] = mapa['proceso'].map(cred)
mapa['C_mxn'] = (mapa['creditos'] * mxn_por_credito).round(2)
mapa['h_construccion'] = [6, 10, 8, 6, 8]
mapa['riesgo'] = [1, 2, 1, 3, 3]
mapa['m_meses'] = (mapa['h_construccion'] * valor_hora / (mapa['A_mxn'] - mapa['C_mxn'])).round(2)
print(f'Carritos: {recuperados:.2f} pedidos recuperados, {recuperados * perfil["ticket_medio_mxn"]:,.2f} MXN '
      f'de ventas y {margen_carritos:,.2f} MXN de margen')
print(mapa.drop(columns = 'dueno').sort_values('m_meses').round(2).to_string(index = False))
print('Créditos del mapa final:', sum(cred.values()), 'de', CUOTA_CORE)

# Regla de prioridad: se paga en menos de un mes, riesgo de 2 o menos, y gana quien libera más horas:
candidatos = mapa[(mapa['m_meses'] < 1) & (mapa['riesgo'] <= 2)].sort_values('H_ahorro', ascending = False)
print('Orden por meses de recuperación:', mapa.sort_values('m_meses')['proceso'].tolist())
print('Orden con la regla de riesgo:', candidatos['proceso'].tolist())

# Sensibilidad de los carritos a la tasa de recuperación:
for tasa in [0.02, 0.04, 0.06, 0.10]:
    margen = E * tasa * perfil['ticket_medio_mxn'] * MARGEN
    c = cred['Carritos abandonados'] * mxn_por_credito
    print(f'  recuperación {tasa:.0%}: margen {margen:,.2f} MXN, m = {8 * valor_hora / (margen - c):.2f} meses')

# Burbujas: valor neto mensual frente a riesgo, tamaño por horas de construcción:
fig, ax = plt.subplots(figsize = (9, 5.5))
neto = mapa['A_mxn'] - mapa['C_mxn']
ax.scatter(mapa['riesgo'], neto, s = mapa['h_construccion'] * 120, color = colores, alpha = 0.75,
           edgecolor = 'white', linewidth = 2)
for (_, fila), v in zip(mapa.iterrows(), neto):
    ax.annotate(f"{fila['proceso']}\nm = {fila['m_meses']:.2f} meses", (fila['riesgo'], v),
                xytext = (22, -4), textcoords = 'offset points', fontsize = 9, va = 'center')
ax.set_xticks([1, 2, 3])
ax.set_xticklabels(['1 bajo', '2 medio', '3 alto'])
ax.set_xlim(0.6, 4.0)
ax.set_ylim(-300, 4_600)
ax.set_xlabel('Riesgo de la automatización')
ax.set_ylabel('Valor neto mensual (MXN)')
ax.set_title('Valor neto frente a riesgo (tamaño: horas de construcción)', fontsize = 16)
ax.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.show()

Carritos: 11.88 pedidos recuperados, 6,415.20 MXN de ventas y 2,886.84 MXN de margen
                       proceso  H_ahorro   A_mxn  creditos  C_mxn  h_construccion  riesgo  m_meses
  Confirmar y registrar pedido     25.83 2325.00      2480  48.59               6       1     0.24
       Guía de envío y rastreo     41.33 3720.00      3100  60.73              10       2     0.25
          Carritos abandonados      0.00 2886.84      1534  30.05               8       3     0.25
Inventario y reorden de tueste     13.43 1209.00      1860  36.44               8       1     0.61
                  Devoluciones      2.53  228.00        76   1.49               6       3     2.38
Créditos del mapa final: 9050 de 10000
Orden por meses de recuperación: ['Confirmar y registrar pedido', 'Guía de envío y rastreo', 'Carritos abandonados', 'Inventario y reorden de tueste', 'Devoluciones']
Orden con la regla de riesgo: ['Guía de envío y rastreo', 'Confirmar y registrar pedido', 'Inventario y reorden de tueste']
  recuperación 2%: margen 962.28 MXN, m = 0.77 meses
  recuperación 4%: margen 1,924.56 MXN, m = 0.38 meses
  recuperación 6%: margen 2,886.84 MXN, m = 0.25 meses
  recuperación 10%: margen 4,811.40 MXN, m = 0.15 meses

Ordenados solo por meses de recuperación, los tres primeros están casi empatados: confirmación $0.24$, guías $0.25$ y carritos $0.25$ meses, es decir, se pagan en una semana. Les siguen el inventario con $0.61$ y las devoluciones con $2.38$. El mapa final consume $9,050$ créditos, dentro de la cuota de Core.

Los carritos recuperarían $11.88$ pedidos al mes, $6,415.20$ MXN de ventas y $2,886.84$ MXN de margen. Con los $282$ recordatorios del plan habrían encabezado la lista; con los $198$ que dejan los filtros, quedan terceros. Y su cifra es la más frágil de todas: si la tasa de recuperación es del $2%$ en lugar del $6%$, el margen baja a $962.28$ MXN y $m$ sube a $0.77$ meses; si es del $10%$, baja a $0.15$. Las horas de guías se midieron con cronómetro; la tasa de recuperación es una suposición que solo un mes real confirmará.

La gráfica de burbujas muestra por qué Valeria no ordena solo por $m$. Las guías están arriba (el mayor valor neto, $3,659.27$ MXN al mes) y en riesgo medio; la confirmación y el inventario, abajo a la izquierda, con poco valor y poco riesgo; los carritos y las devoluciones, a la derecha, en la columna del riesgo alto. Por eso la regla de prioridad tiene dos filtros y un desempate: se automatiza primero lo que se paga en menos de un mes y tiene riesgo $2$ o menor, y entre eso gana lo que libera más horas. El resultado es el orden de la salida: guías, confirmación e inventario.

Así, el mapa de Café Altura queda en tres niveles:

1. Se automatiza (riesgo bajo o medio, recuperación en semanas): guías de envío y rastreo, que libera $41.33$ horas al mes; confirmación y registro de pedidos, con $25.83$; e inventario agregado, con $13.43$. Los tres juntos dan un valor neto de $7,108.24$ MXN al mes por $24$ horas de construcción, $2,160$ MXN.
   
2. Se asiste (la máquina prepara, una persona decide): devoluciones, donde la IA clasifica y redacta y Inés aprueba; y carritos, que se lanzan como piloto de tres meses con la plantilla aprobada por Lucía para medir la tasa de recuperación antes de darla por buena.
   
3. Queda en manos de una persona: cuándo y cuánto tostar, cada reembolso, cada respuesta a una queja y cada entrega fallida.

La especificación del flujo de guías

El primer flujo que se construye es el de guías, y antes de abrir Make se escribe su especificación con la plantilla del Día 18 (Flujos que se dibujan solos: generar automatizaciones con IA): disparador, entradas, pasos, salidas, errores y humanos, más las restricciones. Es el documento que Inés firma y el que, si quisiera, Valeria podría entregar al generador de borradores de ese día. Este es cafe_altura/especificacion_guias_rastreo.json:

{
  "nombre": "CA Guías y rastreo",
  "version": 1,
  "plataforma": "Make",
  "negocio": "Café Altura (ficticio)",
  "disparador": "Webhook de la tienda en línea: pedido pagado y marcado como listo para empacar",
  "entradas": [
    "Pedido: id_pedido, renglones (clave, gramos, cantidad), peso_total_g, fecha_tueste",
    "Envío: nombre, calle_y_numero, colonia, codigo_postal, ciudad, telefono_contacto"
  ],
  "pasos": [
    "Recibir el pedido pagado desde el webhook de la tienda",
    "Solicitar la guía a la API de la paquetería con peso, medidas y dirección de entrega",
    "Escribir el número de rastreo en el pedido de la tienda",
    "Anotar la guía en la hoja Envios con su fecha de creación",
    "Enviar al cliente el aviso de envío con el enlace de rastreo"
  ],
  "creditos_por_pedido": 5,
  "salidas": [
    "Etiqueta PDF de la guía en la cola de impresión de Paco",
    "Pedido de la tienda con numero_rastreo",
    "Hoja Envios: id_pedido, numero_rastreo, paqueteria, creada, estado"
  ],
  "errores": [
    "Tres intentos con 15 minutos de espera ante un 429 o un 5xx de la paquetería",
    "Código postal no reconocido: el pedido pasa a la cola de Lucía sin guía",
    "Si la guía falla tres veces, aviso a Paco y estado pendiente_manual en Envios"
  ],
  "humanos": [
    "Paco revisa el peso real en la báscula y pega la guía en la caja",
    "Lucía corrige direcciones incompletas y atiende entregas fallidas",
    "Inés es la dueña del flujo y aprueba cualquier cambio de paquetería"
  ],
  "restricciones": [
    "La dirección se comparte solo con la paquetería y solo para entregar",
    "Sin claves de la paquetería ni de la tienda en el blueprint: van en las conexiones de Make",
    "El aviso al cliente es transaccional: no lleva promociones ni recomendaciones de productos"
  ]
}

Tres decisiones de la especificación vienen de la tabla de riesgos. Los cinco pasos coinciden con los cinco créditos por pedido que se contaron en la sección anterior: si alguien añade un paso, la cuenta de créditos debe cambiar con él. Los errores distinguen lo pasajero (un 429 o un 5xx de la paquetería, que se reintenta) de lo que necesita a una persona (un código postal que no existe, que va directo a Lucía sin gastar más intentos). Y las restricciones dejan por escrito que la dirección solo viaja a la paquetería y que el aviso al cliente es transaccional, sin promociones: un aviso de envío con una oferta dentro dejaría de ser un mensaje de servicio y pasaría a ser marketing.

El mapa dibujado

El siguiente bloque comprueba la especificación con el mismo espíritu que el validador del Día 18: que estén los seis campos de la plantilla, que el número de pasos coincida con los créditos por pedido y que no haya cadenas que delaten una clave o un dato personal. Después dibuja el mapa de automatización de Café Altura con la función dibujar_flujo del Día 2 y la paleta de formas de la serie: disparadores en óvalo verde, acciones en rectángulo azul, decisiones en rombo naranja, el paso con IA en rectángulo morado, el manejador de error en rojo y las personas en hexágono gris:

# Validación de la especificación y mapa de automatización de Café Altura con patches en Python:
from matplotlib.patches import Ellipse, FancyBboxPatch, Polygon, RegularPolygon, FancyArrowPatch

especificacion = json.loads((cafe / 'especificacion_guias_rastreo.json').read_text(encoding = 'utf-8'))
CAMPOS = ['disparador', 'entradas', 'pasos', 'salidas', 'errores', 'humanos']
faltan = [c for c in CAMPOS if not especificacion.get(c)]
texto_spec = json.dumps(especificacion, ensure_ascii = False).lower()
sospechosos = [p for p in ['api_key', 'token', 'password', 'bearer', '@', 'http'] if p in texto_spec]
print('Campos de la plantilla del Día 18 que faltan:', faltan)
print('Pasos:', len(especificacion['pasos']), '| créditos declarados por pedido:',
      especificacion['creditos_por_pedido'], '| coinciden:', len(especificacion['pasos']) == cred['Guía de envío y rastreo'] / 620)
print('Personas nombradas:', len(especificacion['humanos']), '| cadenas sospechosas:', sospechosos)

FORMAS = {   # paleta de formas de la serie: tipo -> (forma, relleno)
    'disparador': ('ovalo', '#3a9d5d'), 'accion': ('rectangulo', '#2a78d6'),
    'decision': ('rombo', '#eb6834'), 'ia': ('rectangulo', '#7b5ea7'),
    'error': ('rectangulo', '#c8423b'), 'humano': ('hexagono', '#8a8986'),
}

def dibujar_flujo(nodos, aristas, titulo, ancho = 1.9, alto = 0.9):
    fig, ax = plt.subplots(figsize = (13, 7.2))
    for n in nodos:
        forma, color = FORMAS[n['tipo']]
        x, y = n['x'], n['y']
        if forma == 'ovalo':
            figura = Ellipse((x, y), ancho, alto)
        elif forma == 'rombo':
            figura = Polygon([(x - ancho / 2, y), (x, y + alto / 1.4), (x + ancho / 2, y), (x, y - alto / 1.4)])
        elif forma == 'hexagono':
            figura = RegularPolygon((x, y), 6, radius = ancho / 2, orientation = np.pi / 6)
        else:
            figura = FancyBboxPatch((x - ancho / 2, y - alto / 2), ancho, alto, boxstyle = 'round,pad=0.03')
        figura.set_facecolor(color)
        figura.set_edgecolor('white')
        figura.set_linewidth(2)
        ax.add_patch(figura)
        ax.text(x, y, n['texto'], ha = 'center', va = 'center', fontsize = 9, color = 'white')
    posicion = {n['id']: (n['x'], n['y']) for n in nodos}
    for origen, destino, etiqueta in aristas:
        (x1, y1), (x2, y2) = posicion[origen], posicion[destino]
        ax.add_patch(FancyArrowPatch((x1, y1), (x2, y2), arrowstyle = '-|>', mutation_scale = 14,
                                     shrinkA = 40, shrinkB = 42, color = '#52514e', linewidth = 1.4))
        if etiqueta:
            ax.text((x1 + x2) / 2, (y1 + y2) / 2 + 0.2, etiqueta, ha = 'center', fontsize = 8.5,
                    color = '#52514e', bbox = dict(facecolor = 'white', edgecolor = 'none', pad = 1))
    xs, ys = [n['x'] for n in nodos], [n['y'] for n in nodos]
    ax.set_xlim(min(xs) - 1.3, max(xs) + 1.3)
    ax.set_ylim(min(ys) - 1.0, max(ys) + 1.0)
    ax.set_aspect('equal')
    ax.axis('off')
    ax.set_title(titulo, fontsize = 16)
    return fig, ax

nodos = [
    # Fila 1: pedido pagado -> confirmación -> guía -> rastreo -> entrega fallida
    {'id': 'p1', 'tipo': 'disparador', 'texto': 'Pedido pagado\n(webhook)', 'x': 0, 'y': 4.4},
    {'id': 'p2', 'tipo': 'accion', 'texto': 'Registrar y\nconfirmar', 'x': 2.5, 'y': 4.4},
    {'id': 'p3', 'tipo': 'accion', 'texto': 'Solicitar guía\na paquetería', 'x': 5.0, 'y': 4.4},
    {'id': 'p4', 'tipo': 'humano', 'texto': 'Paco pesa\ny pega guía', 'x': 7.5, 'y': 4.4},
    {'id': 'p5', 'tipo': 'decision', 'texto': '¿Entrega\nfallida?', 'x': 10.0, 'y': 4.4},
    {'id': 'p6', 'tipo': 'humano', 'texto': 'Lucía\nreprograma', 'x': 12.5, 'y': 4.4},
    {'id': 'p7', 'tipo': 'error', 'texto': 'Guía falla 3 veces:\naviso a Paco', 'x': 5.0, 'y': 2.9},
    # Fila 2: inventario agregado -> reorden -> Inés
    {'id': 'i1', 'tipo': 'accion', 'texto': 'Restar gramos\n(1 actualización)', 'x': 2.5, 'y': 1.5},
    {'id': 'i2', 'tipo': 'decision', 'texto': '¿Bajo punto\nde reorden?', 'x': 5.0, 'y': 1.5},
    {'id': 'i3', 'tipo': 'humano', 'texto': 'Inés programa\nel tueste', 'x': 7.5, 'y': 1.5},
    # Fila 3: devoluciones con IA que solo clasifica
    {'id': 'd1', 'tipo': 'disparador', 'texto': 'Solicitud de\ndevolución', 'x': 0, 'y': -0.2},
    {'id': 'd2', 'tipo': 'ia', 'texto': 'Clasificar motivo\n(borrador)', 'x': 2.5, 'y': -0.2},
    {'id': 'd3', 'tipo': 'humano', 'texto': 'Inés aprueba\nel reembolso', 'x': 5.0, 'y': -0.2},
    # Fila 4: carritos con consentimiento
    {'id': 'c1', 'tipo': 'disparador', 'texto': 'Carrito\nabandonado', 'x': 7.5, 'y': -0.2},
    {'id': 'c2', 'tipo': 'decision', 'texto': '¿Consiente, sin\ncompra ni baja?', 'x': 10.0, 'y': -0.2},
    {'id': 'c3', 'tipo': 'accion', 'texto': 'Un aviso a las\n24 h con baja', 'x': 12.5, 'y': -0.2},
]
aristas = [('p1', 'p2', ''), ('p2', 'p3', ''), ('p3', 'p4', ''), ('p4', 'p5', ''), ('p5', 'p6', 'sí'),
           ('p3', 'p7', 'error'), ('p2', 'i1', ''), ('i1', 'i2', ''), ('i2', 'i3', 'sí'),
           ('d1', 'd2', ''), ('d2', 'd3', ''), ('c1', 'c2', ''), ('c2', 'c3', 'sí')]
fig, ax = dibujar_flujo(nodos, aristas, 'Mapa de automatización de Café Altura')
tipos = pd.Series([n['tipo'] for n in nodos]).value_counts().to_dict()
print('Nodos por tipo:', tipos)
print('Puertas humanas:', tipos.get('humano', 0), '| pasos con IA:', tipos.get('ia', 0),
      '| decisiones:', tipos.get('decision', 0))
plt.tight_layout()
plt.show()

Campos de la plantilla del Día 18 que faltan: []
Pasos: 5 | créditos declarados por pedido: 5 | coinciden: True
Personas nombradas: 3 | cadenas sospechosas: []
Nodos por tipo: {'accion': 4, 'humano': 4, 'disparador': 3, 'decision': 3, 'error': 1, 'ia': 1}
Puertas humanas: 4 | pasos con IA: 1 | decisiones: 3

La especificación tiene sus seis campos, sus $5$ pasos coinciden con los $5$ créditos por pedido y no contiene ninguna cadena sospechosa. El mapa tiene $16$ nodos: $3$ disparadores, $4$ acciones, $3$ decisiones, $1$ manejador de error, $1$ solo paso con IA y $4$ puertas humanas. La fila de arriba es el camino de cada pedido pagado: confirmación, guía, Paco con la báscula y, si la entrega falla, Lucía. La fila del medio es el inventario, que termina en Inés programando el tueste. Abajo, las devoluciones (la IA clasifica, Inés aprueba) y los carritos (un rombo con los cuatro filtros y un único aviso).

Que el mapa de una tienda en línea con cinco procesos tenga un solo paso con IA no es una falta de ambición. Las guías, la confirmación y el inventario son trabajo de reglas: datos estructurados que van de un sistema a otro. La IA aporta donde hay lenguaje que leer, que en Café Altura son las devoluciones; y aun ahí solo prepara, no decide.

Café Altura frente a Trigo Lento

El ensayo termina como empezó, con la objeción de Don Ernesto. La Figura 2 pone los dos negocios lado a lado recorriendo los cinco pasos del método (inventariar, medir, costear, valorar el riesgo y priorizar), y el último bloque del día los compara con números: el producto, su vida útil, el canal de entrada, el pago, la entrega, el pico, el volumen, las horas a mano y el proceso prioritario. Las cifras de Trigo Lento son las del Día 1 ($468$ encargos, $46.8$ horas a mano y $11.7$ con el objetivo de $1.5$ minutos por encargo):

Figura 2. Dos negocios, un método: Trigo Lento y Café Altura recorren los mismos cinco pasos del mapa (inventariar, medir, costear, valorar el riesgo y priorizar) con respuestas distintas.

# Café Altura frente a Trigo Lento: el mismo método con otras cifras en Python:
horas_ca_antes = procesos['h_antes'].sum()
horas_ca_despues = procesos['h_despues'].sum()
comparativa = pd.DataFrame({
    'Trigo Lento': {'producto': 'Pan de masa madre', 'vida_util': '1 a 3 días', 'entrada': 'WhatsApp 55 %',
                    'pago': 'Al recoger', 'entrega': 'Recogida en mostrador', 'pico': '10:00 a 12:00',
                    'volumen_mes': 468, 'horas_a_mano': 46.8, 'horas_con_flujo': 11.7,
                    'proceso_prioritario': 'Encargos por WhatsApp'},
    'Café Altura': {'producto': 'Café tostado en bolsa', 'vida_util': 'Semanas (fecha de tueste)',
                    'entrada': 'Tienda en línea 70 %', 'pago': 'Anticipado', 'entrega': 'Paquetería',
                    'pico': 'Noche (empaque)', 'volumen_mes': 620, 'horas_a_mano': round(horas_ca_antes, 2),
                    'horas_con_flujo': round(horas_ca_despues, 2), 'proceso_prioritario': candidatos['proceso'].iloc[0]},
})
print(comparativa.to_string())
for negocio in comparativa.columns:
    c = comparativa[negocio]
    print(f"{negocio}: {c['horas_a_mano'] / c['volumen_mes'] * 60:.2f} min por caso hoy, "
          f"{c['horas_con_flujo'] / c['volumen_mes'] * 60:.2f} con flujos, "
          f"reducción {1 - c['horas_con_flujo'] / c['horas_a_mano']:.1%}")

                               Trigo Lento                Café Altura
producto                 Pan de masa madre      Café tostado en bolsa
vida_util                       1 a 3 días  Semanas (fecha de tueste)
entrada                      WhatsApp 55 %       Tienda en línea 70 %
pago                            Al recoger                 Anticipado
entrega              Recogida en mostrador                 Paquetería
pico                         10:00 a 12:00            Noche (empaque)
volumen_mes                            468                        620
horas_a_mano                          46.8                      104.5
horas_con_flujo                       11.7                      21.37
proceso_prioritario  Encargos por WhatsApp    Guía de envío y rastreo
Trigo Lento: 6.00 min por caso hoy, 1.50 con flujos, reducción 75.0%
Café Altura: 10.11 min por caso hoy, 2.07 con flujos, reducción 79.6%

La Tabla 5 recoge la comparación. Café Altura dedica más tiempo por caso que Trigo Lento ($10.11$ minutos frente a $6.00$) y lo reduce un poco más con los flujos ($79.6%$ frente a $75.0%$), porque sus procesos son más mecánicos: copiar una dirección a un portal se automatiza mejor que entender un encargo de pastel con nombre y dedicatoria.

Tabla 5. Café Altura frente a Trigo Lento: producto, vida útil, canal de entrada, pago, entrega, pico, volumen, horas manuales y proceso prioritario.

Las diferencias explican por qué Don Ernesto tenía razón en la mitad que importa:

• Perecedero frente a vida de anaquel. El pan obliga a que el encargo llegue a tiempo al obrador; el café permite inventario, y por eso Café Altura tiene un proceso de reorden que Trigo Lento no necesita en esa forma.
  
• Recogida frente a envío. En la panadería no hay guías ni rastreo; el cliente viene. El proceso que más horas le cuesta al tostador simplemente no existe en el mostrador de Narvarte.
  
• Pago anticipado frente a pago al recoger. Café Altura nunca empieza a trabajar un pedido sin cobrarlo; Trigo Lento hornea pasteles que a veces nadie recoge, como el de zanahoria del Día 13.
  
• Canales y picos. La tienda recibe pedidos estructurados por su web; la panadería, mensajes en lenguaje natural por WhatsApp. Por eso Trigo Lento necesita IA para entender el encargo, y Café Altura casi no.

Lo que viaja al Día 21 no son las cifras, sino tres piezas del método: la secuencia de pasos (inventariar, medir, costear, valorar el riesgo y priorizar), la tabla de créditos por proceso con su fórmula $K = \sum_i n_i k_i$, y la columna de riesgo con el paso humano obligatorio. Lo que no viaja son los carritos: en un encargo por WhatsApp no hay carrito. Su análogo en Trigo Lento son las conversaciones sin cerrar, la clienta que preguntó el precio del pastel de chocolate y no volvió a escribir; y la regla que se traslada es la de hoy: a lo sumo un mensaje, solo dentro de la conversación que ella empezó y nunca como campaña.

Don Ernesto mira la tabla un rato largo y concede, a su manera: “Bueno. Peras y hogazas no, pero las dos se pesan en la misma báscula.” Es la mejor definición del método que nadie ha dado en la serie.

Consideraciones finales

El ensayo en Café Altura deja tres lecciones que no habrían aparecido mirando solo la panadería. La primera es que el proceso que más duele no siempre es el que más cuesta: Inés hablaba de las devoluciones y de los “¿dónde viene mi paquete?”, y el cronómetro dijo que la mitad de las horas estaban en copiar guías. La segunda es que el diseño de un flujo cambia su factura más que el plan contratado: el mismo mapa cabe o no cabe en Make Core según haya o no un iterador en el inventario. La tercera es que la ética cambia los números, y los cambia a mejor: el filtro de consentimiento bajó los recordatorios de $282$ a $198$, y con ello quitó a los carritos del primer lugar de una lista que, sin filtro, habría empezado por el proceso más arriesgado y peor medido.

Las limitaciones conviene decirlas igual de claro. Café Altura es inventada, y con ella todos sus minutos, la tasa de abandono, el $43%$ de consentimiento, la recuperación del $6%$, el margen del $45%$ y las horas de construcción. El valor de la hora mide el tiempo, no el cansancio de Paco a medianoche, que no sale en ninguna columna. La fórmula de recuperación ignora el mantenimiento: un flujo que se rompe cuando la paquetería cambia su API cuesta horas que hoy no se cuentan, y el Día 19 mostró cuánto se acumulan. Y las comisiones de las plataformas cambian con frecuencia: la propia Tiendanube publica dos versiones distintas de las suyas.

Antes de pasar al Día 21, conviene que usted se haga algunas preguntas sobre una tienda en línea que conozca, o sobre la suya:

• ¿Cuál de sus procesos concentra la mitad de las horas a mano? ¿Lo ha medido con cronómetro o lo supone?
  
• ¿Alguno de sus flujos usa un iterador que multiplica su coste por el tamaño de cada pedido?
  
• ¿A quién le envía hoy los recordatorios de carrito, cuántas veces, y puede demostrar que cada persona dio su consentimiento?
  
• ¿Qué decisiones de su tienda, como reembolsar o responder una queja, no debe tomar nunca un flujo?

Un gran libro que habla de esto es Supply Chain Management: Strategy, Planning, and Operation (o Administración de la cadena de suministro: estrategia, planeación y operación), de Sunil Chopra y Peter Meindl. Sus capítulos sobre el diseño de redes de distribución explican, con números, por qué vender en línea con envío a domicilio cambia los costes de inventario, de transporte y de información frente a la venta en tienda, que es justo la diferencia entre Café Altura y Trigo Lento. Leerlo ayuda a ver que un mapa de automatización no es una lista de tareas aburridas, sino el sistema nervioso de una cadena de suministro pequeña.

Un mapa de automatización no ordena lo que se puede automatizar, sino lo que conviene automatizar primero: horas medidas, créditos contados, riesgos con nombre y una persona en cada puerta que mueve dinero o reputación. Hoy Café Altura tiene su mapa: tres flujos que se pagan en semanas, dos procesos asistidos y una lista de decisiones que siguen siendo de Inés. Y Valeria tiene la práctica que necesitaba para dibujar mañana el de su propia casa.

Conclusiones clave

Método del mapa

• El mapa empieza por los procesos, no por las herramientas: en una tienda en línea son cinco (pedidos, inventario, envíos, devoluciones y carritos), cada uno con lo que entra, lo que sale, su dueño y lo que falla.
  
• Café Altura dedica $104.50$ horas al mes a mano; con $H = n (t_a - t_d) / 60$, los flujos ahorrarían $83.13$ horas, $7,482.00$ MXN al mes a $90$ MXN la hora.
  
• Las guías de envío son el $49.4%$ de las horas a mano y, con la confirmación, el $79.1%$: el Pareto señala dónde está el trabajo, no dónde está la queja.

Costes y riesgos

• Vender en línea le cuesta al tostador entre $13,929.50$ y $21,212.02$ MXN al mes en comisiones; todo Make Core, $195.92$ MXN, el $0.06%$ de las ventas.
  
• Con un iterador en el inventario el mapa pide $10,914$ créditos frente a los $10,000$ de Core; con una actualización agregada, $9,302$, y $9,050$ con los recordatorios reales.
  
• Con $m = h_c c_h / (A - C)$, confirmación ($0.24$), guías ($0.25$) y carritos ($0.25$) se pagan en una semana; la regla de riesgo deja primero a guías, confirmación e inventario, y deja asistidas las devoluciones y los carritos.
  
• El reembolso y la respuesta a una queja los decide Inés; la IA solo clasifica y redacta un borrador.

Lo que viaja a Trigo Lento

• El consentimiento recortó los recordatorios de carrito de $282$ a $198$, el $21.1%$ de los carritos: un aviso, a las $24$ horas, con baja inmediata y nunca a anónimos.
  
• Del Día 20 al Día 21 viajan la secuencia del método, la tabla de créditos y la columna de riesgo con su paso humano; no viajan las cifras.
  
• El análogo de los carritos en Trigo Lento son las conversaciones sin cerrar, y la regla es la misma: a lo sumo un mensaje, dentro de la conversación que empezó el cliente.

Mañana, en el Día 21: Sesión práctica: el mapa de automatización de Trigo Lento. Con el método ensayado en Café Altura, Valeria inventariará doce procesos de la panadería, los priorizará por valor, esfuerzo y riesgo, asignará cada uno a Make, a n8n, a Python o a una persona, revisará el presupuesto de $45$ USD al mes y publicará el primer flujo real de Trigo Lento, TL Formulario v1; lo que no pase la prueba se quedará, como la masa madre, en manos de una persona.

Referencias

1. Dumas, M., La Rosa, M., Mendling, J. y Reijers, H. A. (2018). Fundamentals of Business Process Management (2.ª ed.). Springer. https://doi.org/10.1007/978-3-662-56509-4
   
2. Chopra, S. y Meindl, P. (2016). Supply Chain Management: Strategy, Planning, and Operation (6.ª ed.). Pearson.
   
3. Rogers, D. S. y Tibben-Lembke, R. S. (1999). Going Backwards: Reverse Logistics Trends and Practices. Reverse Logistics Executive Council.
   
4. Baymard Institute (2026). Cart Abandonment Rate Statistics. https://baymard.com/lists/cart-abandonment-rate
   
5. Cámara de Diputados del H. Congreso de la Unión (2026). Ley Federal de Protección al Consumidor (texto vigente). https://www.diputados.gob.mx/LeyesBiblio/
   
6. Shopify (2026). Planes y precios (México). https://www.shopify.com/mx/precios
   
7. Mercado Pago (2026). Link de pago: costos. https://www.mercadopago.com.mx/herramientas-para-vender/link-de-pago
   
8. Stripe (2026). Tarifas (México). https://stripe.com/mx/pricing
   
9. Tiendanube (2026). Costos por transacción. Centro de Atención. https://ayuda.tiendanube.com/es_MX/123484-costos-por-transaccion/como-se-calculan-los-costos-por-transaccion
   
10. Make (2026). Pricing. https://www.make.com/en/pricing