Data Mesh Sin la Complejidad: Un Bucket por Equipo

Data mesh suena genial en teoría: propiedad descentralizada, datos orientados al dominio, infraestructura de autoservicio. En la práctica, usualmente significa 18 meses de trabajo de “equipo de plataforma” construyendo un portal de autoservicio que nadie usa.

Aquí está el secreto: no necesitas una plataforma para hacer data mesh. Necesitas un bucket por equipo y un pip install.

La promesa de data mesh (y el fracaso usual)

La promesa:

• Cada equipo es dueño de sus datos
• Sin cuello de botella central
• Infraestructura de autoservicio
• Diseño orientado al dominio

La implementación usual:

• 6 meses construyendo una “plataforma de datos” con Terraform, Kubernetes y Airflow
• Un “equipo de plataforma” de 5 personas manteniéndola
• Los equipos siguen sin poder incorporarse sin abrir un ticket
• $200k/año en infraestructura antes de que alguien consulte algo

La implementación DataSpoc:

• Cada equipo ejecuta pip install dataspoc-pipe dataspoc-lens
• Cada equipo crea su propio bucket S3
• Cada equipo gestiona sus propios pipelines
• Costo total: $0 + almacenamiento S3 (~$5/mes por equipo)
• Tiempo de configuración: 30 minutos por equipo

La arquitectura

┌─────────────────────────────────────────────────────────────────┐
│                         Company Cloud (AWS/GCS/Azure)            │
│                                                                 │
│  ┌─────────────────┐  ┌─────────────────┐  ┌────────────────┐  │
│  │ s3://finance     │  │ s3://product     │  │ s3://marketing │  │
│  │                  │  │                  │  │                │  │
│  │ Pipe → Parquet   │  │ Pipe → Parquet   │  │ Pipe → Parquet │  │
│  │ Lens → SQL/AI    │  │ Lens → SQL/AI    │  │ Lens → SQL/AI  │  │
│  │ ML → predictions │  │                  │  │                │  │
│  │                  │  │                  │  │                │  │
│  │ IAM: finance-team│  │ IAM: product-team│  │ IAM: mkt-team  │  │
│  └─────────────────┘  └─────────────────┘  └────────────────┘  │
│                                                                 │
│  Cross-domain analyst: registers all 3 buckets in Lens          │
│  AI agent: connects via MCP, scoped to team's bucket            │
└─────────────────────────────────────────────────────────────────┘

Cada equipo es una plataforma de datos autocontenida:

• Su propio bucket (datos aislados)
• Su propia configuración de Pipe (sus fuentes, su horario)
• Su propia configuración de Lens (sus consultas, sus transformaciones)
• Su propio agente de IA (MCP con alcance a su bucket)

Sin infraestructura compartida. Sin equipo central. Sin tickets.

Configurando el equipo de Finanzas (ejemplo)

Paso 1: Crear el bucket e IAM

# AWS (or equivalent for GCS/Azure)
aws s3 mb s3://company-finance
aws iam create-policy --policy-name finance-data-access --policy-document '{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": ["s3:GetObject", "s3:PutObject", "s3:ListBucket"],
    "Resource": ["arn:aws:s3:::company-finance", "arn:aws:s3:::company-finance/*"]
  }]
}'

Paso 2: Instalar y configurar Pipe

pip install dataspoc-pipe[s3]
dataspoc-pipe init

Pipeline: Postgres (ERP) → bucket de Finanzas

source:
  tap: tap-postgres
  config: ~/.dataspoc-pipe/sources/erp.json
  streams:
    - invoices
    - payments
    - accounts_receivable

destination:
  bucket: s3://company-finance
  path: raw
  compression: zstd

incremental:
  enabled: true

schedule:
  cron: "0 6 * * *"  # daily at 6am

Pipeline: Stripe → bucket de Finanzas

source:
  tap: tap-stripe
  config: ~/.dataspoc-pipe/sources/stripe.json
  streams:
    - charges
    - refunds
    - subscriptions

destination:
  bucket: s3://company-finance
  path: raw
  compression: zstd

incremental:
  enabled: true

schedule:
  cron: "0 7 * * *"

dataspoc-pipe run _ --all
dataspoc-pipe schedule install

Paso 3: Instalar y configurar Lens

pip install dataspoc-lens[s3,ai,mcp]
dataspoc-lens init
dataspoc-lens add-bucket s3://company-finance

Paso 4: Crear transformaciones de dominio

-- ~/.dataspoc-lens/transforms/001_monthly_revenue.sql
CREATE OR REPLACE TABLE monthly_revenue AS
SELECT
    DATE_TRUNC('month', created_at) AS month,
    SUM(amount) AS revenue,
    COUNT(*) AS transactions,
    SUM(CASE WHEN type = 'refund' THEN amount ELSE 0 END) AS refunds
FROM charges
GROUP BY 1
ORDER BY 1;

-- ~/.dataspoc-lens/transforms/002_accounts_aging.sql
CREATE OR REPLACE TABLE accounts_aging AS
SELECT
    customer_id,
    SUM(CASE WHEN DATEDIFF('day', due_date, CURRENT_DATE) > 90 THEN amount ELSE 0 END) AS over_90,
    SUM(CASE WHEN DATEDIFF('day', due_date, CURRENT_DATE) BETWEEN 60 AND 90 THEN amount ELSE 0 END) AS days_60_90,
    SUM(CASE WHEN DATEDIFF('day', due_date, CURRENT_DATE) BETWEEN 30 AND 60 THEN amount ELSE 0 END) AS days_30_60,
    SUM(CASE WHEN DATEDIFF('day', due_date, CURRENT_DATE) < 30 THEN amount ELSE 0 END) AS current_amount
