TL;DR: At 1 million vectors, self-hosting on a $40/month VPS and Pinecone’s $50/month Standard floor cost about the same — the decision is ops time, not dollars. At 10 million, a quantized self-hosted Qdrant on a ~$86/month box beats typical managed bills by 2–4×. At 100 million, both options get expensive and the real cost is engineering either way.

	Self-hosted (Qdrant/pgvector on a VPS)	Managed serverless (Pinecone)	Managed dedicated (Qdrant Cloud)
Best for	1M–10M vectors, privacy, predictable bills	Spiky traffic, zero ops, small teams	Production SLA without running servers
Cost at 1M vectors	~$40/mo (8 GB VPS)	$50/mo plan minimum	Free tier (1 GB) to ~$30+/mo
Cost at 10M vectors	~$86/mo (16 GB VPS, int8 quantization)	~$10/mo storage + read/write units; bills climb with traffic	Low hundreds/mo (sizing calculator)
The catch	You are the on-call engineer	Read units dominate at scale; floor never drops	RAM-based pricing punishes float32 at scale

Honest take: below ~5 million vectors, run Qdrant or pgvector on the VPS you probably already have — the managed floor buys you nothing. Past 50 million, price out both seriously before committing; the winner depends on your query volume, not the sticker price.

Every price below was checked in September 2026. Vector database pricing changes quarterly; re-check before you commit to an architecture.

How much RAM do 1M, 10M, and 100M vectors need?

A float32 vector costs 4 bytes per dimension, and an HNSW index adds roughly 50% overhead on top of raw vector size. That one formula drives every cost number in this article:

Scale	384-dim (MiniLM)	768-dim (bge-base, nomic-embed)	1536-dim (OpenAI-class)
1M vectors	~1.5 GB raw / ~2.3 GB with index	~3 GB / ~4.5 GB	~6 GB / ~9 GB
10M vectors	~15 GB / ~23 GB	~30 GB / ~45 GB	~60 GB / ~90 GB
100M vectors	~150 GB / ~225 GB	~300 GB / ~450 GB	~600 GB / ~900 GB

Three levers change this math, and they matter more than which database you pick:

• Scalar (int8) quantization cuts vector memory 4×. 10M × 768-dim drops from ~30 GB to ~7.5 GB in RAM, with original vectors kept on disk for rescoring. Recall loss is typically small for retrieval workloads, but measure it on your own queries.
• Binary quantization cuts it 32×: a 768-dim vector becomes 96 bytes, so 100M vectors fit in ~9.6 GB of RAM. Qdrant’s docs recommend it mainly for high-dimensional embeddings (1536+) and always with rescoring enabled — it is not a free lunch at lower dimensions.
• Dimension choice is the cheapest lever of all. If a 768-dim local model retrieves as well as a 1536-dim API model for your corpus, you just halved every bill in this article. Our local embedding models guide covers which models hold up.

What does self-hosting a vector database cost per month?

The database software is free — Qdrant (Apache 2.0), Milvus (Apache 2.0), Chroma (Apache 2.0), and pgvector (PostgreSQL license) all permit unrestricted commercial self-hosting. The cost is the machine under it. Vector search is a non-GPU workload: RAM and NVMe are what you pay for, not CUDA cores.

Using Vultr regular Cloud Compute prices (checked September 2026) as a representative mainstream VPS baseline:

Scale (768-dim)	Configuration that works	Instance	Price
1M vectors	Float32 in RAM, no tricks needed (~4.5 GB)	8 GB RAM / 4 vCPU	~$40/mo
10M vectors	int8 quantization (~7.5 GB) + originals on NVMe	16 GB RAM / 6 vCPU	~$86/mo
10M vectors, no quantization	~45 GB in RAM	64 GB class	roughly 4× the 16 GB price — quantize instead
100M vectors	Binary quantization (~10 GB RAM) + ~300 GB NVMe for originals, or disk-based index (Milvus DiskANN)	32 GB RAM + block storage	~$173/mo + storage

