Cápsula 05: Costos y Trade-offs de Selección

Descripción de la cápsula

Elegir una vector database no es solo comparar features técnicos: es una decisión financiera que impacta directamente el runway de tu startup, el presupuesto de tu equipo o la rentabilidad de tu producto. El "precio de lista" de un proveedor managed representa apenas el 30-40% del costo real. El resto son costos ocultos: horas de ingeniería, egress de datos, soporte, migración futura y el costo de oportunidad de no estar construyendo producto.

En esta cápsula vas a aprender a calcular el Total Cost of Ownership (TCO) real de cada opción, identificar los costos ocultos que nadie menciona en las páginas de pricing, y construir modelos de costo para tres escalas concretas: 10K, 100K y 1M vectores. Al final, tendrás una fórmula replicable para cualquier decisión de infraestructura, no solo vector databases.

La meta no es encontrar "lo más barato", sino encontrar la opción que maximiza valor entregado por dólar invertido en tu contexto específico.

La fórmula de costo total (TCO)

La mayoría de equipos cometen el error de comparar solo el precio del servicio. El TCO real incluye cuatro dimensiones:

TCO = Costo de Infraestructura
    + Costo de Operación (horas equipo × tarifa)
    + Costo de Riesgo (incidentes × probabilidad × impacto)
    + Costo de Oportunidad (features no entregadas)

Dimensión 1: Costo de Infraestructura

Es el más visible pero no el más grande. Incluye:

Dimensión 2: Costo de Operación

Aquí es donde la diferencia real aparece. Calcula con esta tabla:

# Tarifa promedio por hora de ingeniero
JUNIOR_RATE = 30   # USD/hr
MID_RATE = 60      # USD/hr
SENIOR_RATE = 100  # USD/hr

# Horas mensuales de operación típicas
operation_hours = {
    "chromadb_self": {
        "monitoring": 4,
        "updates_patches": 2,
        "scaling_manual": 3,
        "backups_recovery": 2,
        "debugging": 3,
        "total": 14  # horas/mes
    },
    "qdrant_self": {
        "monitoring": 3,
        "updates_patches": 2,
        "scaling_manual": 2,
        "backups_recovery": 1,
        "debugging": 2,
        "total": 10
    },
    "pinecone_managed": {
        "monitoring": 1,
        "updates_patches": 0,
        "scaling_manual": 0,
        "backups_recovery": 0,
        "debugging": 1,
        "total": 2
    },
    "weaviate_cloud": {
        "monitoring": 1,
        "updates_patches": 0,
        "scaling_manual": 0,
        "backups_recovery": 0,
        "debugging": 1,
        "total": 2
    }
}

# Costo operativo mensual con ingeniero mid-level
for provider, hours in operation_hours.items():
    monthly_cost = hours["total"] * MID_RATE
    print(f"{provider}: {hours['total']}h/mes = ${monthly_cost}/mes")

chromadb_self:    14h/mes = $840/mes
qdrant_self:     10h/mes = $600/mes
pinecone_managed: 2h/mes = $120/mes
weaviate_cloud:   2h/mes = $120/mes

Dimensión 3: Costo de Riesgo

Cada incidente tiene un costo. La fórmula:

Costo de riesgo = Σ (probabilidad × frecuencia × costo por incidente)

Ejemplo concreto:

• Self-hosted: 2 incidentes/trimestre × 3h promedio × $500/h impacto = $3,000/trimestre
• Managed: 0.5 incidentes/trimestre × 1h promedio × $500/h impacto = $250/trimestre

Dimensión 4: Costo de Oportunidad

El más difícil de calcular pero frecuentemente el más grande:

# Si tu equipo dedica 14h/mes a operar la DB en vez de construir features:
features_delayed_hours = 14  # horas/mes redirigidas a operación
feature_value_per_hour = 200  # USD de valor de producto por hora de dev

opportunity_cost = features_delayed_hours * feature_value_per_hour
print(f"Costo de oportunidad: ${opportunity_cost}/mes")
# Costo de oportunidad: $2,800/mes

Modelos de pricing de proveedores

Pricing por vector almacenado

Pinecone usa este modelo. Pagas por la cantidad de vectores que tienes almacenados:

Cálculo para diferentes escalas:

