Last year, a startup I advise spent three months building their document search feature on Pinecone, then discovered their monthly bill was going to hit ₹35,000 at their projected data volume — four times what they'd budgeted. Migrating to a self-hosted Qdrant instance took two weeks and dropped their cost to ₹4,200 per month. The pain was avoidable. Vector database choice is not a detail you can defer until the bill arrives; the switching cost is high because embeddings, index configurations, filtering logic, and query patterns all change between systems. This comparison gives you enough detail to make the right call the first time, with Indian pricing context included.
The Four Main Options at a Glance
Before going deep on each, here's the honest one-liner for each database:
- Pinecone — Managed-only, simplest to start, most expensive at scale. Best for teams that want zero infrastructure management.
- Weaviate — Open-source with optional cloud hosting, built-in hybrid search, modular ML integrations. Best for complex enterprise search with mixed query types.
- Chroma — Open-source, Python-native, minimal config. Best for RAG prototyping and small production deployments under 1 million vectors.
- Qdrant — Open-source with optional managed cloud, Rust-based performance, best binary quantization. Best for high-throughput production workloads.
And the option most Indian teams overlook: pgvector — a PostgreSQL extension that handles vector similarity search inside your existing database. For workloads under 5 million vectors, it eliminates an entire infrastructure component.
Pinecone: Simplest Entry Point, Highest Cost Ceiling
Pinecone is a fully managed vector database with no self-hosting option. You create an index, insert vectors via their Python or TypeScript SDK, and query. There is no server to configure, no Docker image to manage, no backup schedule to worry about. For an early-stage startup where engineering time costs more than cloud bills, this matters.
What Pinecone does well: Index creation takes minutes. The serverless architecture (launched in 2024) means you pay per query rather than for reserved capacity. Filtering on metadata alongside vector similarity works cleanly. Their sparse-dense hybrid search handles keyword + semantic queries in one API call.
Where Pinecone falls short: You cannot run it on-premises. For Indian companies with data residency requirements — healthcare under DPDP Act, fintech with RBI guidelines — this is a blocker. Pinecone's data centers are in US and EU regions; there is no Mumbai or India option as of early 2026. Pricing also adds up quickly once you move beyond prototype scale.
Pricing in INR (approximate, Feb 2026):
- Starter (free): 100,000 vectors, 1 index, 2 million read units/month
- Standard serverless: roughly ₹65 per million read units + ₹8 per GB stored monthly
- For 1 million vectors with moderate query load: expect ₹4,000–12,000/month
- For 10 million vectors with production traffic: ₹20,000–60,000/month
Weaviate: Best for Complex Enterprise Search
Weaviate is open-source (BSD license) with an optional hosted cloud (Weaviate Cloud Services). Its defining feature is a modular vectorizer architecture — you can attach different ML models to different data classes within one instance, switching embedding models per collection without reindexing everything. It natively supports hybrid search combining BM25 keyword retrieval with vector similarity, weighted by a configurable alpha parameter.
What Weaviate does well: GraphQL and REST API interfaces give different teams flexibility to integrate in the style they prefer. Multi-tenancy is first-class, making it a strong fit for SaaS platforms that need to isolate vector data per customer. Its cross-reference feature lets you link objects between collections — closer to a graph database's behavior than pure vector databases offer.
Where Weaviate falls short: Configuration overhead is real. Before inserting data, you define a schema with classes, properties, vectorizer module settings, and index parameters. The flexibility is also complexity. Teams new to vector databases will spend meaningful time understanding Weaviate's mental model before their first production query. The Python client underwent breaking changes between v3 and v4 — existing tutorials online are frequently outdated.
Self-hosting: Docker Compose deployment is straightforward for single-node setups. Kubernetes via Helm chart for production clusters. Minimum recommended: 2 vCPUs, 8GB RAM for under 1 million vectors.
Pricing in INR (WCS, approximate):
- Sandbox: Free, not for production use
- Serverless: roughly ₹165 per million vector dimensions stored monthly
- For 1 million 1,536-dim vectors: around ₹7,000–15,000/month depending on query volume
- Enterprise: custom pricing
Chroma: The Prototyping Workhorse
Chroma was built with one audience in mind: Python developers building RAG applications. It runs as an in-process library (no server required), as a local server via Docker, or as a hosted service via Chroma Cloud. The API is intentionally minimal — create a collection, add documents, query. LangChain and LlamaIndex have native Chroma integrations, so spinning up a working RAG pipeline takes under 50 lines of Python.
What Chroma does well: Zero-friction local development. You can persist a Chroma collection to disk with two lines of code, making it trivial to build and test RAG pipelines on your laptop before touching cloud infrastructure. Metadata filtering uses a simple dictionary-based syntax that feels natural for Python developers. For proof-of-concept work, hackathons, and internal tools with modest data volumes, Chroma is genuinely the fastest path to a working system.
Where Chroma falls short: Chroma is not optimized for high concurrency. Under heavy parallel query load, you'll see performance degrade faster than Qdrant or a well-tuned Weaviate instance. The Cloud offering is still maturing; some enterprise features (role-based access, audit logs) that Pinecone and Weaviate offer are absent or incomplete. For production deployments beyond roughly 1 million vectors with sustained traffic, the performance headroom starts to feel tight.
Pricing in INR (Chroma Cloud, approximate):
- Free tier: limited storage, single organization
- Pro: roughly ₹1,700/month for small production workloads
- Self-hosted: your infrastructure cost only (a t3.medium on AWS Mumbai is ~₹3,100/month)
Qdrant: Best Performance at Scale
Qdrant is written in Rust, which translates directly into measurable advantages: lower memory usage, better CPU efficiency, and more predictable latency under load compared to JVM-based or Python-based alternatives. Its HNSW implementation is among the fastest available, and its binary quantization feature can compress vectors to 1/32 of their original size with acceptable recall degradation — a meaningful cost reducer when storing tens of millions of embeddings.
What Qdrant does well: Named vectors allow one collection to store multiple embedding types (e.g., image embeddings and text embeddings for the same object) and query them independently or together. Payload filtering is richly typed — you can filter on integers, floats, strings, geo-coordinates, and nested JSON. The gRPC interface makes high-throughput applications measurably faster than REST-only databases. Their Rust SDK is production-quality; Python and TypeScript SDKs are solid.
Where Qdrant falls short: Hybrid search (vector + keyword BM25) arrived more recently and is less battle-tested than Weaviate's implementation. The managed cloud (Qdrant Cloud) is cheaper than Pinecone but still adds up for very large indexes. Documentation is good but spread across multiple versions, and some advanced features (sparse vectors for hybrid search) require reading GitHub issues to understand edge cases.
Pricing in INR (Qdrant Cloud, approximate):
- Free: 1GB storage (roughly 200,000 text embeddings at 1,536 dims)
- Paid: from roughly ₹1,600/month for 4GB / 2 vCPUs
- For 1 million vectors: approximately ₹3,200–6,500/month depending on RAM allocation
- Self-hosted: your infrastructure cost only
The Overlooked Option: pgvector
pgvector is a PostgreSQL extension that adds a vector data type and two index types: IVFFlat (inverted file index) and HNSW (hierarchical navigable small world). It turns your existing PostgreSQL database into a vector search engine. You don't run a separate database process. You don't maintain a separate backup job. You don't write code to synchronize metadata between your relational database and your vector store — because they're the same database.
For a SaaS application already using PostgreSQL (or Supabase, which bundles pgvector natively), this is a compelling argument. A query that would require a vector search followed by a metadata join across two systems becomes a single SQL query:
SELECT id, content, 1 - (embedding <=> $1) AS similarity
FROM documents
WHERE user_id = $2
AND created_at > NOW() - INTERVAL '90 days'
ORDER BY embedding <=> $1
LIMIT 10;The limitations are real: PostgreSQL's HNSW index is slower to build than Qdrant's, recall degrades earlier at scale, and there's no native multi-tenancy at the vector layer (though row-level security handles this adequately for many use cases). But for under 5 million vectors with standard query patterns, pgvector on Supabase Pro (approximately ₹1,700/month) is competitive with managed vector databases at a fraction of the cost.
Performance at 100K vs 1M Vectors
Benchmark numbers from independent ANN (approximate nearest neighbor) benchmarks and community testing (note: your workload will vary by embedding dimension, hardware, and query patterns):
At 100,000 vectors (1,536 dimensions), single-node, queries per second (QPS):
- Qdrant HNSW: ~2,800–4,500 QPS at 99% recall
- Weaviate HNSW: ~1,800–3,200 QPS at 99% recall
- Chroma HNSW: ~800–1,500 QPS at 98% recall
- Pinecone serverless: ~400–1,200 QPS (latency-dominated by network round-trip)
- pgvector HNSW: ~600–1,100 QPS at 97–99% recall
At 1,000,000 vectors, single-node (same metric):
- Qdrant HNSW: ~1,200–2,500 QPS at 98% recall
- Weaviate HNSW: ~700–1,500 QPS at 97% recall
- Chroma: degrades significantly without hardware upgrades
- pgvector HNSW: ~300–700 QPS (RAM pressure becomes a factor)
For most Indian startup use cases — a customer support bot over a 50,000-document knowledge base, a product search over a 200,000-item catalog — any of these databases is fast enough. The performance gap matters when you're handling thousands of concurrent users.
Migration Considerations
Migrating vector databases is painful because embeddings generated from one model are not compatible with another — but migrating between databases using the same embedding model is manageable. The core migration steps are: export vectors + metadata from the source, re-ingest to the target, verify recall on a held-out query set, then cut over traffic. The hardest part is usually filtering logic: each database has its own query syntax for metadata filtering, and complex filter conditions require rewriting rather than direct porting.
If you anticipate growth beyond 5 million vectors within 12 months, start with a database that won't require migration. Starting on Chroma for prototyping and migrating to Qdrant for production is a reasonable two-phase approach — the migration from Chroma to Qdrant is simpler than from Pinecone to any self-hosted option because Pinecone's API is proprietary and export tooling is limited.
Deploying on Indian Cloud: AWS Mumbai and Azure India
Data residency matters for Indian companies under the Digital Personal Data Protection Act and sector-specific RBI/SEBI regulations. Both AWS ap-south-1 (Mumbai) and Azure Central India host all four self-hostable databases cleanly.
For AWS Mumbai: Qdrant and Chroma run on t3.medium (₹3,000–3,500/month) for development; for production scale, c6i.xlarge instances (₹12,000–14,000/month) give consistent throughput. Weaviate benefits from more RAM — r6i.large (₹8,000–9,500/month) is a better fit than compute-optimized instances. Managed options (Pinecone, Weaviate Cloud, Qdrant Cloud) are US/EU hosted — if data residency is a requirement, self-hosting is your only compliant option for these databases. pgvector via Supabase defaults to their Frankfurt region; the Mumbai region Supabase is available for paid plans and keeps data within India.
Decision Guide: Which Database for Your Use Case
- Prototype / internal tool / hackathon → Chroma locally, pgvector on Supabase free tier
- Production under 5M vectors, data must stay in India, cost-sensitive → pgvector on Supabase Mumbai or self-hosted PostgreSQL
- Production, need hybrid search (keyword + semantic), enterprise features → Weaviate self-hosted on AWS Mumbai
- Production, high throughput (>1,000 QPS), cost-efficient scaling → Qdrant self-hosted with HNSW + binary quantization
- Team has no DevOps capacity, data residency not a constraint, budget flexible → Pinecone serverless
Frequently Asked Questions
Is pgvector good enough for production RAG applications, or do you always need a dedicated vector database?
pgvector is production-ready for most Indian startup workloads up to around 5 million vectors with 1,536 dimensions (OpenAI's text-embedding-3-small output). Below that threshold, an HNSW index in PostgreSQL delivers sub-50ms query latency without a separate database to operate. The advantage is genuine: you eliminate a network hop, you use familiar SQL for filtering, and you keep operational complexity low. The point where you should migrate to a dedicated vector database is when you need approximate nearest neighbor recall above 99% at millions of vectors with heavy concurrent load, or when you need native hybrid search (vector + keyword BM25) without writing your own SQL union query. For a Kerala SME or early-stage startup, pgvector on Supabase is often the right first choice.
How much does running a vector database cost for an Indian startup storing 500,000 document embeddings?
At 500,000 vectors with 1,536 dimensions, your options range from near-zero to several thousand rupees per month. pgvector on a Supabase Pro plan (around ₹1,700/month) handles this comfortably with an HNSW index. Chroma self-hosted on an AWS Mumbai t3.medium instance (around ₹3,000/month) runs with headroom. Qdrant Cloud's free tier covers 1GB of storage, which fits roughly 200,000 text embeddings — after that, paid plans start at roughly ₹1,600/month. Weaviate Cloud's sandbox is free but not for production; their smallest production tier is around ₹4,200/month. Pinecone's Starter plan is free up to 100,000 vectors in one index; 500,000 vectors requires a paid plan starting around ₹1,900/month billed in USD. Total cost of ownership should also account for your engineering time to operate self-hosted options.
Can Weaviate and Qdrant both be self-hosted on Indian cloud providers, and what are the minimum server requirements?
Both self-host cleanly on AWS Mumbai (ap-south-1) and Azure Central India. Weaviate's minimum recommended production setup is 2 vCPUs and 8GB RAM for under 1 million vectors; it runs as a Docker container or on Kubernetes via Helm chart. Qdrant's minimum is lighter — 2 vCPUs and 4GB RAM for the same data size, because Rust's memory efficiency means it uses roughly 40% less RAM than Weaviate for equivalent workloads. Both publish official Docker images. For Indian data residency requirements, self-hosting on an AWS Mumbai instance keeps all vector data within India's borders, which matters for healthcare and fintech applications subject to RBI and DPDP Act data localization expectations.