Capsule 06: When to Choose Each Option

Capsule description

After comparing features, analyzing managed vs self-hosted architectures, and calculating real costs, the moment of truth arrives: choosing. But choosing is not betting. It's building a decision framework that any member of your team can follow and defend with data.

This capsule gives you a decision system based on 5 concrete variables: team size, budget, data scale, latency requirements, and compliance constraints. You won't memorize which provider is "best" — you'll learn to derive the right answer for any combination of variables.

In the end you'll have a complete decision tree that you can apply to your current project and to any future vector infrastructure decision.

The 5 decision variables

Every vector database selection comes down to these five variables. The most common mistake is deciding by looking at only one or two.

Variable 1: Team size and profile

Team        | Profile                          | Implication
------------|----------------------------------|----------------------------------
1-2 devs    | Generalists, no DevOps           | Managed mandatory
3-5 devs    | Mix, possibly 1 with infra skills| Managed preferred, self-hosted viable
5-10 devs   | Defined roles, partial DevOps    | Both options viable
10+ devs    | Dedicated DevOps, SRE            | Self-hosted viable and potentially preferred

Rule: If nobody on your team can be woken up at 3am to fix a downed node, you need managed.

Variable 2: Available monthly budget

Budget       | Range          | Viable options
-------------|----------------|------------------------------------------
$0           | Validation     | Free tiers: Pinecone Free, Qdrant Free, ChromaDB local
$0-100/mo    | PoC/MVP        | Free tiers + ChromaDB on a basic droplet
$100-500/mo  | Early product  | Qdrant Cloud, Weaviate Cloud, Pinecone Standard
$500-2K/mo   | Production     | Any managed, self-hosted on a good server
$2K+/mo      | Enterprise     | Enterprise tiers, self-hosted cluster, hybrid

Variable 3: Current and projected scale

Vectors           | Classification | Considerations
------------------|---------------|------------------------------------------
< 10K             | Tiny          | Any option works, including numpy
10K - 100K        | Small         | Free tiers sufficient
100K - 500K       | Medium        | You need a paid tier or self-hosted with RAM
500K - 5M         | Large         | Performance and costs matter
5M - 50M          | Very Large    | Sharding, replication needed
> 50M             | Massive       | Only enterprise options

Variable 4: Latency requirements

p95 latency     | Typical use case                | Viable options
----------------|--------------------------------|---------------------------
< 10ms          | Autocomplete, real-time         | Pinecone, Qdrant (optimized)
10-50ms         | Interactive search              | Any managed, well-configured self-hosted
50-200ms        | RAG in a chatbot                | All options
200-1000ms      | Batch processing                | All, including pgvector
> 1000ms        | Offline analysis                | You don't need a specialized vector DB

Variable 5: Compliance constraints

Level          | Requirements                    | Viable options
---------------|--------------------------------|----------------------------------
None           | No specific regulation          | Any provider
Basic          | Data in a specific region       | Managed with region selection
Medium         | GDPR, personal data             | Managed with a DPA or self-hosted in your infra
High           | HIPAA, medical data             | Self-hosted or enterprise with certification
Critical       | Government, defense, financial   | Self-hosted in exclusively audited infra

Decision Tree: the complete framework

Follow this decision tree step by step. Each node is a question with binary answers.

Level 1: Do you need a dedicated vector DB?