pinecone_costs = {
    "10K_vectors": {
        "storage": 0,           # Dentro del tier gratuito
        "queries": 0,           # Incluidas en starter
        "monthly": 0,
        "note": "Free tier cubre esto"
    },
    "100K_vectors": {
        "storage": 0,           # Límite del tier gratuito
        "queries": 0,
        "monthly": 0,
        "note": "Justo en el límite free. Un vector más → Standard"
    },
    "1M_vectors": {
        "storage": 80,          # ~$0.08/1K × 1000
        "queries": 0,           # Incluidas en Standard
        "monthly": 80,
        "note": "Standard tier requerido"
    }
}

Pricing por capacidad (pods/instancias)

Weaviate Cloud y Qdrant Cloud usan variantes de este modelo:

Pricing self-hosted (infraestructura)

Para ChromaDB, Milvus, Qdrant o Weaviate self-hosted:

Costos ocultos que nadie menciona

1. Egress de datos

Cada vez que tu aplicación lee datos de la vector DB, pagas por el tráfico de red:

# Ejemplo: API en AWS us-east-1, DB en AWS us-west-2
queries_per_day = 10_000
avg_response_size_kb = 5  # 10 resultados × 500 bytes metadata
days_per_month = 30

monthly_egress_gb = (queries_per_day * avg_response_size_kb * days_per_month) / (1024 * 1024)
egress_cost = monthly_egress_gb * 0.09  # AWS inter-region

print(f"Egress mensual: {monthly_egress_gb:.2f} GB = ${egress_cost:.2f}/mes")
# Egress mensual: 1.43 GB = $0.13/mes (bajo para 10K queries)

# Pero con 1M queries/día:
monthly_egress_gb_high = (1_000_000 * avg_response_size_kb * 30) / (1024 * 1024)
egress_cost_high = monthly_egress_gb_high * 0.09
print(f"Egress alto: {monthly_egress_gb_high:.2f} GB = ${egress_cost_high:.2f}/mes")
# Egress alto: 143.05 GB = $12.87/mes

2. Costo de embedding generation

Antes de almacenar vectores, necesitas generarlos. Este costo se olvida siempre:

# Re-indexing cost (cuando necesitas re-generar embeddings)
docs = 1_000_000
tokens_per_doc = 500
price_per_million_tokens = 0.02  # text-embedding-3-small

reindex_cost = (docs * tokens_per_doc / 1_000_000) * price_per_million_tokens
print(f"Costo de re-indexar 1M docs: ${reindex_cost:.2f}")
# Costo de re-indexar 1M docs: $10.00

# ¡Pero si cambias de modelo de embeddings, pagas DOBLE!
# Modelo viejo para comparar + modelo nuevo para migrar

3. Costo de migración

Cambiar de proveedor no es gratis:

migration_costs = {
    "engineering_time": {
        "hours": 40,         # 1 semana de un ingeniero senior
        "rate": 100,
        "cost": 4_000
    },
    "dual_running": {
        "months": 1,         # Correr ambos proveedores en paralelo
        "extra_cost": 150,   # Costo del proveedor nuevo mientras migras
        "cost": 150
    },
    "re_embedding": {
        "docs": 1_000_000,
        "cost": 10           # text-embedding-3-small
    },
    "testing_validation": {
        "hours": 20,
        "rate": 100,
        "cost": 2_000
    },
    "downtime_risk": {
        "estimated_hours": 2,
        "revenue_per_hour": 500,
        "cost": 1_000
    }
}

total = sum(item["cost"] for item in migration_costs.values())
print(f"Costo total de migración: ${total:,}")
# Costo total de migración: $7,160

4. Soporte premium

5. Costo de compliance y auditoría

Si tu aplicación maneja datos regulados (GDPR, HIPAA, SOC2):

• Self-hosted: Tú eres responsable → auditoría: $5,000-20,000/año
• Managed con certificación: El proveedor tiene certificaciones → verificación: $1,000-5,000/año
• Managed sin certificación: No viable → costo infinito (no puedes usarlo)

Cálculos concretos de TCO por escala

Escenario A: 10,000 vectores (PoC / MVP)

Contexto: Startup en fase de validación, equipo de 2-3 devs, budget limitado.

Ganador: Pinecone Free o Qdrant Cloud Free A esta escala, los tiers gratuitos cubren todo. No tiene sentido self-hosted.

Escenario B: 100,000 vectores (Producto en validación)

Contexto: Producto con tracción inicial, 50-200 usuarios, equipo de 3-5 devs.

Ganador: Weaviate Cloud o Qdrant Cloud El costo operativo de self-hosted domina. Managed es 5-6x más barato en TCO real.

Escenario C: 1,000,000 vectores (Producción a escala)

