-- sincronización de stock por bodega
CREATE PROCEDURE sp_sync_stock
  @desde datetime
AS
BEGIN
  SET NOCOUNT ON;

  SELECT a.cod_prod,
         b.cod_bodega,
         SUM(b.stock_fisico) AS stock,
         GETDATE() AS sincronizado
  FROM   mae_producto a
  JOIN   mov_bodega  b ON b.cod_prod = a.cod_prod
  WHERE  a.activo = 'S'
    AND  b.fecha_mov >= @desde
  GROUP BY a.cod_prod, b.cod_bodega
  HAVING   SUM(b.stock_fisico) > 0;

  -- bitácora con reintento
  INSERT INTO backoffice_sync_log
        (entidad, referencia, estado, intento, ts)
  VALUES ('stock', @desde, 'OK', 1, GETDATE());
END
GO

-- índice para no bloquear en horario laboral
CREATE NONCLUSTERED INDEX ix_mov_bodega_fecha
  ON mov_bodega (fecha_mov) INCLUDE (cod_prod, stock_fisico);


-- sincronización de stock por bodega
CREATE PROCEDURE sp_sync_stock
  @desde datetime
AS
BEGIN
  SET NOCOUNT ON;

  SELECT a.cod_prod,
         b.cod_bodega,
         SUM(b.stock_fisico) AS stock,
         GETDATE() AS sincronizado
  FROM   mae_producto a
  JOIN   mov_bodega  b ON b.cod_prod = a.cod_prod
  WHERE  a.activo = 'S'
    AND  b.fecha_mov >= @desde
  GROUP BY a.cod_prod, b.cod_bodega
  HAVING   SUM(b.stock_fisico) > 0;

  -- bitácora con reintento
  INSERT INTO backoffice_sync_log
        (entidad, referencia, estado, intento, ts)
  VALUES ('stock', @desde, 'OK', 1, GETDATE());
END
GO

-- índice para no bloquear en horario laboral
CREATE NONCLUSTERED INDEX ix_mov_bodega_fecha
  ON mov_bodega (fecha_mov) INCLUDE (cod_prod, stock_fisico);

// worker de sincronización Softland → web
import { sql } from './mssql';
import { db }  from './postgres';

type SyncResult = {
  entidad: string;
  registros: number;
  ms: number;
};

export async function syncStock(): Promise<SyncResult> {
  const t0 = performance.now();
  const filas = await sql.query('EXEC sp_sync_stock @desde', {
    desde: lastRun('stock'),
  });

  await db.transaction(async (trx) => {
    for (const f of filas) {
      await trx('productos')
        .insert({ sku: f.cod_prod, stock: f.stock })
        .onConflict('sku')
        .merge();
    }
  });

  return {
    entidad: 'stock',
    registros: filas.length,
    ms: Math.round(performance.now() - t0),
  };
}


// worker de sincronización Softland → web
import { sql } from './mssql';
import { db }  from './postgres';

type SyncResult = {
  entidad: string;
  registros: number;
  ms: number;
};

export async function syncStock(): Promise<SyncResult> {
  const t0 = performance.now();
  const filas = await sql.query('EXEC sp_sync_stock @desde', {
    desde: lastRun('stock'),
  });

  await db.transaction(async (trx) => {
    for (const f of filas) {
      await trx('productos')
        .insert({ sku: f.cod_prod, stock: f.stock })
        .onConflict('sku')
        .merge();
    }
  });

  return {
    entidad: 'stock',
    registros: filas.length,
    ms: Math.round(performance.now() - t0),
  };
}

// conciliación de cartolas bancarias
export async function conciliar(cartola: Movimiento[]) {
  const pendientes = await cuentasPorCobrar();

  for (const mov of cartola) {
    const calce = pendientes.find((c) =>
      c.monto === mov.abono && c.rut === mov.rut);

    if (calce) {
      await aplicarPago(calce.documento, mov.fecha);
    } else {
      await dejarPendiente(mov, 'sin calce automático');
    }
  }
}

