Embeddings DB vs Self-Host pgvector: True Cost

Default to a managed vector DB and only add pgvector when Postgres is already in your stack, your queries need SQL-filter-then-vector-search, or you need transactional consistency. At 200k vectors the bills run from LanceDB on object storage at $0.25/month through Turbopuffer's $16 and Pinecone's $50 minimums to $125 for a Supabase database sized to hold the index in memory. The decision is about operational complexity, query expressiveness, and what your existing stack already pays for. This article compares them on two scales and names which workload fits which choice.

1. Two paths to vector storage

The managed path: send vectors and queries to a hosted vector DB (Pinecone, Turbopuffer, Weaviate Cloud, Chroma Cloud). Provisioning is minutes; operations are zero. Cost is per-vector storage + per-operation read/write. The vendor handles infrastructure, scaling, indexing, and backup.

The self-host pgvector path: install the pgvector extension on Postgres, store vectors as additional columns alongside application data, query via SQL with vector-distance operators. Provisioning is hours to days (Postgres setup, index tuning, schema design). Operations are ongoing (backups, monitoring, security patches, performance tuning). Cost is the Postgres tier itself, and the tier is set by memory: pgvector's HNSW index answers fast when it fits in RAM.

The Embeddings DB Cost engine runs these comparisons literally on user-defined inputs. The methodology behind the cost model is documented at the Embeddings DB Cost methodology page^[5]. The engine's vendor rates are list prices checked in October 2026 (Pinecone, Supabase, Cloudflare R2, Turbopuffer), shown in each result's notes. Postgres+pgvector is priced on Supabase Pro: $25 a month including $10 of compute credit^[2], plus the smallest compute size whose benchmarked HNSW capacity holds the index^[3][8], plus disk above 8 GB.

2. Small scale (200k vectors): plan minimums and index memory

200k 1,536-dim vectors, 2,400 queries/day (light RAG workload, typical solo SaaS launch):

Pinecone Standard comes to its $50/month plan minimum^[1], Turbopuffer to its $16/month Launch minimum^[4], and LanceDB on Cloudflare R2 to $0.25/month. Postgres+pgvector on Supabase comes to $125/month: the $25 Pro plan, Large compute at $110 less the $10 credit^[8], because Supabase's benchmark served 224,482 1,536-dim vectors from Large's 8 GB and only 100,000 from Medium's 4 GB^[3].

At this scale the hosted vendors' plan minimums set their bills, since metered usage is trivial, while pgvector's bill is set by the memory its index needs. Storing vectors as pgvector's half-precision halfvec type^[6] roughly halves that memory, and an index that spills to disk still answers, more slowly; both can move a 200k index down a size. Benchmark recall and latency on your own data before relying on either.

Operationally, both paths need little attention at this scale. Pinecone is set-and-forget; a hosted Postgres is configure-once-and-forget. The strategic decision at 200k vectors is about what you already operate and whether a dedicated database's memory bill is worth SQL access to the vectors.

3. Large scale (1M vectors): pgvector's memory sets its price

1M 1,536-dim vectors, 30,000 queries/day (mature RAG workload, typical mid-stage SaaS):

Pinecone Standard rises to $111.12/month: Pinecone bills a query 1 read unit per GB of namespace, so each of the 900,000 monthly queries reads about 7 units on the ~7 GB index, about $103 in reads^[1]. Postgres+pgvector on Supabase rises to $425.79/month: 1M 1,536-dim vectors is Supabase's 2XL benchmark (32 GB of RAM, $410 a month)^[3][8], plus about 14 GB of disk for the table and its index. Turbopuffer stays at its $16/month Launch minimum, and LanceDB on R2 comes to $1.51/month.

At 1M vectors LanceDB is still cheapest, then Turbopuffer at its $16 minimum, Pinecone at $111.12 now that its metered reads have cleared the $50 minimum, and pgvector at $425.79. The pgvector figure is a capacity price: the same 2XL served 560 queries per second in Supabase's benchmark, so it barely moves with query volume.