Contexto: Producto establecido, 1,000+ usuarios, equipo con DevOps dedicado.

Ganador: Qdrant Cloud o Weaviate Cloud Self-hosted solo gana en infra directa, pero el costo operativo lo hace 4x más caro en TCO.

Excepción: Si tu equipo ya tiene infraestructura y DevOps dedicado, el costo operativo de self-hosted baja significativamente (de 14h a 4-6h/mes), haciendo que self-hosted sea competitivo.

Escenarios de proyección de costo

Nunca decidas con una sola foto del presente. Evalúa siempre tres escenarios:

Proyección a 12 meses (empezando con 100K vectores)

import matplotlib.pyplot as plt

months = list(range(1, 13))

# Escenario conservador: crecimiento 5% mensual
conservative = [100_000 * (1.05 ** m) for m in months]

# Escenario esperado: crecimiento 15% mensual
expected = [100_000 * (1.15 ** m) for m in months]

# Escenario agresivo: crecimiento 30% mensual
aggressive = [100_000 * (1.30 ** m) for m in months]

for i, month in enumerate(months):
    print(f"Mes {month:2d}: "
          f"Conservador={conservative[i]:>10,.0f} | "
          f"Esperado={expected[i]:>10,.0f} | "
          f"Agresivo={aggressive[i]:>10,.0f}")

Mes  1: Conservador=   105,000 | Esperado=   115,000 | Agresivo=   130,000
Mes  3: Conservador=   115,763 | Esperado=   152,088 | Agresivo=   219,700
Mes  6: Conservador=   134,010 | Esperado=   231,306 | Agresivo=   481,584
Mes  9: Conservador=   155,133 | Esperado=   351,788 | Agresivo= 1,060,449
Mes 12: Conservador=   179,586 | Esperado=   535,117 | Agresivo= 2,329,961

Insight clave:

• Conservador: Te mantienes en el mismo tier 12 meses
• Esperado: Necesitas upgrade de tier en mes 6-8
• Agresivo: Necesitas migración de proveedor en mes 8-10

Impacto en costo de cada escenario

Escenario     | Mes 1    | Mes 6    | Mes 12   | Trigger de cambio
--------------|----------|----------|----------|-------------------
Conservador   | $250/mes | $280/mes | $320/mes | Ninguno
Esperado      | $250/mes | $400/mes | $800/mes | Upgrade tier mes 6
Agresivo      | $250/mes | $700/mes | $2,500/mes | Migrar mes 8

Trade-offs que debes explicitar en tu equipo

Trade-off 1: Simplicidad vs Control

                SIMPLICIDAD ◄──────────────────────► CONTROL

Pinecone ████████░░            ░░░░░░░░████ Milvus self-hosted
Weaviate Cloud ███████░░░      ░░░░░░░████░ Qdrant self-hosted
Qdrant Cloud ██████░░░░        ░░░░░████░░ Weaviate self-hosted
                                ░░░████░░░░ ChromaDB self-hosted

Preguntas para tu equipo:

• ¿Tenemos DevOps dedicado o los devs hacen todo?
• ¿Cuántas horas/mes estamos dispuestos a invertir en operación?
• ¿Necesitamos customizar la configuración del índice?

Trade-off 2: Costo directo vs Costo operativo

Si tu equipo cobra >$40/hr, managed casi siempre gana.

Trade-off 3: Time-to-market vs Personalización

Semanas para producción:

ChromaDB self-hosted:  ████████████████ 4-6 semanas
Qdrant self-hosted:    ████████████ 3-4 semanas
Weaviate Cloud:        ████████ 2-3 semanas
Qdrant Cloud:          ████████ 2-3 semanas
Pinecone:              ████ 1-2 semanas

Costo de cada semana de retraso:

weekly_burn_rate = 15_000  # USD para startup de 5 personas
weeks_saved_managed = 3    # semanas menos vs self-hosted

value_of_speed = weeks_saved_managed * weekly_burn_rate
print(f"Valor de ir managed: ${value_of_speed:,} en burn rate ahorrado")
# Valor de ir managed: $45,000 en burn rate ahorrado

Trade-off 4: Vendor lock-in vs Velocidad

Mitigación de lock-in:

# Patrón de abstracción para reducir lock-in
from abc import ABC, abstractmethod
from typing import List, Dict, Any

