Cloud y automatización

Patrones de diseño para data engineering: patrones prácticos para plataformas de datos confiables

Una guía práctica de patrones de diseño aplicados a data engineering: ingesta, transformación, orquestación, almacenamiento, confiabilidad y serving.

Por JaviPublicado 17 min de lecturaIntermedio

En este artículo

Cuando los desarrolladores oyen hablar de patrones de diseño, suelen pensar en patrones de software como Factory, Strategy, Observer o Repository.

Esos patrones siguen siendo útiles en los sistemas de datos, pero el data engineering tiene sus propios problemas recurrentes:

  • ingerir datos desde fuentes poco confiables;
  • procesar más de una vez el mismo archivo o evento;
  • detectar solo lo que cambió;
  • separar los datos sin procesar de los datos confiables;
  • gestionar registros incorrectos sin detener todo un pipeline;
  • reintentar de forma segura tras errores transitorios;
  • reconstruir tablas posteriores sin corromper el historial;
  • servir el mismo conjunto de datos a distintos consumidores;
  • mantener transformaciones comprensibles a medida que crece la plataforma.

Estos problemas se repiten en tecnologías como SQL Server, Microsoft Fabric, Spark, Delta Lake, Kafka, APIs, warehouses y lakehouses.

Eso los convierte en buenos candidatos para patrones.

Un patrón de diseño no es una funcionalidad de un producto ni una arquitectura obligatoria. Es una forma de solución reutilizable para un problema que aparece una y otra vez.

Este artículo se centra en patrones prácticos que se pueden aplicar en cualquier plataforma de datos.

Los patrones de datos no son patrones de diseño de software

Un patrón de software suele describir cómo colaboran clases u objetos.

Un patrón de data engineering suele describir cómo los datos se mueven, cambian, fallan, se recuperan y se vuelven consumibles.

  1. Origen
  2. Sin procesar
  3. Validada
  4. Curada
  5. Serving
Del origen al serving

No es un patrón de diseño orientado a objetos. Aun así, es un patrón, porque la misma separación resuelve el mismo tipo de problema en muchos sistemas.

Los patrones de datos más útiles suelen agruparse en seis categorías:

  1. ingesta;
  2. transformación;
  3. orquestación;
  4. almacenamiento y modelado;
  5. confiabilidad;
  6. serving e integración.

Lo importante no es memorizar nombres. Lo importante es reconocer el problema que resuelve cada patrón.

1. Procesamiento idempotente

Si tuviera que elegir un solo patrón que todo data engineer en producción debería entender, sería la idempotencia.

Una operación es idempotente cuando ejecutarla de nuevo con la misma entrada produce el mismo estado final.

Eso importa porque los pipelines fallan.

Un job puede agotar el tiempo de espera después de escribir datos, perder su confirmación, ser reintentado por un orquestador, recibir dos veces el mismo archivo, recibir un evento duplicado o ser relanzado manualmente.

Sin idempotencia, los reintentos pueden crear datos duplicados.

Una clave de negocio o de ingesta estable puede basarse en:

source_file + source_row_id

o:

event_id

o:

tenant_id + order_id + event_timestamp

Después, aplica la regla de que una misma entrada lógica no puede crear otra copia lógica.

La implementación exacta puede ser una restricción de unicidad, MERGE, INSERT ... WHERE NOT EXISTS, un merge de Delta o un paso de deduplicación.

Lo importante es el patrón:

Un reintento debe ser seguro.

No confundas unicidad técnica con unicidad de negocio. Un ID de fila generado no evita eventos de negocio duplicados si cada reintento genera un ID nuevo.

2. Carga incremental

Una recarga completa es sencilla:

  1. Borrar todo
  2. Recargar todo
Recarga completa

También puede volverse extremadamente costosa.

El patrón de carga incremental procesa solo los registros nuevos o modificados desde la ejecución correcta anterior.

Algunos indicadores de cambio habituales:

  • updated_at;
  • una identidad creciente;
  • un número de secuencia de la fuente;
  • change tracking;
  • captura de datos de cambios (CDC);
  • una posición en el log de transacciones;
  • la hora de llegada de los archivos;
  • un watermark.