Getting a production-grade Qdrant running is genuinely one command:

$ docker run -d -p 6333:6333 -v $(pwd)/qdrant_storage:/qdrant/storage qdrant/qdrant
$ curl -X PUT http://localhost:6333/collections/docs \
  -H 'Content-Type: application/json' \
  -d '{"vectors": {"size": 768, "distance": "Cosine"},
       "quantization_config": {"scalar": {"type": "int8", "always_ram": true}}}'
# → {"result": true, "status": "ok", "time": 0.18}

What the sticker price leaves out: backups (a snapshot cron job plus ~20% extra for backup storage on most providers), and your hours. A single-node vector DB is low-maintenance compared to a full inference stack, but it is not zero — budget it alongside the numbers in our self-hosted AI maintenance cost breakdown.

What does a managed vector database cost at the same scale?

Pinecone (serverless, Standard plan, September 2026): storage is $0.33/GB-month, read and write units are metered on top — Pinecone’s own docs list rates on the order of $4 per million write units and $16 per million read units, but the console is the source of truth and the rates have moved before. The Standard plan carries a $50/month minimum regardless of usage.

• 1M × 768-dim ≈ 3 GB → ~$1/month of storage. You pay the $50 floor anyway.
• 10M ≈ 30 GB → ~$10/month storage; with moderate query traffic, real bills land in the low-to-mid hundreds because read units scale with both query volume and namespace size.
• 100M ≈ 300 GB → ~$99/month for storage alone, before a single query. Read-unit consumption per query grows with namespace size, so heavy-traffic bills at this scale reach four figures. Aggressive namespacing is how you keep this sane.

Qdrant Cloud: a permanent free tier (1 GB RAM cluster — genuinely enough for ~500K quantized 768-dim vectors as a proof of concept), then resource-based pricing per vCPU/RAM/disk. Third-party cost breakdowns from September 2026 put a 1M × 1536-dim production cluster at roughly $100–115/month; a 768-dim workload with quantization prices meaningfully lower. The sizing calculator on qdrant.tech is the source of truth — RAM is the dominant line item, which is why quantization settings change the quote more than vector count does.

Weaviate Cloud and Zilliz Cloud play in the same band: serverless entry points in the $25–50/month range and per-resource pricing that tracks stored dimensions. Same pattern, different calculators.

The structural difference: managed pricing scales with usage (reads especially), self-hosted pricing scales in hardware steps. If your query volume doubles, a VPS bill doesn’t move until you outgrow the box; a serverless bill doubles.

Where is the break-even between self-hosted and managed?

Scale (768-dim)	Self-hosted	Managed (typical)	Verdict
≤1M vectors	~$40/mo	$50/mo floor (Pinecone) or free tier (Qdrant Cloud)	Wash on dollars. Choose on ops appetite.
10M vectors	~$86/mo quantized	$150–400/mo with real traffic	Self-hosting wins 2–4× if you’ll own the box
100M vectors	$173–350/mo + real engineering (binary quant, disk indexes, sharding)	$99/mo storage + read units; four figures at high QPS	No default winner — model your query volume

Two honest caveats on that table. First, the managed column is traffic-dependent: a low-QPS internal RAG tool at 10M vectors can stay near the storage floor, and then managed is closer to break-even than the table suggests. Second, the self-hosted column assumes one node with no high-availability requirement. The moment you need replicas across zones, multiply the VPS line by 2–3× and add the operational complexity that pushed people to managed services in the first place.

The problem you will actually hit: HNSW build memory spikes

The first time most people self-host past ~5M vectors, the bulk insert kills the process. Steady-state RAM for 10M quantized vectors may be ~8 GB, but HNSW graph construction during ingestion spikes well above steady state, the container hits its limit, and the OOM killer takes Qdrant down mid-index.

The fix that worked for us on a 16 GB box: ingest with indexing deferred, then let the index build after the data lands —

