Capsule 05: Selection Costs and Trade-offs

Capsule description

Choosing a vector database is not just about comparing technical features: it's a financial decision that directly impacts your startup's runway, your team's budget, or your product's profitability. A managed provider's "list price" represents barely 30-40% of the real cost. The rest are hidden costs: engineering hours, data egress, support, future migration, and the opportunity cost of not building product.

In this capsule you'll learn to calculate the real Total Cost of Ownership (TCO) of each option, identify the hidden costs nobody mentions on pricing pages, and build cost models for three concrete scales: 10K, 100K, and 1M vectors. In the end, you'll have a replicable formula for any infrastructure decision, not just vector databases.

The goal is not to find "the cheapest", but to find the option that maximizes value delivered per dollar invested in your specific context.

The total cost formula (TCO)

Most teams make the mistake of comparing only the service price. The real TCO includes four dimensions:

TCO = Infrastructure Cost
    + Operational Cost (team hours × rate)
    + Risk Cost (incidents × probability × impact)
    + Opportunity Cost (undelivered features)

Dimension 1: Infrastructure Cost

It's the most visible but not the largest. It includes:

Dimension 2: Operational Cost

This is where the real difference appears. Calculate with this table:

# Average hourly rate per engineer
JUNIOR_RATE = 30   # USD/hr
MID_RATE = 60      # USD/hr
SENIOR_RATE = 100  # USD/hr

# Typical monthly operation hours
operation_hours = {
    "chromadb_self": {
        "monitoring": 4,
        "updates_patches": 2,
        "scaling_manual": 3,
        "backups_recovery": 2,
        "debugging": 3,
        "total": 14  # hours/month
    },
    "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
    }
}

# Monthly operational cost with a mid-level engineer
for provider, hours in operation_hours.items():
    monthly_cost = hours["total"] * MID_RATE
    print(f"{provider}: {hours['total']}h/month = ${monthly_cost}/month")

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

Dimension 3: Risk Cost

Every incident has a cost. The formula:

Risk cost = Σ (probability × frequency × cost per incident)

Concrete example:

• Self-hosted: 2 incidents/quarter × 3h average × $500/h impact = $3,000/quarter
• Managed: 0.5 incidents/quarter × 1h average × $500/h impact = $250/quarter

Dimension 4: Opportunity Cost

The hardest to calculate but frequently the largest:

# If your team spends 14h/month operating the DB instead of building features:
features_delayed_hours = 14  # hours/month redirected to operations
feature_value_per_hour = 200  # USD of product value per dev hour

opportunity_cost = features_delayed_hours * feature_value_per_hour
print(f"Opportunity cost: ${opportunity_cost}/month")
# Opportunity cost: $2,800/month

Provider pricing models

Pricing per stored vector

Pinecone uses this model. You pay for the number of vectors you have stored:

Calculation for different scales:

pinecone_costs = {
    "10K_vectors": {
        "storage": 0,           # Within the free tier
        "queries": 0,           # Included in starter
        "monthly": 0,
        "note": "Free tier covers this"
    },
    "100K_vectors": {
        "storage": 0,           # Free tier limit
        "queries": 0,
        "monthly": 0,
        "note": "Right at the free limit. One more vector → Standard"
    },
    "1M_vectors": {
        "storage": 80,          # ~$0.08/1K × 1000
        "queries": 0,           # Included in Standard
        "monthly": 80,
        "note": "Standard tier required"
    }
}

Pricing per capacity (pods/instances)

Weaviate Cloud and Qdrant Cloud use variants of this model:

Self-hosted pricing (infrastructure)

For ChromaDB, Milvus, Qdrant, or Weaviate self-hosted:

Hidden costs nobody mentions

1. Data egress

Every time your application reads data from the vector DB, you pay for the network traffic:

# Example: API in AWS us-east-1, DB in AWS us-west-2
queries_per_day = 10_000
avg_response_size_kb = 5  # 10 results × 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"Monthly egress: {monthly_egress_gb:.2f} GB = ${egress_cost:.2f}/month")
# Monthly egress: 1.43 GB = $0.13/month (low for 10K queries)