FROM accounts_receivable
WHERE status = 'open'
GROUP BY 1;

dataspoc-lens transform run

Paso 5: Conectar el agente de IA del equipo

dataspoc-lens mcp

Configuración de Claude Desktop para el equipo de finanzas:

{
  "mcpServers": {
    "finance-data": {
      "command": "dataspoc-lens",
      "args": ["mcp"]
    }
  }
}

Ahora el agente de IA del CFO puede preguntar:

"What's our monthly revenue trend?"
"Which customers have overdue payments over $10k?"
"What's our net retention rate this quarter?"

Cada respuesta viene de SQL real sobre los datos del equipo de finanzas. Sin acceso a los buckets de otros equipos.

Configurando el equipo de Producto (mismo patrón, diferentes datos)

pip install dataspoc-pipe[s3] dataspoc-lens[s3,ai]
dataspoc-pipe init

# Product team sources: Postgres (app DB) + Mixpanel events
source:
  tap: tap-postgres
  config: ~/.dataspoc-pipe/sources/app-db.json
  streams:
    - users
    - subscriptions
    - feature_flags

destination:
  bucket: s3://company-product
  path: raw
  compression: zstd

incremental:
  enabled: true

dataspoc-lens add-bucket s3://company-product
dataspoc-lens ask "how many users signed up last week?"

El equipo de producto tiene cero visibilidad de los datos de finanzas. Finanzas tiene cero visibilidad de los datos de producto. IAM aplica los límites, no el código de la aplicación.

Analítica entre dominios

El jefe de analítica necesita ver a través de los equipos. Simple — registra múltiples buckets:

dataspoc-lens add-bucket s3://company-finance
dataspoc-lens add-bucket s3://company-product
dataspoc-lens add-bucket s3://company-marketing

Ahora puede hacer JOIN entre dominios:

SELECT
    p.user_id,
    p.plan,
    f.lifetime_value,
    m.acquisition_channel
FROM product_users p
JOIN finance_customer_360 f ON p.user_id = f.customer_id
JOIN marketing_attribution m ON p.user_id = m.user_id
WHERE p.plan = 'enterprise';

Esto solo funcióna si el rol IAM del analista tiene acceso de lectura a los tres buckets. El modelo de acceso es:

Principios de data mesh mapeados a DataSpoc

El contrato de datos: convención de bucket

Los equipos acuerdan una cosa — la estructura del bucket:

s3://team-bucket/
  .dataspoc/manifest.json          # What tables exist (auto-generated)
  raw/<source>/<table>/*.parquet   # Raw ingested data
  curated/<domain>/<table>/*.parquet # Cleaned data
  gold/<domain>/<table>/*.parquet  # Business-ready aggregations

Este es el único contrato entre equipos. Si el equipo A quiere compartir datos con el equipo B, otorga IAM de lectura en su bucket. El equipo B lo registra con dataspoc-lens add-bucket. Listo.

Sin API que construir. Sin catálogo de datos que mantener. Sin reuniones de gobernanza. El manifiesto ES el catálogo.

Escalando: de 1 equipo a 20

Team 1:  pip install → bucket → pipe → lens → agent    (30 min)
Team 2:  pip install → bucket → pipe → lens → agent    (30 min)
Team 3:  pip install → bucket → pipe → lens → agent    (30 min)
...
Team 20: pip install → bucket → pipe → lens → agent    (30 min)

Cada equipo es independiente. Agregar el equipo 20 no afecta a los equipos 1-19. Sin Airflow compartido. Sin warehouse compartido. Sin cómputo compartido.

Lo que hace un “equipo de plataforma” en este modelo:

• Crea buckets y políticas IAM para nuevos equipos (5 min por equipo)
• Mantiene el acceso del analista entre dominios
• Ayuda a los equipos con su primera configuración de pipeline (oferta de servicio)
• Eso es todo. Sin Kubernetes. Sin Terraform. Sin equipo de 5 personas.

Costo por equipo

Para una empresa de 10 equipos: $30-50/mes total. Compara con Databricks ($30k-100k/año) o Snowflake ($24k-120k/año).

Cuándo esto no funcióna

Siendo honestos:

• Escala de petabytes por equipo — DuckDB no lo maneja. Necesitas Spark/Trino.
• Requisitos de tiempo real — DataSpoc es batch. Necesitas Kafka + Flink.
• Gobernanza/cumplimiento pesado — Necesitas un catálogo de datos real (DataHub, Atlan). Manifest.json es mínimo.
• 100+ fuentes de datos por equipo — Gestionar muchos taps de Singer puede volverse complejo. Considera Meltano.
• Equipo con cero habilidades técnicas — Necesitan cómodidad con CLI. Si no pueden pip install, usa Fivetran + Looker.

Pruébalo

Configura tu primer dominio en 10 minutos:

pip install dataspoc-pipe[s3] dataspoc-lens[s3,mcp]

# Create your domain
dataspoc-pipe init
dataspoc-pipe add my-source
dataspoc-pipe run my-source

# Query your domain
dataspoc-lens init
dataspoc-lens add-bucket s3://my-team-data
dataspoc-lens shell

# Connect your team's AI agent
dataspoc-lens mcp

Data mesh no es un producto que compras. Es un patrón que sigues. DataSpoc hace el patrón trivial: un bucket por equipo, pip install, listo.