class VectorStore(ABC):
    """Interfaz abstracta que desacopla tu código del proveedor."""

    @abstractmethod
    def add(self, documents: List[str], embeddings: List[List[float]],
            metadata: List[Dict[str, Any]]) -> List[str]:
        pass

    @abstractmethod
    def query(self, embedding: List[float], top_k: int = 10,
              filters: Dict[str, Any] = None) -> List[Dict]:
        pass

    @abstractmethod
    def delete(self, ids: List[str]) -> None:
        pass

class ChromaStore(VectorStore):
    def __init__(self, collection_name: str):
        import chromadb
        self.client = chromadb.Client()
        self.collection = self.client.get_or_create_collection(collection_name)

    def add(self, documents, embeddings, metadata):
        ids = [f"doc_{i}" for i in range(len(documents))]
        self.collection.add(
            documents=documents, embeddings=embeddings,
            metadatas=metadata, ids=ids
        )
        return ids

    def query(self, embedding, top_k=10, filters=None):
        results = self.collection.query(
            query_embeddings=[embedding], n_results=top_k,
            where=filters
        )
        return results

    def delete(self, ids):
        self.collection.delete(ids=ids)

# Migrar a Pinecone = implementar PineconeStore(VectorStore)
# Tu código de aplicación NO cambia

Troubleshooting de costos

1. "Self-hosted sale más barato en papel"

Síntoma: La hoja de cálculo muestra que self-hosted cuesta $50/mes vs $200/mes managed.

Diagnóstico: Solo estás contando infraestructura directa. Falta:

• Horas de operación: 10-14h/mes × tarifa del equipo
• Riesgo de incidentes: 2-4 por trimestre
• Costo de oportunidad: features no entregadas

Solución: Recalcula con la fórmula TCO completa. Si tu equipo cobra >$40/hr, managed casi siempre gana en TCO real.

2. "Managed se ve carísimo al principio"

Síntoma: $200/mes por Pinecone cuando podrías tener un droplet de $12.

Diagnóstico: Estás comparando precio de servicio vs precio de infra, no TCO vs TCO.

Solución: Calcula cuántas horas de ingeniería ahorras. Si ahorras 10h/mes a $60/hr, managed te "ahorra" $400/mes netos.

3. "No tengo históricos de tráfico para proyectar"

Síntoma: No sabes si tendrás 10K o 1M vectores en 6 meses.

Solución: Proyecta por rangos con tres escenarios (conservador, esperado, agresivo). Elige el proveedor que funcione para los tres escenarios, o define un trigger explícito de migración.

4. "Los precios cambiaron desde que calculé"

Síntoma: Elegiste proveedor hace 6 meses, el pricing cambió.

Solución: Agenda revisión de TCO cada trimestre. Los proveedores managed cambian precios frecuentemente. Mantén tu spreadsheet actualizado y compara contra alternativas cada 3-6 meses.

5. "El free tier me alcanza hoy pero no sé cuándo no"

Síntoma: Estás en Pinecone Free con 80K vectores. El límite es 100K.

Solución: Calcula la fecha estimada en que alcanzarás el límite con tu tasa de crecimiento. Ten listo el presupuesto para el siguiente tier ANTES de alcanzar el límite.

current_vectors = 80_000
limit = 100_000
monthly_growth_rate = 0.15  # 15% mensual

import math
months_until_limit = math.log(limit / current_vectors) / math.log(1 + monthly_growth_rate)
print(f"Meses hasta el límite: {months_until_limit:.1f}")
# Meses hasta el límite: 1.6

Ejercicios prácticos

Ejercicio 1: Calcula tu TCO real

Construye una tabla de TCO para 6 meses comparando dos opciones para tu proyecto del Decision Tree:

Pregunta final: ¿Cuál opción minimiza el riesgo total para tu etapa actual?

Ejercicio 2: Proyección de crecimiento

Tu producto tiene 30K vectores hoy y crece 20% mensual. Calcula:

1. ¿En qué mes alcanzas 100K vectores?
2. ¿En qué mes alcanzas 500K vectores?
3. ¿Cuánto costará el mes 12 vs el mes 1?

import math

current = 30_000
growth = 0.20

# 1. ¿Cuándo llegas a 100K?
months_100k = math.log(100_000 / current) / math.log(1.20)
print(f"100K vectores en mes: {months_100k:.1f}")  # Mes 6.6

# 2. ¿Cuándo llegas a 500K?
months_500k = math.log(500_000 / current) / math.log(1.20)
print(f"500K vectores en mes: {months_500k:.1f}")  # Mes 15.3

# 3. Vectores en mes 12
vectors_month_12 = current * (1.20 ** 12)
print(f"Vectores mes 12: {vectors_month_12:,.0f}")  # 267,215