-- movimientos sin conciliar
SELECT fecha, glosa, abono, rut_cliente
FROM   banco_movimiento
WHERE  conciliado = 'N'
ORDER BY fecha DESC;


// conciliación de cartolas bancarias
export async function conciliar(cartola: Movimiento[]) {
  const pendientes = await cuentasPorCobrar();

  for (const mov of cartola) {
    const calce = pendientes.find((c) =>
      c.monto === mov.abono && c.rut === mov.rut);

    if (calce) {
      await aplicarPago(calce.documento, mov.fecha);
    } else {
      await dejarPendiente(mov, 'sin calce automático');
    }
  }
}

-- movimientos sin conciliar
SELECT fecha, glosa, abono, rut_cliente
FROM   banco_movimiento
WHERE  conciliado = 'N'
ORDER BY fecha DESC;

Inicio/Casos/Nos pidieron una tienda. Lo que faltaba era sacar al ERP de su aislamiento.

Distribución mayorista

Nos pidieron una tienda. Lo que faltaba era sacar al ERP de su aislamiento.

Distribuidora mayorista, Región Metropolitana · 2026

-- sincronización de stock por bodega
CREATE PROCEDURE sp_sync_stock
  @desde datetime
AS
BEGIN
  SET NOCOUNT ON;

  SELECT a.cod_prod,
         b.cod_bodega,
         SUM(b.stock_fisico) AS stock,
         GETDATE() AS sincronizado
  FROM   mae_producto a
  JOIN   mov_bodega  b ON b.cod_prod = a.cod_prod
  WHERE  a.activo = 'S'
    AND  b.fecha_mov >= @desde
  GROUP BY a.cod_prod, b.cod_bodega
  HAVING   SUM(b.stock_fisico) > 0;

  -- bitácora con reintento
  INSERT INTO backoffice_sync_log
        (entidad, referencia, estado, intento, ts)
  VALUES ('stock', @desde, 'OK', 1, GETDATE());
END
GO

-- índice para no bloquear en horario laboral
CREATE NONCLUSTERED INDEX ix_mov_bodega_fecha
  ON mov_bodega (fecha_mov) INCLUDE (cod_prod, stock_fisico);


-- sincronización de stock por bodega
CREATE PROCEDURE sp_sync_stock
  @desde datetime
AS
BEGIN
  SET NOCOUNT ON;

  SELECT a.cod_prod,
         b.cod_bodega,
         SUM(b.stock_fisico) AS stock,
         GETDATE() AS sincronizado
  FROM   mae_producto a
  JOIN   mov_bodega  b ON b.cod_prod = a.cod_prod
  WHERE  a.activo = 'S'
    AND  b.fecha_mov >= @desde
  GROUP BY a.cod_prod, b.cod_bodega
  HAVING   SUM(b.stock_fisico) > 0;

  -- bitácora con reintento
  INSERT INTO backoffice_sync_log
        (entidad, referencia, estado, intento, ts)
  VALUES ('stock', @desde, 'OK', 1, GETDATE());
END
GO

-- índice para no bloquear en horario laboral
CREATE NONCLUSTERED INDEX ix_mov_bodega_fecha
  ON mov_bodega (fecha_mov) INCLUDE (cod_prod, stock_fisico);

// worker de sincronización Softland → web
import { sql } from './mssql';
import { db }  from './postgres';

type SyncResult = {
  entidad: string;
  registros: number;
  ms: number;
};

export async function syncStock(): Promise<SyncResult> {
  const t0 = performance.now();
  const filas = await sql.query('EXEC sp_sync_stock @desde', {
    desde: lastRun('stock'),
  });

  await db.transaction(async (trx) => {
    for (const f of filas) {
      await trx('productos')
        .insert({ sku: f.cod_prod, stock: f.stock })
        .onConflict('sku')
        .merge();
    }
  });

  return {
    entidad: 'stock',
    registros: filas.length,
    ms: Math.round(performance.now() - t0),
  };
}


// worker de sincronización Softland → web
import { sql } from './mssql';
import { db }  from './postgres';

