Two years ago, the default move for retrieval-augmented generation (RAG) was obvious: embed your documents, ship vectors to Pinecone or Weaviate, keep PostgreSQL for everything else. Vector databases were built for the job. Postgres was the database your app already had.
That split made sense in demos. In production it often meant two sources of truth, sync pipelines that broke at 2 a.m., and bills that scaled faster than query volume. By 2026, a clear correction showed up: teams with real users, real permissions, and real budgets are moving vectors back into PostgreSQL with pgvector (PostgreSQL Global Development Group, n.d.). Not because vector databases failed. Because most applications never needed a second database in the first place.
What Changed
Three things shifted the default:
- pgvector matured. Hierarchical Navigable Small World (HNSW) indexing, parallel builds, and extensions like pgvectorscale closed much of the latency gap for workloads under roughly 10 to 50 million vectors (BuildSpace, 2026; Kunal Ganglani, 2026).
- RAG became a feature, not the product. Most apps need semantic search plus user rows, billing status, tenant isolation, and deletes that actually stick. That is relational work.
- Operations got honest. Running Postgres you already know beats onboarding a second storage system, new backup rules, and a sync layer nobody wanted to maintain (DBA Dataverse, 2026).
Instacart is the headline example. They consolidated keyword and embedding search into PostgreSQL with pgvector, moving away from a split stack that included Elasticsearch and Facebook AI Similarity Search (FAISS). One engine, one indexing story, finer control over recall (Instacart, 2024; InfoQ, 2025).
The Core Argument in One Sentence
Dedicated vector databases optimize pure approximate nearest-neighbor search at massive scale. Most production apps need search plus business logic in the same transaction. PostgreSQL with pgvector gives you Atomicity, Consistency, Isolation, Durability (ACID), Structured Query Language (SQL) joins, row-level security, and vectors in one place (JusDB, 2026; OpenHelm, 2026).
Use Cases: Problem, Cause, Effect
Below are four patterns we see repeatedly. Each follows the same arc: what broke, why it broke, what teams did instead.
1. Internal document RAG with permissions
Problem: A SaaS (Software as a Service) company built RAG over customer uploads. Users reported seeing snippets from documents they should not access. Incidents were hard to reproduce.
Cause: Document metadata (owner, workspace, delete flag) lived in PostgreSQL. Embeddings lived in a managed vector store. The retrieval path was: vector search first, filter in application code second. Race conditions and stale vectors meant deleted or reassigned documents still surfaced in top-k results. Two systems, no single transactional guarantee (DBA Dataverse, 2026).
Effect after moving to pgvector: One query joins document_chunks to memberships and applies vector distance in the same statement. Deletes are immediate. Row-level security enforces tenant boundaries at the database layer. Incident rate drops because correctness moved from app-side filtering to SQL the database already enforces.
2. E-commerce catalog search (Instacart-style)
Problem: Search returned semantically relevant items that were out of stock or unavailable in the user's region. Shoppers clicked dead ends. Merchandising lost trust in "AI search."
Cause: Semantic retrieval ran against a vector index built from product embeddings. Availability and geo rules lived in PostgreSQL and updated continuously. Pre-filtering in the vector database could not cheaply see realtime inventory without duplicating high-churn fields into embedding metadata or running expensive post-filters (Instacart, 2024).
Effect after consolidating on PostgreSQL: Instacart combined full-text ranking (ts_rank) and pgvector similarity in one datastore, using relational pre-filters (availability, region) before vector scoring. Fewer pipelines, less duplication, better control over how keyword and semantic recall merge (InfoQ, 2025). Search relevance improved because the database saw the same truth the checkout flow used.
3. Startup RAG: prototype cost vs production bill
Problem: A team shipped a Pinecone-backed assistant during beta. At public launch, infrastructure cost jumped faster than revenue. Usage-based pricing on reads and storage compounded with marketing traffic (Rivestack, 2026; Khimananda, 2026).
Cause: The vector tier was priced per dimension stored and per query unit. Beta volume hid the curve. PostgreSQL was already running the app on a fixed instance size. Adding vectors to an existing Supabase or Neon deployment did not add a second vendor invoice line (Moiz Nisar, 2025).
Effect after migrating to pgvector: Predictable monthly database cost, same backup and monitoring stack, no separate sync workers. Latency for their corpus (under two million chunks) stayed within retrieval budget. Money moved from vector SaaS (Software as a Service) fees to one larger Postgres instance they would have scaled anyway.
4. Support ticket semantic search with workflow state
Problem: Support agents searched past tickets by meaning ("payment failed after card update") but results mixed closed, duplicate, and spam threads. Agents wasted time opening irrelevant history.
Cause: Ticket body embeddings sat in Qdrant. Status, assignee, and deduplication keys sat in Postgres. Hybrid filters across systems required two round trips and client-side merging. Metadata drift when tickets were merged or status changed overnight (Kalvium Labs, 2026).
Effect after pgvector: Single query: approximate nearest neighbors on embedding column, WHERE status = 'resolved', WHERE team_id = $1, ordered by similarity. Hybrid keyword plus vector fusion uses PostgreSQL full-text search or pg_trgm in the same engine (Suparbase, 2026). Agent workflow sped up because filters and vectors agreed on row identity.
PostgreSQL vs Dedicated Vector Database
| Factor | PostgreSQL + pgvector | Dedicated vector DB |
|---|---|---|
| Best fit scale | Roughly under 10 to 50M vectors on a well-provisioned node | 100M+ vectors, high query-per-second (QPS), multi-region SLAs |
| ACID transactions | Yes, native | No (eventual consistency models) |
| Joins with app data | Native SQL | Metadata filters only; no relational joins |
| Operational stack | One database to backup, tune, and hire for | Second system plus sync pipeline |
| Cost model | Fixed instance or managed Postgres tier | Often usage-based; can spike at launch |
| Hybrid search | Full-text + pgvector + pg_trgm in one query | Varies; Weaviate strong here; others need extras |
| Sharp edges | HNSW rebuild time, memory tuning, single-node ceiling | Vendor lock-in, limited SQL, sync complexity |
What PostgreSQL + pgvector Looks Like in Practice
A minimal production pattern: chunks table, HNSW index, filtered similarity search.
CREATE EXTENSION vector;
CREATE TABLE document_chunks (
id bigserial PRIMARY KEY,
tenant_id uuid NOT NULL,
document_id uuid NOT NULL,
content text NOT NULL,
embedding vector(1536),
deleted_at timestamptz
);
CREATE INDEX ON document_chunks
USING hnsw (embedding vector_cosine_ops);
-- Top 5 similar chunks this tenant may read, excluding soft-deleted rows
SELECT c.id, c.content,
1 - (c.embedding <=> $1) AS similarity
FROM document_chunks c
JOIN document_access a ON a.document_id = c.document_id
WHERE c.tenant_id = $2
AND a.user_id = $3
AND c.deleted_at IS NULL
ORDER BY c.embedding <=> $1
LIMIT 5;That join and filter in one round trip is the feature vector-only stacks make painful. You can express authorization, lifecycle, and similarity together instead of hoping application code reconciles two stores after the fact.
When a Dedicated Vector Database Still Wins
Postgres is not universal. Stay on or move to Pinecone, Qdrant, Weaviate, or Milvus when:
- You expect 100 million or more vectors with aggressive sub-10 millisecond (ms) latency service-level agreements (SLAs) and horizontal sharding out of the box (BuildSpace, 2026; BackendBytes, 2026).
- Vector search is the product, not a sidebar feature, and you want zero database operations (OpenHelm, 2026).
- You have no PostgreSQL footprint and no appetite to run one just for embeddings (Moiz Nisar, 2025).
- You need multi-region replication managed for you without designing Postgres sharding yourself.
- Your team lacks database operations (DBA) capacity and prefers usage-priced software-as-a-service over tuning HNSW parameters.
The mature view in 2026 is not "vector databases are dead." It is "default to Postgres until metrics prove you outgrew it." Measure recall, p95 latency, and dollars per million queries before you split the stack again.
Decision Checklist
- Do you already run PostgreSQL for core app data? If yes, pgvector is the path of least resistance.
- Does retrieval need joins, transactions, or row-level security? If yes, Postgres wins on correctness.
- Are you under roughly 10 million vectors and moderate QPS? If yes, pgvector performance is usually sufficient.
- Will launch traffic multiply query cost on a usage-based vector SaaS? If yes, model the bill before committing.
- Are you building a vector-native product at billion-vector scale? If yes, evaluate dedicated engines with open benchmarks on your embedding size and filter patterns.
Bottom Line
The 2023 playbook was: PostgreSQL for rows, vector database for embeddings, glue in the middle. The 2026 playbook for most teams is simpler: PostgreSQL for rows and embeddings, tune HNSW, add hybrid search where needed, and graduate to a specialized vector store only when scale and SLAs demand it.
Developers are not going back because Postgres is trendy. They are going back because the split stack created sync bugs, permission leaks, and surprise bills. pgvector turns RAG into a database problem teams already know how to solve. For everything else, dedicated vector databases still earn their place at the far end of the scale curve.
Bibliography
- BackendBytes. (2026). Vector databases compared: pgvector vs Pinecone vs Weaviate. https://backendbytes.com/articles/vector-databases-comparison/
- BuildSpace. (2026). PostgreSQL as a vector database: Should you use pgvector or Pinecone for RAG in 2026? https://buildspace.site/blog/postgresql-pgvector-vs-pinecone-rag-2026
- DBA Dataverse. (2026, May). pgvector vs Pinecone vs Weaviate: A production DBA's verdict. https://dbadataverse.com/tech/postgresql/2026/05/pgvector-vs-pinecone-vs-weaviate-a-production-dbas-verdict-2026
- InfoQ. (2025, August). Instacart consolidates search infrastructure on PostgreSQL, phasing out Elasticsearch. https://www.infoq.com/news/2025/08/instacart-elasticsearch-postgres/
- Instacart. (2024). How Instacart built a modern search infrastructure on Postgres. https://www.instacart.com/company/tech-innovation/how-instacart-built-a-modern-search-infrastructure-on-postgres
- JusDB. (2026). Vector databases comparison: pgvector vs Pinecone vs Weaviate. https://www.jusdb.com/blog/vector-databases-comparison-pgvector-pinecone-weaviate-2026
- Kalvium Labs. (2026). pgvector vs Pinecone vs Qdrant vs Weaviate: Which we actually use in production. https://www.kalviumlabs.ai/blog/vector-databases-compared-pgvector-pinecone-qdrant-weaviate/
- Khimananda. (2026). Vector databases for RAG: pgvector vs Pinecone. https://khimananda.com/blog/vector-databases-for-rag-pgvector-vs-pinecone
- Kunal Ganglani. (2026). pgvector vs Pinecone 2026: Full comparison. https://www.kunalganglani.com/blog/pgvector-vs-pinecone
- Moiz Nisar. (2025). Why I skipped Pinecone and used pgvector for my RAG system. https://moiznisar.hashnode.dev/why-i-skipped-pinecone-and-used-pgvector-for-my-rag-system-and-when-you-should-too
- OpenHelm. (2026). Pinecone vs Weaviate vs Qdrant vs pgvector: Vector database showdown. https://openhelm.ai/blog/pinecone-vs-weaviate-vs-qdrant-vs-pgvector
- PostgreSQL Global Development Group. (n.d.). pgvector extension. https://github.com/pgvector/pgvector
- Rivestack. (2026). pgvector vs Pinecone: Which should you use in 2026? https://rivestack.io/blog/pgvector-vs-pinecone
- Suparbase. (2026). pgvector and Postgres for RAG: A 2026 production setup. https://suparbase.com/blog/pgvector-rag-production