# But with 1M queries/day:
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"High egress: {monthly_egress_gb_high:.2f} GB = ${egress_cost_high:.2f}/month")
# High egress: 143.05 GB = $12.87/month

2. Embedding generation cost

Before storing vectors, you need to generate them. This cost is always forgotten:

# Re-indexing cost (when you need to re-generate 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"Cost to re-index 1M docs: ${reindex_cost:.2f}")
# Cost to re-index 1M docs: $10.00

# But if you switch embedding models, you pay DOUBLE!
# Old model to compare + new model to migrate

3. Migration cost

Switching providers is not free:

migration_costs = {
    "engineering_time": {
        "hours": 40,         # 1 week of a senior engineer
        "rate": 100,
        "cost": 4_000
    },
    "dual_running": {
        "months": 1,         # Run both providers in parallel
        "extra_cost": 150,   # Cost of the new provider while you migrate
        "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"Total migration cost: ${total:,}")
# Total migration cost: $7,160

4. Premium support

5. Compliance and audit cost

If your application handles regulated data (GDPR, HIPAA, SOC2):

• Self-hosted: You are responsible → audit: $5,000-20,000/year
• Managed with certification: The provider has certifications → verification: $1,000-5,000/year
• Managed without certification: Not viable → infinite cost (you can't use it)

Concrete TCO calculations by scale

Scenario A: 10,000 vectors (PoC / MVP)

Context: A startup in the validation phase, a team of 2-3 devs, limited budget.

Winner: Pinecone Free or Qdrant Cloud Free At this scale, the free tiers cover everything. Self-hosted makes no sense.

Scenario B: 100,000 vectors (Product in validation)

Context: A product with initial traction, 50-200 users, a team of 3-5 devs.

Winner: Weaviate Cloud or Qdrant Cloud The operational cost of self-hosted dominates. Managed is 5-6x cheaper in real TCO.

Scenario C: 1,000,000 vectors (Production at scale)

Context: An established product, 1,000+ users, a team with dedicated DevOps.

Winner: Qdrant Cloud or Weaviate Cloud Self-hosted wins only on direct infra, but the operational cost makes it 4x more expensive in TCO.

Exception: If your team already has infrastructure and dedicated DevOps, the operational cost of self-hosted drops significantly (from 14h to 4-6h/month), making self-hosted competitive.

Cost projection scenarios

Never decide with a single snapshot of the present. Always evaluate three scenarios:

12-month projection (starting with 100K vectors)

import matplotlib.pyplot as plt

months = list(range(1, 13))

# Conservative scenario: 5% monthly growth
conservative = [100_000 * (1.05 ** m) for m in months]

# Expected scenario: 15% monthly growth
expected = [100_000 * (1.15 ** m) for m in months]

# Aggressive scenario: 30% monthly growth
aggressive = [100_000 * (1.30 ** m) for m in months]

for i, month in enumerate(months):
    print(f"Month {month:2d}: "
          f"Conservative={conservative[i]:>10,.0f} | "
          f"Expected={expected[i]:>10,.0f} | "
          f"Aggressive={aggressive[i]:>10,.0f}")

Month  1: Conservative=   105,000 | Expected=   115,000 | Aggressive=   130,000
Month  3: Conservative=   115,763 | Expected=   152,088 | Aggressive=   219,700
Month  6: Conservative=   134,010 | Expected=   231,306 | Aggressive=   482,681
Month  9: Conservative=   155,133 | Expected=   351,788 | Aggressive= 1,060,449
Month 12: Conservative=   179,586 | Expected=   535,025 | Aggressive= 2,329,809

Key insight:

• Conservative: You stay in the same tier for 12 months
• Expected: You need a tier upgrade in month 6-8
• Aggressive: You need a provider migration in month 8-10

Cost impact of each scenario

Scenario      | Month 1  | Month 6  | Month 12  | Change trigger
--------------|----------|----------|-----------|--------------------
Conservative  | $250/mo  | $280/mo  | $320/mo   | None
Expected      | $250/mo  | $400/mo  | $800/mo   | Upgrade tier month 6
Aggressive    | $250/mo  | $700/mo  | $2,500/mo | Migrate month 8

Trade-offs you must make explicit with your team

Trade-off 1: Simplicity vs Control

                SIMPLICITY ◄──────────────────────► CONTROL

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

Questions for your team:

• Do we have dedicated DevOps or do the devs do everything?
• How many hours/month are we willing to invest in operations?
• Do we need to customize the index configuration?

Trade-off 2: Direct cost vs Operational cost

If your team charges >$40/hr, managed almost always wins.

Trade-off 3: Time-to-market vs Customization

Weeks to production:

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

Cost of each week of delay:

weekly_burn_rate = 15_000  # USD for a 5-person startup
weeks_saved_managed = 3    # fewer weeks vs self-hosted

value_of_speed = weeks_saved_managed * weekly_burn_rate
print(f"Value of going managed: ${value_of_speed:,} in saved burn rate")
# Value of going managed: $45,000 in saved burn rate

Trade-off 4: Vendor lock-in vs Speed

Lock-in mitigation:

# Abstraction pattern to reduce lock-in
from abc import ABC, abstractmethod
from typing import List, Dict, Any

class VectorStore(ABC):
    """Abstract interface that decouples your code from the provider."""

    @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)

# Migrating to Pinecone = implement PineconeStore(VectorStore)
# Your application code does NOT change

Cost troubleshooting

1. "Self-hosted comes out cheaper on paper"

Symptom: The spreadsheet shows that self-hosted costs $50/mo vs $200/mo managed.

Diagnosis: You're only counting direct infrastructure. You're missing:

• Operation hours: 10-14h/month × the team's rate
• Incident risk: 2-4 per quarter
• Opportunity cost: undelivered features

Solution: Recalculate with the complete TCO formula. If your team charges >$40/hr, managed almost always wins in real TCO.

2. "Managed looks super expensive at first"

Symptom: $200/mo for Pinecone when you could have a $12 droplet.

Diagnosis: You're comparing service price vs infra price, not TCO vs TCO.

Solution: Calculate how many engineering hours you save. If you save 10h/month at $60/hr, managed "saves" you $400/mo net.

3. "I don't have traffic history to project"

Symptom: You don't know if you'll have 10K or 1M vectors in 6 months.

Solution: Project by ranges with three scenarios (conservative, expected, aggressive). Choose the provider that works for all three scenarios, or define an explicit migration trigger.

4. "Prices changed since I calculated"

Symptom: You chose a provider 6 months ago, the pricing changed.

Solution: Schedule a TCO review every quarter. Managed providers change prices frequently. Keep your spreadsheet updated and compare against alternatives every 3-6 months.

5. "The free tier is enough today but I don't know until when"

Symptom: You're on Pinecone Free with 80K vectors. The limit is 100K.

Solution: Calculate the estimated date you'll hit the limit at your growth rate. Have the budget ready for the next tier BEFORE hitting the limit.

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

import math
months_until_limit = math.log(limit / current_vectors) / math.log(1 + monthly_growth_rate)
print(f"Months until the limit: {months_until_limit:.1f}")
# Months until the limit: 1.6

Practical exercises

Exercise 1: Calculate your real TCO

Build a 6-month TCO table comparing two options for your Decision Tree project:

Final question: Which option minimizes total risk for your current stage?

Exercise 2: Growth projection

Your product has 30K vectors today and grows 20% monthly. Calculate:

1. In which month do you reach 100K vectors?
2. In which month do you reach 500K vectors?
3. How much will month 12 cost vs month 1?

import math

current = 30_000
growth = 0.20

# 1. When do you reach 100K?
months_100k = math.log(100_000 / current) / math.log(1.20)
print(f"100K vectors in month: {months_100k:.1f}")  # Month 6.6

# 2. When do you reach 500K?
months_500k = math.log(500_000 / current) / math.log(1.20)
print(f"500K vectors in month: {months_500k:.1f}")  # Month 15.4

# 3. Vectors in month 12
vectors_month_12 = current * (1.20 ** 12)
print(f"Vectors month 12: {vectors_month_12:,.0f}")  # 267,483

# Month 1 cost (Qdrant Cloud, 30K vectors): ~$33/mo
# Month 12 cost (Qdrant Cloud, 267K vectors): ~$100/mo

Exercise 3: Break-even managed vs self-hosted

At what hourly rate for your team does managed become worth it over self-hosted?

Data:

• Self-hosted: $50/mo infra + 12h/mo operations
• Managed: $200/mo service + 2h/mo operations

# 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 at ${rate_breakeven:.0f}/hr")

# If your team charges > $15/hr → managed wins
# Most engineers charge $30-150/hr
# Conclusion: managed almost always wins

Exercise 4: Migration simulator

Your startup chose ChromaDB self-hosted 8 months ago. Now it has 500K vectors and the team spends 16h/mo on operations. Is it worth migrating to managed?

# Current cost (ChromaDB self-hosted, 500K vectors)
current_infra = 60        # AWS t3.large
current_ops = 16 * 80     # 16h × $80/hr mid-senior
current_risk = 400        # estimated
current_monthly = current_infra + current_ops + current_risk
# $1,740/mo

# Post-migration cost (Qdrant Cloud)
new_service = 150         # tier for 500K
new_ops = 2 * 80          # 2h × $80/hr
new_risk = 50
new_monthly = new_service + new_ops + new_risk
# $360/mo

# Migration cost (one-time)
migration_cost = 7_000    # engineering + downtime + re-embedding

# Monthly savings
monthly_savings = current_monthly - new_monthly
# $1,380/mo

# Payback period
payback = migration_cost / monthly_savings
print(f"Migration payback: {payback:.1f} months")
# Migration payback: 5.1 months

# Year 1 savings (discounting migration)
year_1_savings = (monthly_savings * 12) - migration_cost
print(f"Year 1 savings: ${year_1_savings:,.0f}")
# Year 1 savings: $9,560

Exercise 5: Sensitivity analysis

How does your decision change if your team's rate is $30/hr vs $100/hr vs $150/hr?

Connection with the project: Decision Tree

In your final Decision Tree project, include a cost analysis section that applies these concepts:

1. Calculate the TCO for the 2-3 finalist options from your decision matrix
2. Project 12 months out with three growth scenarios
3. Identify the migration trigger: at what volume or monthly cost will you re-evaluate?
4. Document the hidden costs you identified for your specific case

Summary

• The list price is not the real cost. TCO includes infrastructure, operations, risk, and opportunity.
• The operational cost dominates in most cases. Engineering hours > service price.
• Managed wins in TCO for teams where an engineer's hour costs >$15/hr.
• Self-hosted wins only when you have dedicated DevOps AND need fine control of the index.
• Free tiers are excellent for PoC (10K-100K vectors), but plan the jump to the paid tier.
• Always project three scenarios: conservative, expected, and aggressive.
• The migration cost is real: $5,000-15,000, so choose well from the start.
• Review your TCO every quarter. Managed prices change, your scale grows.

Additional resources

1. AWS Pricing Calculator — Official estimator for AWS infrastructure costs
2. GCP Pricing Calculator — Official Google Cloud estimator
3. Pinecone Pricing — Pinecone's current pricing and calculator
4. Qdrant Cloud Pricing — Qdrant managed tiers and prices
5. Weaviate Pricing — Weaviate Cloud pricing
6. OpenAI Embeddings Pricing — Embedding generation costs
7. FinOps Foundation — Framework for cloud cost management
8. ANN Benchmarks — Performance benchmarks for sizing infrastructure

Estimated time: 25-35 minutes
Next: 06-when-to-choose-each-option.md