That is where the curves cross. At 100 QPS sustained (about 259M queries a month), Pinecone's $16/M read units^[7] at about 7 units a query come to roughly $30,000 a month, while the Supabase 2XL bill stays near $426. A dedicated Postgres becomes the cheaper engine once a hosted vendor's metered reads, not its minimum, set the bill.

4. The true cost of self-hosting pgvector

Running Postgres yourself on a VPS swaps the hosted price for server rent plus your time. For the 200k scenario:

• Infrastructure: an 8 GB RAM VPS, enough for the index on Supabase's benchmark, at €8.49 ($9.99) a month on Hetzner's CX33 (EU locations)^[9], checked October 2026; the cheapest VPS comparison has the full table.
• Initial setup (assumed): 8-16 hours of engineering (PostgreSQL install, pgvector extension, schema design, index tuning, backup configuration, monitoring setup). At $100/hour loaded, that is $800-$1,600 one-time.
• Ongoing maintenance (assumed): 2-6 hours per month (security patches, performance monitoring, backup verification, index re-tuning as data grows, occasional debugging). At $100/hour loaded, that is $200-$600/month of opportunity cost.
• Incident response (assumed): 1-2 incidents per year requiring 4-8 hours each (disk filling up, query plan regression, replication lag, etc). $400-$800 per incident.

The total annualized cost of self-hosting on the $9.99 CX33 is about $120 infrastructure + $2,400-$7,200 maintenance + $400-$1,600 incidents = $2,920-$8,920 per year, or about $243-$743 per month. Compare the stores in the two scenarios above: LanceDB on R2 at about $3 to $18 a year, Turbopuffer at its $192-a-year minimum, Pinecone at $600 (200k vectors) to about $1,333 (1M vectors), and Supabase pgvector at $1,500 to about $5,109. On these assumptions the hosted vector stores cost less than the self-host time, and even Supabase's 1M-vector bill sits inside the self-host range; self-hosting only makes sense if the maintenance time is reclaimed for other product work and not paid at full opportunity cost.

5. What managed vendors actually buy you

What a fully hosted vendor (Pinecone, Turbopuffer) buys you for that spend:

• Zero provisioning time. Account creation to first query is under 10 minutes. Self-host is hours to days.
• Zero operations time. No backups to verify, no security patches to apply, no index tuning to do, no monitoring to set up. The vendor handles all of it.
• Elastic scale. Doubling vector count or query volume is automatic on managed. Self-host requires you to plan for, provision, and migrate to a larger tier.
• Index expertise. Pinecone and Turbopuffer tune HNSW (or proprietary equivalents) for production workloads. Solo founders setting up pgvector usually pick suboptimal index parameters.
• Recall guarantees. Managed vendors publish recall vs latency tradeoffs and tune to specific targets. Self-host requires you to benchmark recall yourself.

For solo founders, the operational time saved is the largest line item. Saving 4 hours per month of maintenance work at $100/hour loaded is $4,800/year. Saving even 1 incident per year at 8 hours is $800. On those assumed hours, a hosted vector store's fee in the scenarios above ($192 to about $1,333 a year) buys back several thousand dollars of founder time; replace the hours with your own estimate before deciding.

6. Metadata filtering and SQL-join requirements

The strongest argument for pgvector over managed is SQL expressiveness. If your queries need to filter by application data before (or alongside) vector search, pgvector lets you do this in one SQL statement against one database. Managed vendors offer metadata filtering, but the expressiveness is shallower than full SQL.

Example: "Find the 10 most similar documents to this query, but only among documents from customers in the EU created in the last 30 days where the assigned account manager is in the sales team." In Postgres+pgvector, this is one SQL query with WHERE clauses and a vector-distance ORDER BY. In Pinecone, this is a metadata filter applied to the vector search, which works if all the filters are pre-indexed metadata fields but breaks if any filter requires a join.

The pgvector GitHub^[6] documents the supported distance operators (L2, inner product, cosine) and the indexing options (IVFFlat, HNSW). Solo founders building RAG products where the query patterns are pure "find similar docs" can use managed. Solo founders building products where vector search is one component of a complex query (search + filter + join + vector) should use pgvector.