Un flujo de watermark habitual se ve así:

  1. 1Leer el último watermark correcto
  2. 2Leer filas de origen posteriores al watermark
  3. 3Transformar
  4. 4Escribir el destino
  5. 5Confirmar el nuevo watermark
Carga incremental con watermark

La palabra clave es correcto. El watermark solo debe avanzar cuando los datos correspondientes se hayan confirmado de forma segura.

Una marca de tiempo sola también puede ser peligrosa. Si varios registros comparten la misma marca de tiempo, un watermark más seguro puede incluir un criterio de desempate como (updated_at, primary_key).

3. Change Data Capture

Las cargas incrementales responden a la pregunta: ¿qué cambió desde mi ejecución anterior?

Change Data Capture, o CDC, va más allá: representa los cambios de la fuente como un flujo de inserciones, actualizaciones y eliminaciones.

INSERT customer 42
UPDATE customer 42
DELETE customer 17

Es útil para la replicación operativa, la analítica casi en tiempo real, las arquitecturas orientadas a eventos, la ingesta en un lakehouse y para mantener sincronizados los almacenes de serving.

El CDC también introduce nuevas responsabilidades de ingeniería:

  • el orden;
  • los duplicados;
  • las eliminaciones;
  • los cambios de esquema;
  • los checkpoints;
  • la reproducción;
  • los eventos tardíos.

El CDC no elimina la complejidad. Acerca la detección de cambios a la fuente y hace explícito el historial de cambios.

4. Capas sin procesar → validada → curada

Uno de los patrones de plataforma más comunes consiste en separar los datos por nivel de confianza.

Los nombres exactos varían:

    1. Sin procesar
    2. Limpia
    3. Curada
    1. Bronze
    2. Silver
    3. Gold
    1. Aterrizaje
    2. Estandarizada
    3. Serving
Nombres habituales de las tres capas

Los nombres importan menos que las responsabilidades.

La capa sin procesar conserva lo que llegó. La capa validada normaliza tipos, aplica controles de calidad, deduplica y estandariza claves. La capa curada da forma a los datos para analítica, APIs, informes, machine learning o consumo por dominio.

Esta separación aporta algo extremadamente valioso: la reproducibilidad.

Si cambia una regla de transformación, a menudo puedes reconstruir las capas confiables a partir de los datos sin procesar conservados, en lugar de pedir a la fuente que vuelva a enviar el historial.

No crees tres capas porque un diagrama te lo dijo. Si cada capa simplemente copia la anterior sin añadir ninguna responsabilidad, has creado sobrecarga, no arquitectura.

5. Patrón de cuarentena / dead-letter

Los datos de producción rara vez son perfectos.

Un pipeline frágil trata una fila incorrecta así:

  1. 1 fila no válida
  2. Falla todo el lote
Frágil: una fila no válida hace fallar el lote

Un patrón más resiliente separa los registros no válidos.

  1. Registros entrantes
  2. Validar
    • válidos
      Destino
    • no válidos
      Cuarentena
Patrón de cuarentena

El registro en cuarentena debe contener información suficiente para investigar el fallo:

contenido original
motivo del error
regla de validación
origen
ID de ejecución
marca de tiempo

En los sistemas de eventos, el equivalente suele llamarse dead-letter queue.

Una tabla de cuarentena no debe convertirse en un cementerio de datos. Necesita monitorización, un responsable, una política de retención y reglas de reintento o corrección.

6. Reintento con backoff exponencial

Los errores transitorios son normales en los sistemas distribuidos:

  • HTTP 429;
  • HTTP 503;
  • fallo temporal de conexión a la base de datos;
  • throttling del almacenamiento;
  • una breve interrupción de red.

Los reintentos inmediatos y repetidos pueden empeorar la situación.

En su lugar:

  1. Fallo
  2. esperar 1 s
    Reintentar
  3. esperar 2 s
    Reintentar
  4. esperar 4 s
    Reintentar