type SyncResult = {
  entidad: string;
  registros: number;
  ms: number;
};

export async function syncStock(): Promise<SyncResult> {
  const t0 = performance.now();
  const filas = await sql.query('EXEC sp_sync_stock @desde', {
    desde: lastRun('stock'),
  });

  await db.transaction(async (trx) => {
    for (const f of filas) {
      await trx('productos')
        .insert({ sku: f.cod_prod, stock: f.stock })
        .onConflict('sku')
        .merge();
    }
  });

  return {
    entidad: 'stock',
    registros: filas.length,
    ms: Math.round(performance.now() - t0),
  };
}

// conciliación de cartolas bancarias
export async function conciliar(cartola: Movimiento[]) {
  const pendientes = await cuentasPorCobrar();

  for (const mov of cartola) {
    const calce = pendientes.find((c) =>
      c.monto === mov.abono && c.rut === mov.rut);

    if (calce) {
      await aplicarPago(calce.documento, mov.fecha);
    } else {
      await dejarPendiente(mov, 'sin calce automático');
    }
  }
}

-- movimientos sin conciliar
SELECT fecha, glosa, abono, rut_cliente
FROM   banco_movimiento
WHERE  conciliado = 'N'
ORDER BY fecha DESC;


// conciliación de cartolas bancarias
export async function conciliar(cartola: Movimiento[]) {
  const pendientes = await cuentasPorCobrar();

  for (const mov of cartola) {
    const calce = pendientes.find((c) =>
      c.monto === mov.abono && c.rut === mov.rut);

    if (calce) {
      await aplicarPago(calce.documento, mov.fecha);
    } else {
      await dejarPendiente(mov, 'sin calce automático');
    }
  }
}

-- movimientos sin conciliar
SELECT fecha, glosa, abono, rut_cliente
FROM   banco_movimiento
WHERE  conciliado = 'N'
ORDER BY fecha DESC;

<10seg

Desfase con el ERP

Pedidos digitados a mano

Base de clientes, no dos

100%

Acciones con registro

El punto de partida

Tres manos para un mismo pedido

La empresa vende a otras empresas. Cientos de clientes mayoristas, cada uno con su lista de precios y sus condiciones comerciales negociadas. Todo eso vivía en Softland y en la cabeza de los vendedores.

El pedido llegaba por correo o WhatsApp

Sin formato, sin códigos de producto, muchas veces con el nombre comercial y no el del catálogo.

Alguien revisaba precio y stock a mano

Abría Softland, buscaba las condiciones de ese cliente, confirmaba disponibilidad y respondía.

Y después lo digitaba de nuevo en el ERP

Tercera vez que el mismo pedido se escribía. Cada paso, una oportunidad de equivocarse.

El encargo original era construir una tienda en línea. Pero una tienda que no conoce las condiciones comerciales de cada cliente no le sirve a nadie en un negocio mayorista.

El problema real no era la falta de vitrina. Era que el ERP no conversaba con nada.

La solución

Cinco piezas, no una tienda

Portal B2B con condiciones por cliente

Cada cliente entra con su cuenta y ve su lista de precios, sus descuentos y su crédito disponible. No un precio genérico de vitrina.

Sincronización con el ERP en segundos

No es un proceso nocturno ni una carga cada hora. Cuando algo cambia en Softland, el portal lo sabe casi de inmediato.

Ficha de cliente alimentada desde el ERP

Una sola base de clientes. El vendedor ve historial de compra, documentos y saldos sin salir del portal ni mantener datos duplicados.

Permisos por usuario y por rol

Un vendedor ve su cartera. Un jefe ve la de su equipo. Un cliente ve lo suyo. Nadie ve de más.

Registro de cada acción relevante

Quién hizo qué, sobre qué registro y a qué hora. En su momento pareció un detalle de implementación. No lo era.

La decisión técnica

Por qué no consultamos el ERP en cada visita

Es la salida obvia y es la que rompe todo. Si cada visitante consulta Softland directamente, la tienda deja lento al ERP y con él a la empresa completa.