$ curl -X PATCH http://localhost:6333/collections/docs \
  -H 'Content-Type: application/json' \
  -d '{"optimizers_config": {"indexing_threshold": 0}}'   # defer HNSW during bulk load
# ...bulk upsert batches of 1-2K points...
$ curl -X PATCH http://localhost:6333/collections/docs \
  -d '{"optimizers_config": {"indexing_threshold": 20000}}' # re-enable, build once

Also set "on_disk": true for the vector store if you’re within 30% of the machine’s RAM. Managed services hide this class of problem from you — that, not the hardware markup, is what the monthly premium actually buys.

When NOT to self-host your vector database

• Your query volume is spiky and unpredictable. Serverless absorbs a 20× traffic spike; your 16 GB VPS falls over. If you’re B2C-facing, that spike arrives the day you get press.
• You need multi-region replication or a compliance-grade SLA. Building HA vector search across zones is a distributed-systems project, not a docker command. Qdrant Cloud’s premium tier or Pinecone gets you there for less than the engineering time costs.
• Nobody on the team wants to own it. A vector DB that loses its index on an unmonitored disk-full event takes your whole RAG product down. The when-not-to-self-host decision guide applies here in full.
• You’re below ~500K vectors and already all-in on a cloud. Qdrant Cloud’s free tier or pgvector on your existing managed Postgres costs $0 marginal. Don’t add a server to save money you’re not spending.

If you’re still choosing which database to run, our Chroma vs Qdrant vs Weaviate comparison and the pgvector vs Chroma vs Qdrant local RAG shootout cover the feature side of this decision.

What to actually buy

Prices as of September 2026, all taken from the comparison above:

Your situation	The option	Price	Where
Prototype or side project, under 500K vectors	Qdrant Cloud free tier or pgvector on existing Postgres	$0	Qdrant Cloud
Production RAG at 1M-scale, want to own it	8 GB / 4 vCPU VPS + Qdrant	~$40/mo	Vultr
10M vectors, cost-sensitive, one competent operator	16 GB / 6 vCPU VPS + Qdrant with int8 quantization	~$86/mo	Vultr
Spiky consumer traffic, no ops appetite	Pinecone serverless Standard	from $50/mo	Pinecone
100M+ vectors	Model your QPS first; nothing at this scale is an impulse buy	$200–1,000+/mo	both of the above

FAQ

Is pgvector cheaper than a dedicated vector database?

The infrastructure cost is identical — it runs on the same VPS. pgvector is the cheaper decision below ~1–5M vectors because it reuses a Postgres you already run and back up. Past that, HNSW memory behavior and quantization support in Qdrant or Milvus justify the second service.

Can I run the vector DB on the same box as Ollama?

At 1M-vector scale, yes — quantized, it needs 1–2 GB of RAM, which coexists fine with an inference stack on a 32 GB machine. At 10M+, give it its own box: HNSW build spikes and model loading will fight over the same RAM at the worst possible moment.

At what point does managed become the cheaper option?

On raw dollars, almost never at steady state — hardware-step pricing beats usage pricing for predictable workloads. Managed wins on total cost when your traffic is spiky, when you need HA across regions, or when the 2–5 hours/month of ops time is billed at consulting rates. Price your time, not just the invoice.

Sources

• Pinecone: Understanding cost — storage and read/write unit model, checked September 2026
• Qdrant Cloud pricing and billing — resource-based pricing and free tier, checked September 2026
• Qdrant: Quantization guide — scalar and binary quantization memory math
• Vultr pricing — Cloud Compute instance prices, checked September 2026
• LeanOps: Qdrant Cloud vs Pinecone cost breakdown — third-party managed-cluster cost examples, September 2026

What self-hosting actually costs

Real cost breakdowns for self-hosted AI: hardware floors, power, maintenance hours, and the honest comparison against paying for it. No spam, unsubscribe anytime.

Email address Subscribe