Reintento con backoff exponencial

A menudo se añade un componente aleatorio, o jitter, para que miles de workers no reintenten exactamente en el mismo instante.

Los reintentos normalmente deben combinarse con idempotencia. De lo contrario, una solicitud puede tener éxito, su respuesta puede perderse y el reintento puede crear una escritura duplicada.

Reintento + idempotencia + número de intentos limitado es el patrón más sólido.

7. Patrón pipeline / procesamiento por etapas

Las transformaciones grandes se vuelven difíciles de razonar cuando todas las reglas viven en un único notebook, procedimiento almacenado o función de Python enorme.

Un patrón pipeline divide el procesamiento en etapas:

  1. Extraer
  2. Parsear
  3. Validar
  4. Normalizar
  5. Enriquecer
  6. Publicar
Procesamiento por etapas

Cada etapa tiene una responsabilidad y un contrato definidos.

records = extract(source)
records = parse(records)
records = validate(records)
records = normalize(records)
records = enrich(records)
publish(records)

Entre los beneficios: pruebas más sencillas, fallos más claros, etapas reutilizables, mejor observabilidad y responsabilidades más simples de asignar.

Las etapas lógicas no tienen por qué convertirse automáticamente en servicios de red separados.

8. Patrón Strategy para comportamientos propios de cada fuente

Una plataforma de datos puede empezar con un único flujo CSV y acabar necesitando admitir:

CSV
JSON
SFTP
API
Base de datos

Con el tiempo, el código puede convertirse en una larga cadena de if/elif.

Aquí es donde el patrón Strategy clásico resulta útil.

Define un comportamiento común:

class SourceReader:
    def read(self):
        raise NotImplementedError

Después implementa estrategias específicas para cada fuente:

class CsvReader(SourceReader):
    ...

class ApiReader(SourceReader):
    ...

class SftpReader(SourceReader):
    ...

La orquestación depende de la interfaz y no de los detalles de la fuente.

Esto es especialmente útil en plataformas multi-tenant, donde los tenants usan transportes o formatos distintos pero comparten el mismo ciclo de vida de ingesta.

9. Patrón Adapter para sistemas externos

Los sistemas externos rara vez exponen exactamente el contrato que tu plataforma necesita.

Una API puede devolver:

{
  "customerNumber": 42,
  "created": "2026-10-09T14:00:00Z"
}

mientras que otra devuelve:

{
  "id": 42,
  "created_at": "2026-10-09 14:00:00"
}

No dejes que los contratos propios de cada fuente se extiendan por toda la plataforma.

Usa un Adapter:

  1. API externa
  2. Adapter
  3. Contrato canónico de cliente
Adapter para un sistema externo

El adapter traduce nombres de campos, fechas, la semántica de los valores nulos, valores de estado, el comportamiento de autenticación y los errores propios de la fuente.

Las transformaciones posteriores trabajan sobre el modelo canónico.

10. Fan-out / fan-in

A veces una entrada debe desencadenar varias operaciones independientes.

  1. Entrada
  2. Parseo
    • Métricas de calidad
    • Transformación principal
    • Auditoría
    • Notificaciones
Fan-out

Eso es fan-out.

Más adelante, los resultados pueden reunirse:

    • Tarea A
    • Tarea B
    • Tarea C
  1. Publicación final
Fan-in

Eso es fan-in.

Este patrón es útil para procesar varias particiones o archivos, generar varios formatos de informe, calcular agregaciones independientes o escribir en varios almacenes posteriores.

El fan-out introduce coordinación. Tienes que decidir qué significa que falle una rama, si las ramas que terminaron bien siguen confirmadas, cómo funcionan los reintentos y cómo se detecta que todo terminó.

11. Patrón snapshot + historial

A veces un consumidor quiere el estado actual:

Cliente 42
estado = Activo
país = US

Otros consumidores necesitan saber cómo cambió ese estado.

Un patrón útil consiste en mantener tanto una tabla actual como un historial, o modelar el historial con fechas de vigencia:

customer_id
status
valid_from
valid_to
is_current

Esto está muy relacionado con los patrones de Slowly Changing Dimension.

La idea general es:

Separar «¿qué es cierto ahora?» de «¿qué era cierto en un momento dado?»

Es útil para atributos de clientes, configuración de comercios, reglas de precios, jerarquía organizativa, estado de cuentas y datos de referencia.

12. Patrón de serving materializado

Un error común es obligar a cada consumidor a ejecutar transformaciones complejas en el momento de la solicitud.

  1. Solicitud de la interfaz
  2. Cálculo en cada solicitud
    • 12 joins
    • 3 agregaciones grandes
    • funciones de ventana
  3. Respuesta
Antipatrón: calcular en el momento de la solicitud

El patrón de serving materializado adelanta el trabajo costoso y reutilizable.

  1. Datos sin procesar
  2. Transformación
  3. Resultado curado / materializado
  4. API / dashboard / informe
Serving materializado

Algunas implementaciones posibles: tablas de agregados, vistas materializadas, tablas Gold, Parquet prerrenderizado, resultados de informes en caché e índices de búsqueda.

La contrapartida es la frescura.

No te preguntes solo: ¿debería precalcularse esto?

Pregúntate:

¿El resultado es lo bastante costoso, se repite lo bastante y es lo bastante estable como para que precalcularlo salga más barato que recalcularlo?

Procesamiento basado en configuración

A medida que crecen las plataformas de datos, programar cada fuente de forma fija suele crear cientos de pipelines casi idénticos.

En lugar de:

Pipeline A para el tenant A
Pipeline B para el tenant B
Pipeline C para el tenant C

puedes usar:

Motor de ingesta genérico
        +
configuración

Ejemplo:

{
  "tenant": "tenant-a",
  "source_type": "sftp",
  "format": "csv",
  "delimiter": ",",
  "encoding": "windows-1252",
  "date_format": "%Y-%m-%d",
  "target": "sales"
}

La configuración selecciona estrategias en lugar de incrustar cada decisión en el código de orquestación.

Esto funciona especialmente bien cuando las diferencias son parámetros.

Funciona mal cuando los tenants tienen procesos de negocio fundamentalmente distintos y la configuración se convierte en un lenguaje de programación disfrazado de JSON.

Patrones que suelen combinarse

Algunas combinaciones son especialmente útiles.

Carga incremental + watermark + idempotencia

  1. Watermark
  2. Leer cambios
  3. Merge idempotente
  4. Confirmar el watermark
Carga incremental con watermark e idempotencia

CDC + deduplicación + orden

  1. Flujo CDC
  2. Orden / checkpoint
  3. Deduplicar
  4. Aplicar el cambio
CDC con orden y deduplicación

Reintento + backoff + circuit breaker

Útil al llamar a sistemas posteriores inestables. Un circuit breaker deja de hacer llamadas temporalmente tras fallos repetidos, en lugar de saturar sin pausa una dependencia que no está sana.

Capa sin procesar + cuarentena + reproducción

La capa sin procesar conserva la evidencia, la cuarentena aísla los problemas y la reproducción hace posible la recuperación.

Strategy + Adapter + configuración

Útil para motores de ingesta con varias fuentes o varios tenants.

Cuándo un patrón se convierte en sobreingeniería

Los patrones son útiles porque ponen nombre a estructuras probadas.

Se vuelven perjudiciales cuando los equipos los aplican sin tener el problema correspondiente.

  • No implementes CDC para una tabla de 5.000 filas que se carga una vez al día si una lectura completa no cuesta casi nada.
  • No construyas cinco capas de datos cuando dos tienen responsabilidades claras.
  • No introduzcas un bus de mensajes solo porque los sistemas asíncronos están de moda.
  • No construyas un framework genérico de plugins para dos formatos de archivo fijos.
  • No crees un motor de configuración tan flexible que nadie pueda entender qué va a ejecutar.
  • No introduzcas event sourcing cuando unas simples tablas de historial resuelven el requisito.