# Costo mes 1 (Qdrant Cloud, 30K vectors): ~$33/mes
# Costo mes 12 (Qdrant Cloud, 267K vectors): ~$100/mes

Ejercicio 3: Break-even managed vs self-hosted

¿A partir de qué tarifa por hora de tu equipo conviene managed sobre self-hosted?

Datos:

• Self-hosted: $50/mes infra + 12h/mes operación
• Managed: $200/mes servicio + 2h/mes operación

# TCO self-hosted = 50 + 12 × rate
# TCO managed = 200 + 2 × rate
# Break-even: 50 + 12r = 200 + 2r
# 10r = 150
# r = $15/hr

rate_breakeven = (200 - 50) / (12 - 2)
print(f"Break-even a ${rate_breakeven:.0f}/hr")

# Si tu equipo cobra > $15/hr → managed gana
# La mayoría de ingenieros cobra $30-150/hr
# Conclusión: managed casi siempre gana

Ejercicio 4: Simulador de migración

Tu startup eligió ChromaDB self-hosted hace 8 meses. Ahora tiene 500K vectores y el equipo dedica 16h/mes a operación. ¿Vale la pena migrar a managed?

# Costo actual (ChromaDB self-hosted, 500K vectores)
current_infra = 60        # AWS t3.large
current_ops = 16 * 80     # 16h × $80/hr mid-senior
current_risk = 400        # estimado
current_monthly = current_infra + current_ops + current_risk
# $1,740/mes

# Costo post-migración (Qdrant Cloud)
new_service = 150         # tier para 500K
new_ops = 2 * 80          # 2h × $80/hr
new_risk = 50
new_monthly = new_service + new_ops + new_risk
# $360/mes

# Costo de migración (una vez)
migration_cost = 7_000    # ingeniería + downtime + re-embedding

# Ahorro mensual
monthly_savings = current_monthly - new_monthly
# $1,380/mes

# Payback period
payback = migration_cost / monthly_savings
print(f"Payback de migración: {payback:.1f} meses")
# Payback de migración: 5.1 meses

# Ahorro año 1 (descontando migración)
year_1_savings = (monthly_savings * 12) - migration_cost
print(f"Ahorro año 1: ${year_1_savings:,.0f}")
# Ahorro año 1: $9,560

Ejercicio 5: Análisis de sensibilidad

¿Cómo cambia tu decisión si la tarifa de tu equipo es $30/hr vs $100/hr vs $150/hr?

Conexión con proyecto: Decision Tree

En tu proyecto final de Decision Tree, incluye una sección de análisis de costos que aplique estos conceptos:

1. Calcula el TCO para las 2-3 opciones finalistas de tu matriz de decisión
2. Proyecta a 12 meses con tres escenarios de crecimiento
3. Identifica el trigger de migración: ¿a qué volumen o costo mensual re-evaluarás?
4. Documenta los costos ocultos que identificaste para tu caso específico

Resumen

• El precio de lista no es el costo real. El TCO incluye infraestructura, operación, riesgo y oportunidad.
• El costo operativo domina en la mayoría de los casos. Horas de ingeniería > precio del servicio.
• Managed gana en TCO para equipos donde la hora de ingeniero cuesta >$15/hr.
• Self-hosted gana solo cuando tienes DevOps dedicado Y necesitas control fino del índice.
• Los tiers gratuitos son excelentes para PoC (10K-100K vectores), pero planea el salto al tier pagado.
• Proyecta siempre en tres escenarios: conservador, esperado y agresivo.
• El costo de migración es real: $5,000-15,000, así que elige bien desde el inicio.
• Revisa tu TCO cada trimestre. Los precios de managed cambian, tu escala crece.

Recursos adicionales

1. AWS Pricing Calculator — Estimador oficial de costos de infraestructura AWS
2. GCP Pricing Calculator — Estimador oficial de Google Cloud
3. Pinecone Pricing — Pricing actual y calculadora de Pinecone
4. Qdrant Cloud Pricing — Tiers y precios de Qdrant managed
5. Weaviate Pricing — Pricing de Weaviate Cloud
6. OpenAI Embeddings Pricing — Costos de generación de embeddings
7. FinOps Foundation — Framework para gestión de costos en la nube
8. ANN Benchmarks — Benchmarks de performance para dimensionar infraestructura

Tiempo estimado: 25-35 minutos
Siguiente: 06-cuando-elegir-cada-opcion.md