7. The decision matrix by use case

Use case decisions:

• Pure RAG (find similar documents, no filtering): a hosted vendor for zero operations, with Turbopuffer ($16 minimum) or Pinecone ($50 minimum) as a fully hosted service; or LanceDB on your own object storage for the lowest bill ($0.25/mo at 200k vectors), which you run inside your application rather than as a hosted service.
• RAG with metadata filtering on pre-indexed fields: managed vendor with metadata filtering. Still simpler than pgvector.
• RAG with complex SQL-join requirements: pgvector. Worth the operational tax for the query expressiveness.
• Transactional consistency required (vectors + source records updated atomically): pgvector. Managed vendors require eventually-consistent sync.
• Existing Postgres with memory to spare: pgvector. Marginal cost near zero until the index outgrows the instance's RAM.
• No existing Postgres, query volume under 50 QPS: a no-minimum or object-storage store (LanceDB on R2 at $0.25/mo) for the lowest bill, or a hosted plan with a minimum (Turbopuffer $16, Pinecone $50) for full hosting. A dedicated Postgres sized for the index ($125/mo on Supabase at 200k vectors) costs the most and is worth it only for the SQL query power.

The Embeddings DB Cost calculator prices any vector count and query rate; the 2026 AI solopreneur stack covers the broader stack context.

8. Which path to start with

The default for solo founders building new RAG products without Postgres: a hosted vector store, whose operational simplicity is usually worth Turbopuffer's $16 or Pinecone's $50 monthly minimum, or LanceDB on object storage at $0.25/month if you are happy to run the library inside your app. Migrate to self-host pgvector later if and only if the workload develops requirements (SQL joins, transactional consistency, existing Postgres at scale) that justify the move.

The default for solo founders with existing Postgres-heavy stacks: pgvector. Marginal cost is zero, operational surface is one fewer vendor, and the SQL expressiveness is a real query-power win. Migrate to managed only if the operational overhead becomes meaningful or the index outgrows the memory your Postgres instance can afford.

Frequently asked questions

Is pgvector cheaper than managed vector DBs?

Not as a dedicated database. HNSW search is fast when the index fits in memory, so a hosted Postgres is priced by RAM: on Supabase Pro the Embeddings DB Cost engine returns $125/month for 200k 1,536-dim vectors (Large compute) and $425.79 for 1M (2XL), sized from Supabase's own pgvector benchmarks. Turbopuffer bills its $16 Launch minimum at both scales and Pinecone $50 and $111.12. If you already run Postgres with spare memory, pgvector's marginal cost is near zero, which is where it wins.

What is the true cost of self-hosting pgvector?

Compute, storage and operations time. Supabase's benchmark served 224,482 1,536-dim vectors from 8 GB of RAM, so a 200k index fits an 8 GB VPS such as Hetzner's CX33 at €8.49 a month (EU locations, as of October 2026). Setup is roughly 8-16 hours of engineering and ongoing maintenance 2-6 hours per month (backups, monitoring, security patches, index tuning). At $100/hour loaded, that maintenance is $200-$600 a month of opportunity cost, more than the server itself.

When does pgvector outperform managed vector DBs?

Three scenarios: (1) you need SQL-filter-then-vector-search query patterns, (2) you need transactional consistency between vectors and source records, (3) you operate Postgres for application data and pgvector is marginal cost zero. Outside these three, managed vendors win on operational simplicity and provisioning time.

Does self-hosting save money at high query volumes?

Sometimes. Above 100 QPS sustained on a 1M-vector index, Pinecone's per-read pricing ($16/M read units, about 7 per query at 7 GB) runs to tens of thousands of dollars a month, while Supabase's 2XL, which held 1M 1,536-dim vectors at 560 queries per second in its benchmark, stays at $410 of compute. Below 50 QPS sustained, metered read cost is small on every vendor and the bill is set by plan minimums, memory and operations.