Tampoco quisimos el otro extremo, que es una carga nocturna y aceptar que el portal vaya un día atrasado.

La solución fue que el ERP avise cuando algo cambia, en vez de que el portal pregunte todo el tiempo.

El flujo

1. Cambia un precio, un producto o un cliente en Softland

2. El cambio queda anotado en una cola de salida

3. Un proceso lee solo esa cola, no las tablas del ERP

4. El portal se actualiza en segundos, sin tocar Softland

La cola es liviana: solo tiene lo que cambió. El ERP nunca recibe la carga del portal.

Si algo falla, el registro queda en la cola y se reintenta. Nada se pierde en silencio, que es exactamente lo que pasa cuando una integración se hace con exportaciones manuales.

Meses después

El incidente que probó la arquitectura

Llegó el reporte por WhatsApp: a varios clientes se les estaba vaciando el carrito de compras. Pedidos armados que desaparecían.

La sospecha inmediata fue la de siempre: un proceso automático borrando datos, un error del sistema, una tarea programada mal configurada.

Ese tipo de sospecha es difícil de refutar. Se puede pasar semanas revisando código buscando algo que quizás no existe.

Lo que permitió el registro

Revisar el histórico completo de eliminaciones de las últimas semanas
Identificar quién ejecutó cada acción y a qué hora exacta
Descartar con evidencia la existencia de cualquier proceso automático
Analizar caso por caso los clientes reportados

La conclusión fue clara y verificable: no existía ningún proceso que borrara carritos por su cuenta. Cada carrito desaparecido tenía un responsable identificable y una hora exacta. Eran acciones humanas explícitas, hechas desde la interfaz, por usuarios con permiso para hacerlo.

Entregamos un informe con la evidencia, el detalle por cliente y las hipótesis ordenadas por probabilidad. La conversación pasó de buscar un fantasma en el código a revisar cómo el equipo estaba usando una funcionalidad.

Sin ese registro, la respuesta habría sido una opinión. Con él, fue un hecho.

Lo que nos llevamos

La trazabilidad no se agrega después

Cuando se cotiza una integración, el registro de acciones suele ser lo primero que se recorta. No se ve, no se demuestra en una reunión y nadie lo pide.

Hasta que algo no cuadra. Y entonces es lo único que separa una respuesta con evidencia de una discusión sobre quién tiene la culpa.

En este proyecto se decidió incluirlo desde el diseño, sin que el cliente lo pidiera. Meses después fue lo que resolvió el único incidente serio que tuvo el sistema.

Antes de firmar

Tres preguntas para tu próxima integración

¿Cómo se entera el portal de que algo cambió en el ERP?
Si la respuesta es que pregunta cada vez, vas a dejar lento al ERP.

¿Qué pasa si una sincronización falla?
Si no hay cola ni reintento, el dato se pierde y nadie se entera.

¿Queda registro de quién hace cada acción?
El día que algo no cuadre, es lo único que te va a dar una respuesta.

-- sincronización de stock por bodega
CREATE PROCEDURE sp_sync_stock
  @desde datetime
AS
BEGIN
  SET NOCOUNT ON;

  SELECT a.cod_prod,
         b.cod_bodega,
         SUM(b.stock_fisico) AS stock,
         GETDATE() AS sincronizado
  FROM   mae_producto a
  JOIN   mov_bodega  b ON b.cod_prod = a.cod_prod
  WHERE  a.activo = 'S'
    AND  b.fecha_mov >= @desde
  GROUP BY a.cod_prod, b.cod_bodega
  HAVING   SUM(b.stock_fisico) > 0;

  -- bitácora con reintento
  INSERT INTO backoffice_sync_log
        (entidad, referencia, estado, intento, ts)
  VALUES ('stock', @desde, 'OK', 1, GETDATE());
END
GO

-- índice para no bloquear en horario laboral
CREATE NONCLUSTERED INDEX ix_mov_bodega_fecha
  ON mov_bodega (fecha_mov) INCLUDE (cod_prod, stock_fisico);