Do you have > 10K vectors AND need search < 500ms?
├── NO → Use numpy/FAISS in memory or pgvector if you already have Postgres
│        (You don't need a dedicated vector DB. Review Capsule 07 of Module 1)
└── YES → Continue to Level 2

Level 2: Managed or Self-hosted?

Does your team have dedicated DevOps (>= 1 person with >50% of their time)?
├── NO → MANAGED (continue to Level 3A)
└── YES → Do you have compliance constraints that prevent managed?
         ├── YES → SELF-HOSTED (continue to Level 3B)
         └── NO → Does your budget allow managed ($100+/mo)?
                  ├── YES → MANAGED (continue to Level 3A)
                  │        (Managed is still preferred for TCO)
                  └── NO → SELF-HOSTED (continue to Level 3B)

Level 3A: Managed provider selection

How many vectors do you have/project for 6 months?

< 100K vectors:
├── Budget = $0? → Pinecone Free (100K limit) or Qdrant Cloud Free (1GB)
├── Need latency < 20ms? → Pinecone Standard
└── Budget < $50/mo? → Qdrant Cloud Standard

100K - 1M vectors:
├── Priority is latency? → Pinecone Standard
├── Priority is cost? → Qdrant Cloud
└── Need native hybrid search? → Weaviate Cloud

1M - 10M vectors:
├── Need auto-scaling? → Pinecone Standard/Enterprise
├── Priority is cost? → Qdrant Cloud (scales well)
└── Need GraphQL + modules? → Weaviate Cloud

> 10M vectors:
├── Budget > $2K/mo? → Pinecone Enterprise or Qdrant Enterprise
└── Limited budget? → Consider self-hosted (Level 3B)

Level 3B: Self-hosted provider selection

How many vectors do you have/project for 6 months?

< 500K vectors:
├── Want minimal setup (pip install)? → ChromaDB
├── Need a production-ready REST API? → Qdrant
└── Already using Kubernetes? → Weaviate with a Helm chart

500K - 5M vectors:
├── Priority is pure performance? → Qdrant (Rust-based)
├── Need hybrid search + modules? → Weaviate
└── Team already knows Go? → Milvus

> 5M vectors:
├── Need horizontal sharding? → Milvus or Qdrant cluster
├── Team has Kubernetes experience? → Weaviate or Milvus
└── Budget for dedicated hardware? → Qdrant cluster on bare metal

Quick rules by product stage

Stage 1: Discovery / PoC (0-3 months)

Goal: Validate that vector search solves the user's problem.

Decision criteria:

• Setup speed > everything else
• $0 infrastructure ideal
• Doesn't matter if it scales
• Vendor lock-in doesn't matter

Recommendations:

Anti-rule: Do NOT spend more than 1 day on infrastructure at this stage.

Stage 2: Business validation (3-6 months)

Goal: Confirm product-market fit with real users.

Decision criteria:

• Latency < 200ms for acceptable UX
• Uptime > 99% (not 99.9% yet)
• Predictable cost < $200/mo
• Basic support available

Recommendations:

Anti-rule: Do NOT switch providers at this stage unless you have a real technical blocker.

Stage 3: Production scale (6-18 months)

Goal: Sustain growth with defined SLAs.

Decision criteria:

• SLA > 99.9% uptime
• p95 latency defined and monitored
• Documented incident plan
• Defined scaling strategy
• Optimized costs (not just "make it work")

Recommendations:

Stage 4: Maturity / Optimization (18+ months)

Goal: Optimize costs without sacrificing performance.

Decision criteria:

• Optimized TCO (quarterly review)
• Geographic redundancy
• Tested disaster recovery
• Business metrics tied to search performance

Common strategies:

• Migrate from managed to self-hosted IF you have DevOps and the savings justify the migration
• Negotiate enterprise pricing with volume
• Implement caching to reduce direct queries
• Separate hot/cold storage (frequent vectors in RAM, the rest on disk)

Detailed decision cases

Case 1: Pre-seed startup, solo technical founder

Context:

• 1 developer (you)
• Budget: $0-50/mo
• 20K knowledge base documents
• RAG chatbot to demo to investors
• Timeline: 2 weeks for the demo

Analysis by variable:

Decision: ChromaDB local for development → Pinecone Free for the demo

Justification: ChromaDB lets you iterate fast locally. For the demo, Pinecone Free gives you a stable URL without managing servers.

Case 2: Seed startup, team of 4 devs

Context:

• 4 developers (1 with some infra)
• Budget: $200-500/mo for all infra
• 150K documents, growing 20%/mo
• B2B SaaS product with 30 early customers
• Latency < 100ms for search

Analysis by variable:

Decision: Qdrant Cloud Standard

Justification: Best cost/performance ratio for 150K-500K vectors. Native REST API. Latency < 50ms. ~$50-100/mo. Scales well up to 2M+ without migration.

Alternative: Pinecone Standard if the absolute priority is zero-ops (but ~$150/mo more).

Case 3: Mid-size company, product team + DevOps

Context:

• 8 developers + 2 DevOps
• Budget: $1,000-3,000/mo for vector search
• 2M documents, 500 concurrent users
• Multi-tenant (50 enterprise customers)
• GDPR mandatory, data in EU
• Contractual 99.9% uptime SLA

Analysis by variable:

Decision: Qdrant self-hosted on AWS EU (Frankfurt) with a 3-node cluster

Justification:

• GDPR requires data in the EU → self-hosted gives full control
• Dedicated DevOps → manageable operational cost
• 2M vectors across 3 nodes → redundancy + performance
• Cost: ~$540/mo infra + ~$600/mo operations = $1,140/mo TCO
• vs Pinecone Enterprise EU: ~$2,000/mo (savings of $860/mo = $10,320/year)

Alternative: Weaviate Cloud EU if you want to reduce operational load and the budget allows $1,500-2,000/mo.

Case 4: Scale-up with 20M vectors

Context:

• 15 developers + 4 DevOps/SRE
• Budget: $5,000-15,000/mo for search infrastructure
• 20M vectors, 2,000 concurrent users
• Multi-region (US + EU)
• Latency < 30ms p95
• SOC2 + GDPR

Analysis by variable:

Decision: Milvus cluster on Kubernetes (multi-region) or Qdrant distributed cluster

Justification:

• 20M vectors requires horizontal sharding → Milvus or Qdrant cluster
• Multi-region → you need cross-region replication
• The SRE team can handle the operational complexity
• Infra cost: ~$3,000-5,000/mo (vs enterprise managed ~$10,000-15,000/mo)
• Savings: $5,000-10,000/mo = $60,000-120,000/year

Decision checklist

Before committing to a provider, verify each point:

Pre-decision

• Define current vector volume
• I projected volume for 6 and 12 months (3 scenarios)
• Define the p95 latency requirement with real data (not intuition)
• I identified compliance constraints (GDPR, HIPAA, residency)
• I calculated the team's real operational capacity (available hours/month)
• I calculated the complete TCO (not just the service price) for 2+ options
• I tested at least 2 options with a 1-2 day PoC each

Post-decision

• I documented the decision and its reasons (ADR - Architecture Decision Record)
• Define a re-evaluation trigger (date or volume)
• I implemented an abstraction layer to reduce lock-in
• I configured cost alerts (billing alerts)
• I established a quarterly TCO review process

Recommended ADR format

# ADR-XXX: Vector Database Selection

## Status: Accepted

## Context
[Description of the problem and requirements]

## Decision
We chose [provider] in [managed/self-hosted] mode.

## Variables evaluated
| Variable | Value | Weight |
|----------|-------|------|
| Team | ... | ... |
| Budget | ... | ... |
| Scale | ... | ... |
| Latency | ... | ... |
| Compliance | ... | ... |

## Options considered
1. [Option A] - [reason for rejection]
2. [Option B] - [reason for rejection]
3. [Chosen option] - [reason for selection]

## Consequences
- Positive: ...
- Negative: ...
- Risks: ...

## Re-evaluation trigger
Re-evaluate when: [specific condition]

Quick decision matrix

For urgent decisions, use this table as a quick reference:

Selection troubleshooting

1. "I don't know if my future scale justifies a complex option"

Symptom: You're between ChromaDB (simple) and Qdrant (more robust) and you don't know how much you'll grow.

Diagnosis: You don't need to predict the future. You need to define a migration trigger.

Solution:

# Define your trigger BEFORE choosing
trigger = {
    "volume": "When it reaches 500K vectors",
    "latency": "When p95 > 200ms consistently for 1 week",
    "cost": "When TCO > $500/month",
    "ops": "When I spend > 8h/month on operations",
    "date": "Mandatory review in 6 months (date: YYYY-MM-DD)"
}

# Start with the simple option
# Migrate only when a trigger fires

2. "The product demands a strict SLA and the team has no DevOps"

Symptom: Your enterprise customer requires 99.9% uptime but your team of 3 devs has no operations experience.

Solution: Managed is the only viable option. The cost of managed ($200-800/mo) is much lower than the cost of an incident without DevOps (debugging hours × customer impact × relationship damage).

Concrete step: Choose Pinecone Standard or Qdrant Cloud with its included SLA. Document the provider's SLA and present it to your customer.

3. "Compliance changes frequently"

Symptom: Today you have no GDPR requirements but your sales team is closing EU customers.

Solution:

1. Choose a provider that offers data residency in multiple regions
2. If you're self-hosted, prepare a deploy playbook for a new region
3. Include the compliance risk in your TCO calculation
4. Review each quarter with the legal/compliance team

4. "Two options have a similar score in my matrix"

Symptom: Qdrant Cloud and Weaviate Cloud tie after the analysis.

Solution: When two options are equivalent on paper, the tiebreakers are:

1. Technical test: Do a 1-day PoC with each one. The one that feels better in developer experience wins.
2. Community: Which has better documentation, more examples, a more active community?
3. Trajectory: Which has more momentum? (GitHub stars trend, recent funding, public roadmap)

5. "My team wants the option I wouldn't recommend"

Symptom: You recommend managed but the team wants self-hosted "to learn".

Solution: Present the analysis with concrete numbers (TCO, operation hours, risk). If the team still prefers self-hosted, negotiate: "OK, self-hosted with a trigger to migrate to managed if operations exceed 10h/month in any month of the first quarter."

Practical exercises

Exercise 1: Apply the Decision Tree to your project

Walk through the complete Decision Tree with your module project's data:

1. Do you need a dedicated vector DB? Why?
2. Managed or self-hosted? Why?
3. Which specific provider? Why?

Exercise 2: Evaluate someone else's case

Your friend has an e-commerce startup with semantic product search. Data:

• Team: 2 full-stack developers
• Budget: $100/mo maximum
• Products: 80K SKUs with descriptions
• Latency: < 100ms (live search)
• Compliance: None
• Growth: 10%/mo

What do you recommend?

Exercise 3: Write an ADR

Document your Exercise 1 decision in complete ADR format.

# ADR-001: Vector Database Selection for Knowledge Base

## Status: Accepted (date)

## Context
We need semantic search over 50K internal documents
for a RAG chatbot. The team is 3 devs without experience
in infrastructure operations. Budget: $200/mo.

## Decision
We chose Qdrant Cloud Standard in managed mode.

## Variables evaluated
| Variable | Value | Weight |
|----------|-------|------|
| Team | 3 devs, no DevOps | High |
| Budget | $200/mo | High |
| Scale | 50K → 150K (6mo) | Medium |
| Latency | < 200ms | Medium |
| Compliance | None | Low |

## Options considered
1. ChromaDB self-hosted - Rejected: TCO > $1,000/mo due to operations
2. Pinecone Standard - Rejected: $150/mo, over budget for features we don't need
3. Qdrant Cloud Standard - Chosen: $33-50/mo, adequate performance, scales up to 2M

## Consequences
- Positive: Zero-ops, low cost, native REST API
- Negative: Moderate lock-in (mitigated with an abstraction layer)
- Risks: Pricing may change

## Re-evaluation trigger
When: volume > 500K vectors OR TCO > $200/mo OR p95 latency > 200ms
Mandatory review date: [6 months from today]

Exercise 4: Compare two growth scenarios

Your product is on Pinecone Free with 60K vectors. Model two futures:

Scenario A: Organic growth (10%/mo) Scenario B: Viral launch (50%/mo for 3 months, then 10%)

For each scenario, when do you need to change tier? How much will it cost?

import math

current = 60_000
pinecone_free_limit = 100_000

# Scenario A: 10%/mo
months_a = math.log(pinecone_free_limit / current) / math.log(1.10)
print(f"Scenario A: Free limit in {months_a:.1f} months")  # ~5.4 months

# Month 12 at 10%/mo
vectors_a_12 = current * (1.10 ** 12)
print(f"Scenario A, month 12: {vectors_a_12:,.0f} vectors")  # ~188K
# Cost: Pinecone Standard ~$80/mo

# Scenario B: 50%/mo × 3, then 10%/mo
vectors_b = [current]
for m in range(12):
    growth = 1.50 if m < 3 else 1.10
    vectors_b.append(vectors_b[-1] * growth)

for i, v in enumerate(vectors_b):
    if v > pinecone_free_limit:
        print(f"Scenario B: Free limit in month {i}")  # Month 2
        break

print(f"Scenario B, month 12: {vectors_b[12]:,.0f} vectors")  # ~477K
# Cost: Pinecone Standard ~$200/mo or migrate to Qdrant Cloud

# Plan for Scenario B:
# Month 0-2: Pinecone Free ($0)
# Month 2-6: Qdrant Cloud Standard ($50/mo, more cost-effective)
# Month 6+: Evaluate based on real growth

Exercise 5: Simulated technical debate

Your CTO wants Pinecone Enterprise ($2,000/mo). You believe Qdrant self-hosted ($500/mo TCO) is enough. Prepare 3 arguments in favor of each option with data.

Exercise 6: Risk assessment

Identify the 3 biggest risks of your decision and how you'd mitigate them.

Connection with the project: Decision Tree

Your final module project is to build a Decision Tree for vector database selection. This capsule gives you the complete framework. In your deliverable:

1. Implement the decision tree with the 5 variables as inputs
2. Include at least 4 use cases with complete analysis
3. Document an ADR for your own project
4. Define re-evaluation triggers for each recommendation

Summary

• 5 variables define every decision: team, budget, scale, latency, compliance.
• The Decision Tree gives you a reproducible path, not an opinion. Anyone on your team can follow it.
• Managed is the default for teams without DevOps. Self-hosted only when you have DevOps AND a specific reason (compliance, cost at scale, control).
• The product stage dictates the priority: PoC → speed, Validation → predictable cost, Production → SLA + scalability.
• Document your decision as an ADR. "Why didn't we choose the other options?" should have a clear answer.
• Define re-evaluation triggers BEFORE choosing. Never marry a provider.
• When two options tie, do a 1-day PoC with each one. Developer experience breaks the tie.

Additional resources

1. ChromaDB Documentation — Local setup and API reference
2. Pinecone Documentation — Pricing, quickstart, best practices
3. Qdrant Documentation — API, deployment, cloud
4. Weaviate Documentation — Modules, GraphQL, cloud
5. Milvus Documentation — Cluster setup, sharding, scaling
6. Architecture Decision Records — ADR format and examples
7. CNCF Technology Radar - Databases — Adoption trends
8. DB-Engines Ranking - Vector DBMS — Up-to-date popularity ranking

Estimated time: 30-40 minutes
Next: 07-selection-anti-patterns.md