La mejor arquitectura no es la que tiene más patrones.

Es aquella en la que cada patrón elimina un problema concreto de operación o de mantenimiento.

Guía práctica de selección

Problema Patrón a considerar
Los reintentos crean datos duplicados Idempotencia
Las cargas completas son demasiado costosas Carga incremental
Se necesita un flujo de cambios a nivel de base de datos CDC
Se necesita reproducción y auditabilidad Sin procesar → validada → curada
Filas incorrectas detienen todo el lote Cuarentena / dead-letter
Fallos temporales de sistemas remotos Reintento + backoff exponencial
La transformación es un único bloque enorme Pipeline / procesamiento por etapas
Varios comportamientos según la fuente Strategy
Los esquemas externos se filtran por todas partes Adapter
Hay trabajo independiente que puede ejecutarse en paralelo Fan-out / fan-in
Se necesitan valores actuales e históricos Snapshot + historial / SCD
Consultas complejas que se repiten constantemente Serving materializado
Cientos de pipelines casi idénticos Procesamiento basado en configuración

Lo que estandarizaría en una plataforma de datos

Si estuviera definiendo estándares de ingeniería para una plataforma de datos en producción, esperaría que la mayoría de los pipelines respondieran a estas preguntas:

Identidad: ¿qué identifica de forma única la entrada?

Reproducción: ¿puede el pipeline volver a ejecutarse de forma segura?

Incrementalidad: ¿cómo sabe qué cambió?

Calidad: ¿adónde van los registros no válidos?

Estado: ¿dónde se guardan los watermarks y los checkpoints?

Observabilidad: ¿puedo identificar la ejecución, el tenant, la fuente, la hora de inicio y fin, las filas leídas, las filas escritas, las filas rechazadas, el error y los reintentos?

Recuperación: ¿qué ocurre después de un fallo parcial?

Serving: ¿el consumidor lee transformaciones sin procesar o un modelo de serving diseñado para él?

Estas preguntas valen más que preguntar qué tecnología usó el equipo.

Un pipeline puede usar la plataforma más reciente del mercado y seguir siendo frágil si faltan estas consideraciones.

Los patrones de diseño facilitan hablar de arquitectura

Un beneficio infravalorado de los patrones es la comunicación.

Compara:

Tenemos un proceso que guarda el archivo original, valida los registros, pone las filas no válidas en otro sitio, reintenta los fallos temporales de la API y evita duplicados.

con:

La ingesta es reproducible e idempotente, usa una capa de aterrizaje sin procesar, pone en cuarentena los registros no válidos y reintenta las llamadas transitorias con backoff exponencial.

La segunda descripción condensa mucha información de arquitectura.

Ese vocabulario compartido resulta útil en revisiones de arquitectura, revisiones de código, análisis de incidentes, incorporación de personas nuevas, estándares de plataforma y documentos de diseño.

Los patrones no son solo técnicas de implementación. También son un lenguaje para las decisiones de ingeniería.

Reflexiones finales

Una buena arquitectura de datos rara vez consiste en encontrar una plataforma perfecta.

Consiste en gestionar los problemas recurrentes de forma predecible.

Los datos llegan dos veces. Las fuentes cambian. Las APIs fallan. Los archivos llegan mal formados. Los jobs se reintentan. Las reglas de negocio evolucionan. Los consumidores quieren a la vez datos frescos y respuestas rápidas.

Las tecnologías seguirán cambiando, pero esos problemas seguirán apareciendo.

Por eso patrones como la idempotencia, la carga incremental, el CDC, el procesamiento por capas, la cuarentena, el reintento, Strategy, Adapter, el fan-out/fan-in, el modelado del historial y el serving materializado siguen siendo útiles.

Las plataformas de datos más sólidas no son las que tienen los diagramas más complicados.

Son aquellas en las que los modos de fallo habituales ya se han anticipado, y en las que la solución es repetible en lugar de reinventarse en cada pipeline.

Etiquetas

  • Arquitectura de datos
  • Pipelines de datos
  • Patrones de diseño