-- sincronización de stock por bodega
CREATE PROCEDURE sp_sync_stock
  @desde datetime
AS
BEGIN
  SET NOCOUNT ON;

  SELECT a.cod_prod,
         b.cod_bodega,
         SUM(b.stock_fisico) AS stock,
         GETDATE() AS sincronizado
  FROM   mae_producto a
  JOIN   mov_bodega  b ON b.cod_prod = a.cod_prod
  WHERE  a.activo = 'S'
    AND  b.fecha_mov >= @desde
  GROUP BY a.cod_prod, b.cod_bodega
  HAVING   SUM(b.stock_fisico) > 0;

  -- bitácora con reintento
  INSERT INTO backoffice_sync_log
        (entidad, referencia, estado, intento, ts)
  VALUES ('stock', @desde, 'OK', 1, GETDATE());
END
GO

-- índice para no bloquear en horario laboral
CREATE NONCLUSTERED INDEX ix_mov_bodega_fecha
  ON mov_bodega (fecha_mov) INCLUDE (cod_prod, stock_fisico);

// worker de sincronización Softland → web
import { sql } from './mssql';
import { db }  from './postgres';

type SyncResult = {
  entidad: string;
  registros: number;
  ms: number;
};

export async function syncStock(): Promise<SyncResult> {
  const t0 = performance.now();
  const filas = await sql.query('EXEC sp_sync_stock @desde', {
    desde: lastRun('stock'),
  });

  await db.transaction(async (trx) => {
    for (const f of filas) {
      await trx('productos')
        .insert({ sku: f.cod_prod, stock: f.stock })
        .onConflict('sku')
        .merge();
    }
  });

  return {
    entidad: 'stock',
    registros: filas.length,
    ms: Math.round(performance.now() - t0),
  };
}


// worker de sincronización Softland → web
import { sql } from './mssql';
import { db }  from './postgres';

type SyncResult = {
  entidad: string;
  registros: number;
  ms: number;
};

export async function syncStock(): Promise<SyncResult> {
  const t0 = performance.now();
  const filas = await sql.query('EXEC sp_sync_stock @desde', {
    desde: lastRun('stock'),
  });

  await db.transaction(async (trx) => {
    for (const f of filas) {
      await trx('productos')
        .insert({ sku: f.cod_prod, stock: f.stock })
        .onConflict('sku')
        .merge();
    }
  });

  return {
    entidad: 'stock',
    registros: filas.length,
    ms: Math.round(performance.now() - t0),
  };
}

// conciliación de cartolas bancarias
export async function conciliar(cartola: Movimiento[]) {
  const pendientes = await cuentasPorCobrar();

  for (const mov of cartola) {
    const calce = pendientes.find((c) =>
      c.monto === mov.abono && c.rut === mov.rut);

    if (calce) {
      await aplicarPago(calce.documento, mov.fecha);
    } else {
      await dejarPendiente(mov, 'sin calce automático');
    }
  }
}

-- movimientos sin conciliar
SELECT fecha, glosa, abono, rut_cliente
FROM   banco_movimiento
WHERE  conciliado = 'N'
ORDER BY fecha DESC;


// conciliación de cartolas bancarias
export async function conciliar(cartola: Movimiento[]) {
  const pendientes = await cuentasPorCobrar();

  for (const mov of cartola) {
    const calce = pendientes.find((c) =>
      c.monto === mov.abono && c.rut === mov.rut);

    if (calce) {
      await aplicarPago(calce.documento, mov.fecha);
    } else {
      await dejarPendiente(mov, 'sin calce automático');
    }
  }
}

-- movimientos sin conciliar
SELECT fecha, glosa, abono, rut_cliente
FROM   banco_movimiento
WHERE  conciliado = 'N'
ORDER BY fecha DESC;

Primer paso

Cuéntanos qué proceso te está costando caro

Una reunión de 30 minutos. Revisamos tu requerimiento y te decimos si tiene solución, cuánto demora y cuánto cuesta. Si no podemos ayudarte, también te lo decimos.

Escribir por WhatsApp