Guía de Calidad de Datos: Validación, Profiling, Monitoreo
Domina la calidad de datos: frameworks de validación, profiling, schemas, detección de anomalías y checks en pipelines con Great Expectations, Pandera y Soda.
Introducción
Los problemas de calidad de datos corrompen en silencio analíticas, modelos de ML y decisiones de negocio. Una clave primaria nula rompe un join aguas abajo. Un valor de estado que nadie documentó aparece en un informe tres meses después. Una fuente que recorta sus filas a la mitad sin avisar propaga “insights” que son simplemente erróneos.
El trabajo de calidad de datos tiene tres capas: profiling (entender cómo son los datos), validación (forzar cómo deberían ser) y monitoreo (detectar cuándo se desvían). Esta guía recorre las seis dimensiones de calidad, luego los tres stacks de validación principales — Great Expectations, Pandera y Soda — y finalmente cómo integrar los checks en Airflow, dbt y bucles de monitoreo para que los datos malos se detengan antes de propagarse.
Cuándo usar cada herramienta
Las tres herramientas se solapan pero optimizan capas distintas del stack:
| Herramienta | En qué destaca | Dónde vive | Cuándo no usarla |
|---|---|---|---|
| Great Expectations | Validación a escala de warehouse con reportes e historia | Plataforma de datos / orquestador | Solo necesitas checks puntuales — es pesada |
| Pandera | Schemas de DataFrame nativos en Python | Dentro de notebooks, scripts, funciones ETL | Tus datos viven solo en SQL — usa tests dbt/Soda |
| Soda | Checks SQL-first contra warehouses | YAML declarativo + scans CLI | Necesitas lógica por fila en Python |
| Tests dbt | Validación dentro de la capa de transformación | Junto a los modelos | No usas dbt |
El patrón de fondo: valida en cada frontera de etapa, pon en cuarentena lo que falla y monitorea lo que pasa. Los checks fail-fast (schema, claves, conteo de filas) detienen el pipeline; los checks blandos (deriva de distribución, tasas de nulos anómalas) avisan sin bloquear.
Un orden de adopción que funciona: empieza con checks Pandera en la frontera de ingesta raw — son los más baratos de escribir y detectan los fallos de mayor impacto pronto. Añade tests de dbt cuando exista la capa de transformación. Introduce Soda o GX cuando necesites reportes compartidos, historia y checks que mantengan personas que no escriben código de pipeline. Ninguna capa reemplaza a otra; se apilan.
Para la capa de orquestación alrededor de estos checks, consulta la guía de Airflow; para la capa de transformación, la guía de dbt.
Dimensiones de la calidad de datos
Cada check de calidad corresponde a una de seis dimensiones. Saber qué dimensión cubre un check te dice qué no estás probando todavía:
| Dimensión | Pregunta que responde | Check de ejemplo |
|---|---|---|
| Exactitud | ¿Los datos reflejan la realidad? | El total del pedido coincide con el procesador de pagos |
| Completitud | ¿Los campos obligatorios están llenos? | Sin nulos en order_id; conteo de filas dentro del rango |
| Consistencia | ¿Los datos coinciden entre sistemas? | El ID de cliente existe en orders y customers |
| Validez | ¿Cumple los formatos esperados? | Email con regex válido; fecha no futura; país en lista ISO |
| Unicidad | ¿Hay duplicados? | Claves primarias únicas; sin pedidos duplicados por lote |
| Oportunidad | ¿Los datos están frescos? | Pipeline completado dentro del SLA; datos < 24h |
En la práctica, los equipos suelen implementar primero Validez y Unicidad (las más fáciles de automatizar) e invierten menos en Exactitud y Consistencia (más difíciles: exigen comparar contra una verdad externa o un segundo sistema). Las herramientas también cubren las dimensiones de forma desigual — un check not_null cubre Completitud, un regex cubre Validez, pero nada en un check de schema verifica que un total realmente iguale lo que cobró el procesador de pagos. Los checks de reconciliación como el test de ingresos de dbt más adelante en la guía son cómo se cubre la Consistencia en la práctica.
Profiling de datos
Haz profiling antes de validar — no puedes escribir expectativas sobre datos que no has medido. El profiling te da tasas de nulos, rangos y conjuntos de valores reales; las reglas escritas a ciegas o no detectan problemas reales o disparan sobre datos aceptables.
# profiling/profile_dataset.py — Entiende tus datos antes de validar
import pandas as pd
from ydata_profiling import ProfileReport # antes pandas-profiling
df = pd.read_csv("data/orders.csv")
# Reporte completo (HTML): distribuciones, correlaciones, avisos
profile = ProfileReport(df, title="Orders Dataset Profile", minimal=True)
profile.to_file("reports/orders_profile.html")
# Profiling manual con pandas cuando necesitas los números en código
def profile_dataframe(df: pd.DataFrame) -> dict:
profile = {
"row_count": len(df),
"column_count": len(df.columns),
"null_counts": df.isnull().sum().to_dict(),
"null_percentages": (df.isnull().sum() / len(df) * 100).round(2).to_dict(),
"duplicate_rows": int(df.duplicated().sum()),
"dtypes": df.dtypes.astype(str).to_dict(),
"unique_counts": {col: int(df[col].nunique()) for col in df.columns},
}
for col in df.select_dtypes(include="number").columns:
profile[col] = {
"min": float(df[col].min()),
"max": float(df[col].max()),
"mean": float(df[col].mean()),
"median": float(df[col].median()),
"std": float(df[col].std()),
"quartiles": df[col].quantile([0.25, 0.5, 0.75]).to_dict(),
}
return profile
profile = profile_dataframe(df)
print(f"Rows: {profile['row_count']}, Columns: {profile['column_count']}")
print(f"Nulls: {profile['null_counts']}")
print(f"Duplicates: {profile['duplicate_rows']}")
Dos hábitos de profiling que compensan: guarda el reporte por lote (compara el perfil de hoy con el de ayer para detectar cambios silenciosos de schema) y escribe las expectativas a partir de distribuciones medidas — por ejemplo, los límites de expect_column_values_to_be_between desde cuantiles observados más margen, no desde suposiciones.
Great Expectations
Great Expectations (GX) es la opción pesada: suites de expectativas, checkpoints y reportes Data Docs generados. Su punto fuerte es la validación a escala de warehouse donde necesitas historia y reportes compartidos por el equipo. GX 1.x reorganizó la API en torno a data_sources → assets → batch_definitions → validation_definitions — los ejemplos siguen ese flujo.
Creación de la suite (GX 1.x)
# gx/suite.py — Expectation suite, API GX 1.x
import great_expectations as gx
context = gx.get_context()
# Crea la suite y añade expectativas
suite = context.suites.add(gx.ExpectationSuite(name="orders_suite"))
suite.add_expectation(
gx.expectations.ExpectColumnValuesToNotBeNull(column="order_id")
)
suite.add_expectation(
gx.expectations.ExpectColumnValuesToBeUnique(column="order_id")
)
suite.add_expectation(
gx.expectations.ExpectColumnValuesToBeBetween(
column="total_amount", min_value=0, max_value=100000
)
)
suite.add_expectation(
gx.expectations.ExpectColumnValuesToBeInSet(
column="status",
value_set=["pending", "processing", "shipped", "completed", "cancelled"],
)
)
suite.add_expectation(
gx.expectations.ExpectColumnValuesToMatchRegex(
column="email", regex=r"^[^@]+@[^@]+\.[^@]+$"
)
)
suite.add_expectation(
gx.expectations.ExpectTableRowCountToBeBetween(
min_value=100, max_value=1000000
)
)
Validación (GX 1.x)
# gx/validate.py — Ejecuta una suite contra un DataFrame, GX 1.x
import great_expectations as gx
import pandas as pd
context = gx.get_context()
# Data source → asset → batch definition → validation definition
ds = context.data_sources.add_pandas("orders_source")
asset = ds.add_dataframe_asset("orders_df")
batch_def = asset.add_batch_definition_whole_dataframe("orders_batch")
suite = context.suites.get(name="orders_suite")
validation = context.validation_definitions.add(
gx.ValidationDefinition(data=batch_def, suite=suite, name="orders_validation")
)
df = pd.read_csv("data/orders.csv")
results = validation.run(batch_parameters={"dataframe": df})
if not results.success:
for r in results.results:
if not r.success:
cfg = r.expectation_config
print(f"FAILED: {cfg.type} on column {cfg.kwargs.get('column', 'N/A')}")
raise ValueError("Data quality checks failed")
En lugar del profiler automático eliminado, genera expectativas a partir de un perfil medido: ejecuta profile_dataframe (sección anterior) y emite límites de ExpectColumnValuesToBeBetween desde cuantiles y ExpectColumnValuesToBeInSet desde unique_counts observados en columnas de baja cardinalidad. Revisa la suite generada una vez — las expectativas automáticas son un borrador, no un evangelio.
Pandera
Pandera valida DataFrames dentro del proceso — ideal cuando tu pipeline es Python (pandas, Polars) y los checks pertenecen junto al código que los posee, no en una plataforma externa. Los schemas son declarativos y componibles.
Validación de schema de DataFrame
# validation/pandera_schemas.py — Schema enforcement para DataFrames pandas
import pandera as pa
import pandas as pd
orders_schema = pa.DataFrameSchema({
"order_id": pa.Column(int, checks=pa.Check.unique(), nullable=False),
"customer_id": pa.Column(int, nullable=False),
"created_at": pa.Column(pa.DateTime, nullable=False),
"status": pa.Column(
str,
checks=pa.Check.isin(["pending", "processing", "shipped", "completed", "cancelled"]),
nullable=False,
),
"subtotal": pa.Column(float, checks=pa.Check.ge(0), nullable=False),
"tax": pa.Column(float, checks=pa.Check.ge(0), nullable=True),
"shipping": pa.Column(float, checks=pa.Check.ge(0), nullable=True),
"email": pa.Column(
str,
checks=pa.Check.str_matches(r"^[^@]+@[^@]+\.[^@]+$"),
nullable=True,
),
}, strict=True, coerce=True) # strict: sin columnas extra; coerce: castea tipos
df = pd.read_csv("data/orders.csv")
try:
validated = orders_schema.validate(df, lazy=True) # lazy: recoge TODOS los errores
print(f"Validation passed: {len(validated)} rows")
except pa.errors.SchemaErrors as e:
print(f"Validation failed: {len(e.failure_cases)} issue(s)")
# e.failure_cases lista filas, columnas y checks fallidos
# Check personalizado de regla de negocio
def no_weekend_orders(series: pd.Series) -> pd.Series:
return series.dt.dayofweek < 5 # lunes=0, domingo=6
orders_schema = pa.DataFrameSchema({
"created_at": pa.Column(
pa.DateTime,
checks=pa.Check(no_weekend_orders, element_wise=False,
error="No weekend orders allowed"),
),
})
Dos detalles que importan en producción: lazy=True devuelve todas las filas fallidas en una pasada en vez de parar en la primera — esencial para reportes de cuarentena; y coerce=True corrige los tipos antes de los checks, así que un "42" leído como string se convierte en 42 en vez de fallar el check de int.
Herencia y composición de schemas
# Schema base para columnas compartidas; se extiende por tabla
base_schema = pa.DataFrameSchema({
"id": pa.Column(int, checks=pa.Check.unique(), nullable=False),
"created_at": pa.Column(pa.DateTime, nullable=False),
"updated_at": pa.Column(pa.DateTime, nullable=True),
}, strict=False)
customers_schema = base_schema.add_columns({
"email": pa.Column(str, checks=pa.Check.str_matches(r"^[^@]+@[^@]+$")),
"country": pa.Column(str, checks=pa.Check.isin(["US", "CA", "UK", "DE", "FR", "JP"])),
})
products_schema = base_schema.add_columns({
"name": pa.Column(str, nullable=False),
"price": pa.Column(float, checks=pa.Check.ge(0)),
"sku": pa.Column(str, checks=pa.Check.str_length(min_value=8, max_value=20)),
})
La herencia mantiene la trazabilidad cuerda: cambia las reglas de created_at una vez y todos los schemas derivados las heredan automáticamente.
Soda
Soda pone los checks en YAML y los ejecuta contra el warehouse directamente — sin necesidad de un pipeline Python. Encaja con equipos SQL-first y se integra en orquestadores como un paso de scan.
# checks/orders_checks.yml — checks de Soda Core
checks for orders:
- row_count > 0
- row_count < 1000000
- missing_count(order_id) = 0
- duplicate_count(order_id) = 0
- missing_count(customer_id) = 0
- invalid_count(email) = 0:
valid regex: ^[^@]+@[^@]+\.[^@]+$
- invalid_count(status) = 0:
valid values: [pending, processing, shipped, completed, cancelled]
- min(total_amount) >= 0
- max(total_amount) <= 100000
- schema:
warn: when forbidden column present [ssn, credit_card_number]
fail: when required column missing [order_id, customer_id, status]
- freshness(created_at) < 1d
- anomaly_score for row_count:
default threshold: 3
# dispara cuando el conteo se desvía >3 desviaciones del histórico
# Ejecuta checks contra una fuente de datos
soda scan -d warehouse -c soda_config.yml checks/orders_checks.yml
# Dentro de un pipeline (Airflow) con variables de plantilla
soda scan -d warehouse -c soda_config.yml checks/orders_checks.yml --variable start_date={{ ds }}
La separación warn:/fail: es la versión integrada en Soda de los umbrales blandos y duros: cambios de schema en columnas obligatorias detienen el scan con fallo; columnas sensibles inesperadas avisan para que alguien las revise.
Integrando checks de calidad en pipelines
Una validación que solo corre puntualmente es un ejercicio de laboratorio. El valor está en colocar checks en cada frontera de etapa para que la corrupción se detenga donde empieza.
Integración con Airflow
# dags/pipeline_with_quality.py — Puertas de calidad entre etapas
from airflow import DAG
from airflow.operators.python import PythonOperator
from airflow.providers.postgres.hooks.postgres import PostgresHook
from datetime import datetime
dag = DAG(
"pipeline_with_quality_checks",
schedule="0 2 * * *",
start_date=datetime(2026, 1, 1),
catchup=False,
max_active_runs=1,
)
def extract(**context):
import pandas as pd
hook = PostgresHook(postgres_conn_id="source_db")
df = hook.get_pandas_df(
"SELECT * FROM source WHERE date = %(ds)s", parameters={"ds": context["ds"]}
)
df.to_csv(f"/data/raw/{context['ds']}/orders.csv", index=False)
return len(df)
def validate_raw(**context):
import pandera as pa
import pandas as pd
df = pd.read_csv(f"/data/raw/{context['ds']}/orders.csv")
schema = pa.DataFrameSchema({
"order_id": pa.Column(int, checks=pa.Check.unique(), nullable=False),
"status": pa.Column(str, checks=pa.Check.isin(
["pending", "processing", "shipped", "completed", "cancelled"]
)),
})
schema.validate(df, lazy=True)
def transform(**context):
import pandas as pd
df = pd.read_csv(f"/data/raw/{context['ds']}/orders.csv")
df["total"] = df["subtotal"] + df["tax"] + df["shipping"]
df.to_csv(f"/data/processed/{context['ds']}/orders.csv", index=False)
def validate_processed(**context):
import pandera as pa
import pandas as pd
df = pd.read_csv(f"/data/processed/{context['ds']}/orders.csv")
schema = pa.DataFrameSchema({
"order_id": pa.Column(int, checks=pa.Check.unique(), nullable=False),
"total": pa.Column(float, checks=pa.Check.ge(0), nullable=False),
})
schema.validate(df, lazy=True)
extract_task = PythonOperator(task_id="extract", python_callable=extract, dag=dag)
validate_raw_task = PythonOperator(task_id="validate_raw", python_callable=validate_raw, dag=dag)
transform_task = PythonOperator(task_id="transform", python_callable=transform, dag=dag)
validate_processed_task = PythonOperator(task_id="validate_processed", python_callable=validate_processed, dag=dag)
extract_task >> validate_raw_task >> transform_task >> validate_processed_task
Tres decisiones de diseño que vale la pena copiar: el check corre entre etapas (los errores de raw nunca llegan a transform), lazy=True muestra la lista completa de fallos para el reporte de cuarentena, y la query usa %(ds)s parametrizado en vez de interpolación de strings — queries parametrizadas, siempre.
Cuando una puerta falla, la pregunta es qué pasa con las filas malas. Las dos opciones sanas: cuarentena a una tabla lateral con la razón del fallo y seguir procesando el resto, o fallar la tarea y pararlo todo. Falla ante violaciones de schema/claves; cuarentena para outliers de reglas de negocio por fila.
Tests de dbt como checks de calidad
Los tests de dbt corren dentro de la capa de transformación — la última puerta antes de que los datos lleguen a los dashboards. Los tests singulares (archivos SQL en tests/) devuelven filas que violan la regla; cero filas devueltas significa que pasa.
-- tests/assert_order_count_within_range.sql
SELECT 1
WHERE (
SELECT COUNT(*) FROM {{ ref('stg_orders') }}
WHERE created_at = CURRENT_DATE()
) < 10 OR (
SELECT COUNT(*) FROM {{ ref('stg_orders') }}
WHERE created_at = CURRENT_DATE()
) > 100000
-- tests/assert_revenue_matches_source.sql
SELECT
warehouse.revenue AS warehouse_revenue,
source.revenue AS source_revenue,
ABS(warehouse.revenue - source.revenue) AS discrepancy
FROM (
SELECT SUM(total_amount) AS revenue FROM {{ ref('fct_orders') }}
WHERE created_at >= CURRENT_DATE() - INTERVAL '7 days'
) warehouse
CROSS JOIN (
SELECT SUM(total_amount) AS revenue FROM {{ source('raw', 'orders') }}
WHERE created_at >= CURRENT_DATE() - INTERVAL '7 days'
) source
WHERE ABS(warehouse.revenue - source.revenue) > 0.01
El test de reconciliación de ingresos es el patrón más valioso del archivo: detecta fallos de la dimensión Consistencia — el warehouse se desvía de la fuente — que los checks por fila no pueden ver. La guía de dbt cubre los tests genéricos (unique, not_null, accepted_values, relationships) que resuelven la mayoría de reglas por columna sin SQL personalizado.
Detección de anomalías
Los checks de schema detectan los errores que anticipaste. La detección de anomalías detecta los que no: una fuente que recorta filas en silencio, una tasa de nulos que se triplica, una distribución que se desplaza. El caballo de batalla es el z-score sobre una línea base móvil:
# monitoring/anomaly_detection.py — Detección estadística de anomalías
import numpy as np
def detect_row_count_anomalies(
current_count: int,
historical_counts: list[int],
threshold: float = 3.0,
) -> dict:
mean = np.mean(historical_counts)
std = np.std(historical_counts)
z_score = (current_count - mean) / std if std > 0 else 0
return {
"current": current_count,
"mean": round(mean, 2),
"std": round(std, 2),
"z_score": round(z_score, 2),
"is_anomaly": abs(z_score) > threshold,
"direction": "high" if z_score > 0 else "low",
}
# Por columna: pico en tasa de nulos (solo avisa aumentos)
def detect_null_rate_anomaly(
current_null_rate: float,
historical_rates: list[float],
threshold: float = 3.0,
) -> dict:
mean = np.mean(historical_rates)
std = np.std(historical_rates)
z_score = (current_null_rate - mean) / std if std > 0 else 0
return {
"current_rate": current_null_rate,
"mean_rate": round(mean, 4),
"z_score": round(z_score, 2),
"is_anomaly": z_score > threshold, # las bajadas están bien
}
Dos reglas mantienen la detección útil en lugar de ruidosa: junta al menos 30 días de línea base antes de activar alertas (los z-scores con 5 muestras alertan de todo) y monitorea las métricas que de verdad importan — conteos de filas, tasas de nulos de columnas clave, conteos distintos de IDs — no todas las columnas de la tabla. La estacionalidad es la tercera regla: una caída de fin de semana no es anomalía si los fines de semana siempre caen — compara contra líneas base del mismo día de la semana cuando tus datos tienen ritmo semanal.
El resultado de la detección solo sirve por lo que pasa después. Enruta las anomalías al mismo canal de alertas que los incidentes de infraestructura — un incidente de datos es un incidente de producción — y registra la resolución. En unos meses esa historia se convierte en tu mejor documentación: qué checks detectaron problemas reales, cuáles solo generaron ruido y qué métricas nadie miró jamás. Para la parte de alertas de este bucle, consulta la guía de monitoreo.
Buenas prácticas
- Profiling antes de validar — expectativas escritas desde distribuciones medidas, no suposiciones
- Valida en cada frontera de etapa — raw, staging y marts tienen modos de fallo distintos
- Falla rápido en checks estructurales — schema, claves, conteo cero → detén el pipeline
- Avisa, no bloquees, ante deriva — cambios de distribución y tasas de nulos van a cuarentena + alerta
- Cuarentena para filas malas — envíalas a una tabla lateral con la razón del fallo; no las elimines en silencio
- 30 días de línea base antes de activar alertas de anomalías
lazy=Trueen todas partes — reporta todos los fallos por ejecución, no solo el primero- Versiona los schemas con los modelos — un cambio de schema sin cambio de validación es una ruptura silenciosa
- Guarda los resultados de validación — Data Docs de GX o una tabla de resultados; la historia alimenta las líneas base
- Involucra a expertos de dominio — valores de estado y rangos de precio válidos son reglas de negocio, no suposiciones
Errores comunes
- Validar solo la salida final — los errores de extracción se propagan por las transformaciones; pon puertas en cada frontera
- Sin línea base histórica — la detección de anomalías con una semana de historia alerta sobre ruido
- Validación demasiado estricta — rechazar filas por un campo opcional bloquea todo el pipeline; avisa en checks no críticos
- Parámetros interpolados como string —
f"WHERE date = '{ds}'"es un vector de inyección y se rompe con valores raros; parametriza - Umbrales hardcodeados — un
row_count < 1000000razonable el año pasado dispara con el crecimiento; prefiere límites estadísticos - Eliminar filas malas en silencio — cuarentena con la razón; los descartes silenciosos crean huecos imposibles de auditar
- Ceguera a la deriva de schema — upstream renombra una columna y downstream se rompe misteriosamente;
strict=True+ checks de schema en columnas obligatorias lo cazan en la puerta - Tratar la validación como algo puntual — las fuentes evolucionan; los checks necesitan monitoreo y mantenimiento como el código de producción
Ver también
- Guía completa de Apache Airflow — capa de orquestación para las puertas de calidad mostradas aquí
- Guía completa de dbt — tests y modelos en la capa de transformación
- Guía de arquitectura de pipelines de datos — dónde encajan estos checks en el pipeline completo
- Documentación de Great Expectations — referencia oficial de GX 1.x
- Documentación de Pandera — API de schemas de DataFrame
- Documentación de Soda — checks SodaCL y scans
Preguntas frecuentes
¿Qué es el profiling de datos?
Analizar un dataset para entender su estructura, contenido y calidad: conteos de filas, tasas de nulos, distribuciones, rangos, conteos únicos, tipos. El profiling es el primer paso — no puedes escribir reglas de validación con sentido sobre datos que no has medido.
¿Great Expectations, Pandera o Soda — cuál uso?
GX para validación a escala de warehouse con reportes e historia (la más pesada, más funciones). Pandera para validación nativa en Python dentro de notebooks, scripts y código ETL. Soda para checks declarativos SQL-first contra el warehouse. Muchos stacks usan dos: Pandera en el código de ingesta más Soda/tests dbt en la capa del warehouse.
¿Qué es la detección de anomalías en calidad de datos?
Detección estadística de cambios inesperados en métricas de datos — z-scores sobre línea base móvil, IQR o descomposición de series temporales. Detecta fallos que los checks de schema no ven: una fuente que reduce sus filas a la mitad, una tasa de nulos que se triplica, una distribución que deriva. Necesita ~30 días de línea base para evitar ruido en las alertas.
¿Cuándo debe un check fallar el pipeline y cuándo avisar?
Fallar cuando el dato es estructuralmente inutilizable: claves primarias nulas o duplicadas, columnas obligatorias ausentes, integridad referencial rota, cero filas. Avisar cuando el dato es sospechoso pero procesable: tasas de nulos elevadas, distribuciones desplazadas, valores opcionales inesperados. La separación fallo/aviso evita que los pipelines paren por problemas cosméticos.
¿Cómo pruebo la calidad de datos en CI/CD?
Ejecuta tests de dbt sobre modelos modificados (--select state:modified+) en el pipeline del PR. Para ETL en Python, corre schemas Pandera contra fixtures de ejemplo como paso de test unitario. En producción, integra scans de Soda o tareas de validación en el orquestador — CI detecta regresiones de reglas, la orquestación detecta regresiones de datos.
Recursos Relacionados
Pipelines de Datos: Batch, Streaming, Lambda y Kappa
Diseñá pipelines de datos batch y streaming: código funcional con Airflow, Flink y dbt, diferencias entre Lambda y Kappa, y tabla para elegir ETL o ELT.
Guidedbt: Modelos, Tests, Macros y Materializaciones
Aprende dbt para transformaciones de datos: modelos, tests, macros, materializaciones, seeds, snapshots y patrones de producción.
GuideApache Airflow: DAGs, Operadores y Scheduling
Domina Apache Airflow: DAGs, operadores, sensores, XCom, scheduling, backfilling, connections, variables y patrones de producción para pipelines.
GuideGuía Completa de Monitoreo y Alertas
Monta un stack de monitoreo en producción con Prometheus, Grafana y AlertManager — métodos RED/USE, alertas que no fatigan y SLOs con error budget.