Skip to content

Top 30 Vector Database Interview Questions and Answers [2026]

November 19, 2026 26 min read
Vector DB interview guide by Second Talent
TL;DR: Vector database interviews in 2026 test index choice and tuning, filtered search that keeps recall, hybrid search, quantization with rescoring, recall measurement and safe reindexing when the embedding model changes. Current releases: pgvector 0.8.7 (October 1, 2026), Qdrant 1.20.0 (October 22, 2026), Weaviate 1.40 (October 7, 2026), Milvus 3.0 (July 29, 2026) and Pinecone API version 2026-07.

Qdrant 1.20.0 shipped on October 22, 2026 with BM25 scoring on its full-text payload index and new turbo8 and turbo16 vector datatypes, two months after Pinecone made full-text search generally available.

Keyword and vector retrieval now live in the same engine at most vendors, as the Qdrant 1.20.0 changelog shows.

These questions cover pgvector, Pinecone, Qdrant, Weaviate and Milvus for US hiring managers interviewing engineers who build retrieval for RAG and search, and for engineers preparing for those loops.

Key takeaways
  1. 1pgvector filters after the index scan. With the default hnsw.ef_search of 40 and a filter matching 10% of rows, a query returns about 4 rows on average.
  2. 2pgvector can index vector columns up to 2,000 dimensions, halfvec up to 4,000 and bit up to 64,000.
  3. 3Weaviate reports 8-bit rotational quantization gives 4x compression at 98% to 99% recall in its internal tests.
  4. 4Since January 23, 2026, Pinecone rejects filters with more than 10,000 values in one $in or $nin, so ACL lists need a different design.

Fundamentals

1. What does a vector database do that a B-tree index cannot?

It answers "which stored vectors are closest to this one?" quickly. A B-tree orders scalar values, and nearest neighbor search in hundreds of dimensions has no useful ordering, so an exact search compares the query against every vector.

That is fine at 50,000 rows and too slow at 50 million.

Vector databases build approximate nearest neighbor (ANN) indexes such as HNSW, IVF or DiskANN that inspect a small fraction of vectors and return most of the true neighbors.

The trade is explicit: you give up some recall for orders of magnitude less latency.

Around the index, a vector database adds what production retrieval needs: metadata filtering, keyword and hybrid search, multitenancy, replication and online updates.

A strong candidate states that pgvector without an index performs exact search with perfect recall, so for small tables the right answer can be "no ANN index at all". A weak one treats approximate results as exact and never measures recall.

2. Cosine, dot product or Euclidean distance: how do you choose?

Use the metric the embedding model was trained for, which the model card states.

For vectors normalized to length 1, cosine distance, dot product and Euclidean distance produce the same ranking, so many teams normalize at write time and use dot product, which is cheapest to compute.

The implementation details are where candidates slip. In pgvector, <-> is L2 distance, <=> is cosine distance, <+> is L1, and <#> returns the negative inner product, because Postgres index scans only run in ascending order.

The pgvector README shows the conversions:

SELECT (embedding <#> '[3,1,2]') * -1 AS inner_product FROM items;
SELECT 1 - (embedding <=> '[3,1,2]') AS cosine_similarity FROM items;

A candidate who sets a similarity threshold of 0.8 without knowing whether the column holds distance or similarity will filter out the best results.

3. How do embedding dimensions affect cost, and how would you cut them?

Raw float32 storage is 4 bytes per dimension. In pgvector each vector takes 4 * dimensions + 8 bytes, so a 1,536-dimension embedding is about 6 KB.

Ten million of them is roughly 61 GB before index overhead, and HNSW performs best when the index fits in memory.

Ways to cut it, roughly in order of how much recall they cost:

  • Half precision: pgvector's halfvec stores 2 bytes per dimension and can be indexed up to 4,000 dimensions.
  • Shorter embeddings: models trained with Matryoshka representation learning, such as OpenAI's text-embedding-3 family through its dimensions parameter, can be truncated to 512 or 256 dimensions with a measured recall loss.
  • Quantization: scalar (4x), binary (up to 32x) or newer schemes, usually with rescoring (questions 11 and 12).

A strong candidate runs the recall evaluation from question 4 at each setting and picks the smallest representation that meets the target, rather than defaulting to the largest model.

4. How do you measure recall for a vector index?

Compare the ANN results to exact results on the same queries.

Take a few hundred real or representative queries, run exact k-nearest-neighbor search (a flat index, or pgvector with no index) to get ground truth, then run the ANN query and compute recall@k: the share of the true top k that the ANN query returned.

def recall_at_k(ann_ids: list[list[str]], exact_ids: list[list[str]], k: int = 10) -> float:
    hits = 0
    for ann, exact in zip(ann_ids, exact_ids):
        hits += len(set(ann[:k]) & set(exact[:k]))
    return hits / (k * len(exact_ids))

Two levels of measurement matter. Index recall tells you whether the ANN structure finds the true neighbors.

Retrieval quality (hit rate or nDCG against labeled relevant documents) tells you whether the neighbors are the right answer for users, which also depends on chunking and the embedding model.

A strong candidate tracks both, measures with production filters applied, and reruns the evaluation after every change to index parameters or quantization.

Indexes

5. How does HNSW work, and what do its parameters control?

HNSW (Hierarchical Navigable Small World) builds a layered graph.

Upper layers hold few nodes with long links for coarse navigation, the bottom layer holds every vector, and a search greedily walks from the top toward the query, keeping a candidate list as it descends.

  • m: maximum connections per node per layer. pgvector defaults to 16. Higher values raise recall and memory.
  • ef_construction: candidate list size during build. pgvector defaults to 64. Higher values give a better graph and slower builds and inserts.
  • ef_search: candidate list size at query time. pgvector defaults to 40. This is the main runtime knob for recall against latency.
CREATE INDEX ON items USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 64);

BEGIN;
SET LOCAL hnsw.ef_search = 100;
SELECT id FROM items ORDER BY embedding <=> $1 LIMIT 10;
COMMIT;

HNSW has strong query performance and handles inserts without a training step, at the cost of memory and slow builds. SET LOCAL scopes the change to one transaction, which matters behind a connection pooler.

6. How does an IVF index differ, and how do you size it?

IVF (inverted file) clusters vectors into lists with k-means, then searches only the lists closest to the query. In pgvector this is IVFFlat.

The README says it builds faster and uses less memory than HNSW but has a worse speed-recall trade-off.

Sizing rules from the pgvector docs:

  • Create the index after the table has data, because the lists are trained on existing rows.
  • Start with lists = rows / 1000 up to 1 million rows and sqrt(rows) above that.
  • Query with ivfflat.probes around sqrt(lists). The default is 1, which gives poor recall.
CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 1000);
SET ivfflat.probes = 32;

The failure a strong candidate knows: an IVF index built on a small or unrepresentative sample keeps bad centroids as data grows or drifts, and recall falls until you rebuild. pgvector's FAQ also notes that building with too little data for the number of lists makes queries return fewer results.

7. HNSW, IVF or DiskANN: when do you pick each?

  • HNSW: the default for most workloads that fit in RAM, with frequent inserts and strict latency targets. Every major engine supports it.
  • IVF variants (IVFFlat, IVF_PQ): when build time and memory matter more than peak recall, or for very large static collections where product quantization keeps lists small.
  • DiskANN: when the collection is too large for RAM. It keeps a compressed copy in memory and the graph and full vectors on SSD, trading some latency for much lower memory cost. Milvus 3.0 extended DiskANN to multi-vector embedding lists.
  • Flat / exact: small collections, highly selective filters, or ground truth for evaluation.

A strong candidate turns this into numbers: vector count, dimensions, bytes per vector after quantization, target p99 latency and write rate, and they mention the hardware budget. Weak answers pick a database before stating any of these.

8. What does this query return?

-- items has 2 million rows and an HNSW index on embedding.
-- Session defaults: hnsw.ef_search = 40, no iterative scan.
SELECT id
FROM items
ORDER BY embedding <=> $1
LIMIT 100;

Answer: at most 40 rows, not 100. The pgvector README says results are limited by the dynamic candidate list, hnsw.ef_search, which defaults to 40, and dead tuples or filters can reduce the count further.

Fix: set hnsw.ef_search to at least the LIMIT (with headroom, say 200 for LIMIT 100) for that query, or enable iterative index scans (question 16).

This bites teams that retrieve 100 candidates for a reranker: the reranker sees 40 and nobody notices because no error is raised. A candidate who has tuned pgvector in production usually knows this one.

9. Find the bug: the HNSW index exists but every query does a sequential scan.

CREATE TABLE docs (id bigserial PRIMARY KEY, embedding vector(1536));
CREATE INDEX ON docs USING hnsw (embedding vector_l2_ops);

-- application query
SELECT id FROM docs ORDER BY embedding <=> $1 LIMIT 10;

Bug: the index uses the L2 operator class (vector_l2_ops) and the query orders by cosine distance (<=>). Postgres can only use an index whose operator class matches the operator, so it falls back to an exact scan of every row.

Fix: create the index with vector_cosine_ops, or change the query to <-> if the vectors are normalized and L2 ranking is equivalent. Confirm with EXPLAIN that the plan shows an index scan.

Related traps the candidate should list: a query without ORDER BY ... LIMIT (a WHERE embedding <-> $1 < 0.5 alone cannot use the index), and an expression index on embedding::halfvec(1536) that requires the query to use the same cast.

10. How do you build a vector index on 50 million rows without taking the app down?

Bulk load first and build the index after, since inserting into an existing HNSW graph is far slower than one build. Then plan for memory and locks:

  • Memory: pgvector builds fastest when the graph fits in maintenance_work_mem. It logs a notice when the graph no longer fits, and the build slows sharply.
  • Parallelism: raise max_parallel_maintenance_workers (default 2), and max_parallel_workers (default 8) if needed.
  • Locking: use CREATE INDEX CONCURRENTLY on a live table so writes continue.
SET maintenance_work_mem = '8GB';
SET max_parallel_maintenance_workers = 7;
CREATE INDEX CONCURRENTLY docs_embedding_idx ON docs USING hnsw (embedding vector_cosine_ops);

On managed services, check the memory ceiling before setting 8 GB.

Dedicated engines differ: Qdrant and Milvus build segment indexes in the background while new points sit in unindexed segments, so a strong candidate asks how search behaves on those unindexed segments during a big import.

Quantization and Memory

11. Compare scalar, product and binary quantization.

  • Scalar: maps each float32 to an 8-bit integer, about 4x smaller. Qdrant's docs put the error at usually under 1%. The safe first step.
  • Product (PQ): splits a vector into sub-vectors and replaces each with the ID of its nearest centroid. Qdrant documents up to 64x compression. Highest compression, slowest to search, largest recall loss.
  • Binary: keeps one bit per dimension, 32x smaller, with Hamming distance that is very fast to compute. It works best on high-dimensional embeddings whose values are centered around zero, and it depends on rescoring.

Per the Qdrant quantization docs, version 1.15 added 2-bit and 1.5-bit binary encodings (16x and about 21x) as middle steps.

A strong candidate notes that compression ratios only approach their nominal values at high dimensions, and that quantization changes which vectors are near each other, so the recall test in question 4 must be repeated after enabling it.

12. What are rescoring and oversampling, and how do you configure them?

Quantized search finds candidates fast but ranks them with approximate distances.

Oversampling fetches more candidates than requested from the quantized index, and rescoring recomputes distances for those candidates using the original vectors, then returns the top k.

// Qdrant query parameters
{
  "query": [0.12, 0.98, 0.33],
  "limit": 100,
  "params": {
    "quantization": { "rescore": true, "oversampling": 2.4 }
  }
}

With oversampling: 2.4 and limit: 100, Qdrant pre-selects 240 candidates. Weaviate uses rescoreLimit for the same idea. In pgvector you write it yourself:

SELECT * FROM (
    SELECT * FROM items
    ORDER BY binary_quantize(embedding)::bit(1536) <~> binary_quantize($1)
    LIMIT 200
) candidates
ORDER BY embedding <=> $1
LIMIT 10;

The trade-off: rescoring reads full vectors. If originals live on slow disk, each query pays that I/O. A strong candidate measures recall and p99 at several oversampling values rather than picking one.

13. What are rotational quantization and TurboQuant, and why did vendors add them?

Both aim for better recall at the same compression than plain scalar or binary quantization. Rotating vectors before quantizing spreads information evenly across dimensions, so no single coordinate dominates the error.

  • Weaviate RQ: 8-bit RQ arrived for HNSW in 1.32, 1-bit in 1.33, flat index support in 1.35 and 4-bit in 1.40. Per the Weaviate quantization docs, 8-bit RQ gives 4x compression at 98% to 99% recall in internal tests, often with rescoring off. Quantization is not on by default; since 1.33 you can set a default with DEFAULT_QUANTIZATION.
  • Qdrant TurboQuant: added in 1.18, with bit depths from 8 bits (4x) to 1 bit (32x) and 4-bit as the default. Qdrant recommends 8-bit TurboQuant over scalar at the same 4x ratio, except with Manhattan distance. 1.19 allowed 4-bit TurboQuant as the primary storage type, and 1.20 added turbo8 and turbo16 datatypes.

A strong candidate treats vendor recall figures as a starting point and benchmarks on their own embeddings, since these numbers come from the vendors' internal tests.

14. Your collection outgrew RAM. What are the options before buying bigger machines?

  1. Quantize and keep only compressed vectors in RAM, with originals on disk for rescoring.
  2. Move the index to disk: DiskANN in Milvus, on-disk HNSW or memory-mapped storage elsewhere. Qdrant 1.19 unified memory settings per collection component as cold, cached or pinned, so you can pin quantized vectors and leave originals cold.
  3. Cut dimensions with a shorter Matryoshka embedding (question 3).
  4. Tier tenants: keep active tenants in memory and move idle ones out. Weaviate can mark each tenant active, inactive or offloaded to cloud storage.
  5. Shard across nodes once a single node's memory and CPU are both near limits.

Each step has a cost: disk-based search raises latency and depends on SSD IOPS, so a strong candidate brings p99 targets and an IOPS budget into the answer.

Filtering and Hybrid Search

15. Why do metadata filters hurt recall, and what are the strategies?

An ANN index is built on vector proximity, not on your filter. Three strategies exist:

  • Post-filtering: search the index, then drop rows that fail the filter. Simple, and it returns too few results when the filter is selective. pgvector works this way by default.
  • Pre-filtering: find matching IDs first, then search only among them. Exact for selective filters and slow for broad ones.
  • Filter-aware graph search: traverse the graph while checking the filter, with extra links or fallbacks so the walk does not get stuck in regions where no node matches. Qdrant's filterable HNSW and ACORN, and similar features in other engines, take this route.

Most engines switch strategy based on estimated filter cardinality, using payload index statistics.

A strong candidate asks how selective the production filters are (one tenant out of 10,000, or "language = en" matching 80%) before picking a design, and measures recall with those filters applied.

16. How do pgvector's iterative index scans work?

Added in pgvector 0.8.0, iterative scans keep scanning more of the index when filtering leaves too few results, until enough rows are found or a limit is hit.

SET hnsw.iterative_scan = strict_order;   -- results stay exactly ordered by distance
SET hnsw.iterative_scan = relaxed_order;  -- better recall, slight reordering allowed
SET hnsw.max_scan_tuples = 20000;         -- default ceiling on tuples visited

SELECT id FROM items
WHERE category_id = 123
ORDER BY embedding <-> $1
LIMIT 10;

With relaxed_order, the README recommends a materialized CTE to restore strict ordering, and on Postgres 17 and later the outer sort needs distance + 0:

WITH relaxed AS MATERIALIZED (
    SELECT id, embedding <-> $1 AS distance
    FROM items WHERE category_id = 123
    ORDER BY distance LIMIT 10
)
SELECT * FROM relaxed ORDER BY distance + 0;

Other pgvector options a strong candidate names: a B-tree index on the filter column for highly selective filters (exact search over few rows), a partial HNSW index per hot category, or table partitioning by tenant.

17. How do you make filtered search fast in Qdrant?

Create payload indexes on every field you filter by.

Qdrant uses them both to evaluate filters and to plan the query: for a very selective filter it can skip the graph and score matching points directly, and for broader filters it uses filter-aware HNSW traversal.

Without a payload index, filters fall back to scanning payloads.

Features from recent releases that a candidate working on Qdrant should know:

  • ACORN (1.16): a search method that stays accurate over many filtered points at some cost in speed.
  • Prefix match in keyword filters (1.19) and a full-scan-only substring condition (1.20).
  • Per-element indexes for arrays of objects (1.20) for nested filters.
  • Tenant indexes: a keyword payload index marked is_tenant: true co-locates each tenant's data for faster per-tenant search.

A weak candidate filters in application code after retrieving the top 100, which drops recall the same way post-filtering does.

18. How does hybrid search work, and how do you fuse the two result lists?

Hybrid search runs a keyword retriever (BM25 or a learned sparse model such as SPLADE) and a dense vector retriever, then merges the results.

Keyword search catches exact terms, product codes and names that embeddings blur; dense search catches paraphrases.

Reciprocal rank fusion (RRF) is the common merge: each document scores the sum of 1 / (k + rank) across the lists it appears in, so only rank positions matter. In Qdrant, hybrid search is a Query API call with prefetches:

client.query_points(
    collection_name="docs",
    prefetch=[
        models.Prefetch(query=models.SparseVector(indices=[1, 42], values=[0.22, 0.8]), using="sparse", limit=20),
        models.Prefetch(query=dense_vector, using="dense", limit=20),
    ],
    query=models.RrfQuery(rrf=models.Rrf()),
    limit=10,
)

Per the Qdrant hybrid query docs, the k constant became configurable in 1.16 and weighted RRF arrived in 1.17.

Weaviate's hybrid query uses alpha (1 is pure vector, 0 is pure keyword), and its hybrid search docs state relative score fusion has been the default since 1.24.

19. Find the bug in this hybrid merge.

def hybrid(query: str, k: int = 10):
    dense = vector_search(embed(query), limit=50)   # [(doc_id, cosine_similarity)]
    sparse = bm25_search(query, limit=50)           # [(doc_id, bm25_score)]

    scores = {}
    for doc_id, s in dense + sparse:
        scores[doc_id] = scores.get(doc_id, 0) + s

    return sorted(scores, key=scores.get, reverse=True)[:k]

Bug: it adds raw scores on different scales. Cosine similarity sits between -1 and 1, while BM25 scores are unbounded and often range from 5 to 30 depending on query length and corpus statistics.

BM25 dominates every result, so the dense retriever barely affects ranking, and the balance changes from query to query.

Fix: use rank-based fusion (RRF), or normalize each list (min-max or relative score fusion, as Weaviate does) before weighting. Then tune the weight on a labeled evaluation set.

A follow-up for senior candidates: documents that appear in only one list get no contribution from the other, so the candidate limit per retriever (50 here) affects results and belongs in the evaluation.

20. When do you add a reranker, and how many candidates do you give it?

Add a cross-encoder reranker when first-stage retrieval finds the right documents but ranks them poorly, which shows up as good recall@50 and weak precision@5.

A cross-encoder reads the query and each candidate together, so it scores relevance much better than vector distance, at a cost of one model call per candidate.

Typical shape: retrieve 50 to 200 candidates with hybrid search, rerank, keep the top 5 to 10 for the LLM context. The candidate count is a latency budget question.

Doubling it doubles reranker cost and helps only if relevant documents sit beyond the current cutoff, which you check with recall@k at several values of k. Engines are absorbing this step: Milvus 3.0 added a Function Chain API for model-based reranking inside the search request.

A strong candidate also caches reranker results for repeated queries and remembers question 8, since a pgvector ef_search of 40 caps the candidate pool silently.

Multitenancy, Updates and Reindexing

21. How do you isolate tenants in a vector database?

Options, from strongest isolation to cheapest:

  • Collection or index per tenant: clean isolation and easy deletion, but thousands of collections strain most engines.
  • Native tenant partitions: Pinecone namespaces (up to 1,000,000 per serverless index on Enterprise since September 2026), Weaviate multi-tenancy with one shard per tenant, Milvus partition keys, and Qdrant tenant payload indexes.
  • Shared collection with a tenant filter: cheapest, and one missing filter in one code path leaks data across customers.

The right answer depends on tenant count, size skew and compliance needs. Large tenants can be promoted to dedicated shards; Qdrant 1.16 added tiered multitenancy for that.

A strong candidate enforces the tenant filter in one data access layer, never in each caller, and tests that a query without a tenant ID fails.

22. What happens to an HNSW index when you update and delete heavily?

Deletes usually mark nodes as removed (tombstones) and the graph keeps routing through them until cleanup. Updates are a delete plus an insert.

Under heavy churn, dead nodes consume memory, slow searches and can reduce recall until the engine repairs links or rebuilds segments.

In pgvector, Postgres VACUUM does the cleanup, and vacuuming an HNSW index is slow because it repairs graph connections.

The pgvector changelog shows how sensitive this path is: 0.8.3 (June 17, 2026) fixed possible index corruption during HNSW vacuuming and 0.8.4 fixed a "graph not repaired" error. The README's advice for faster vacuums is to reindex first.

Dedicated engines compact segments in the background (Milvus also has operator-triggered Force Merge in 3.0). A strong candidate monitors deleted-to-live ratios and schedules rebuilds instead of assuming the index heals itself.

23. You are switching to a new embedding model. How do you reindex without downtime?

Vectors from different models live in different spaces, so you cannot mix them in one index or compare old query embeddings with new document embeddings. The safe pattern is blue/green:

  1. Create a new collection, index or vector field for the new model.
  2. Dual-write new and updated documents to both.
  3. Backfill existing documents through a rate-limited batch job that respects embedding API quotas.
  4. Run both side by side on an evaluation set and a slice of live traffic.
  5. Switch reads by flipping an alias, then retire the old index.

Aliases make step 5 atomic: Qdrant and Milvus have collection aliases, and Pinecone added namespace aliases on September 29, 2026.

Milvus 3.0 also supports adding a column online and backfilling it, which its 3.0.0 release notes describe as an embedding upgrade over hundreds of millions of rows without downtime.

A strong candidate stores the model name and version with each vector so mixed states are detectable.

24. A user uploads a document and searches for it a second later. It is not found. Why?

Most vector databases are eventually consistent between write and search, for several reasons: the write is acknowledged before it is applied, new points sit in a segment that is searchable but not yet indexed, or the read goes to a replica that has not caught up.

Fixes depend on the engine. Qdrant's upsert takes a wait parameter that returns only after the operation is applied.

Milvus lets you choose a consistency level per request (Strong, Bounded, Session or Eventually), where Session gives read-your-own-writes for the same client. Qdrant 1.19 added a routing token for deterministic read routes.

Pinecone serverless indexes have a short delay before new records are queryable.

A strong candidate designs the UX around this (show the upload as "processing" until it is searchable) rather than forcing strong consistency on every query, which costs latency.

25. How do you size a vector deployment for 100 million vectors at 500 queries per second?

Work through it out loud:

  • Raw size: 100M x 768 dimensions x 4 bytes is about 307 GB in float32.
  • Compressed: 8-bit quantization brings the in-memory copy to about 77 GB, binary to about 10 GB, plus HNSW links (roughly m to 2m neighbor IDs per vector at the base layer).
  • Throughput: benchmark single-node QPS at the target recall and p99, then divide 500 QPS by it with headroom for peaks and node loss, and add replicas.
  • Writes: ingestion rate and index build time decide how many nodes absorb writes without hurting reads.

Managed services package these choices differently. Pinecone's Dedicated Read Nodes became generally available on April 15, 2026 for steady, high read volumes, alongside on-demand serverless capacity, per the Pinecone 2026 release notes.

A strong candidate presents a range with assumptions written down and says which benchmark would confirm it.

Choosing and Designing

26. pgvector or a dedicated vector database?

pgvector fits when vectors belong next to relational data: transactions update a row and its embedding together, filters join to other tables, backups and access control already exist, and the collection is in the low tens of millions or less.

One system to run is a real advantage.

A dedicated engine fits when the vector workload dominates: hundreds of millions of vectors, high QPS with strict p99, heavy filtering that needs filter-aware traversal, built-in hybrid search and quantization options, or tenant counts that Postgres partitioning handles poorly.

Running a second system brings sync pipelines between the primary database and the vector store, and those pipelines are a common source of stale or missing results.

A strong answer picks based on numbers and team capacity and names the migration trigger (for example, "when the HNSW index no longer fits in RAM on our largest Postgres instance"). Our PostgreSQL interview guide covers the Postgres side.

27. Design retrieval for a RAG assistant over 50 million document chunks with per-user permissions.

Strong answers cover these decisions:

  • Chunking and metadata: chunk by document structure, and store document ID, tenant ID, permission groups, source, updated time and embedding model version with each chunk.
  • Permissions: filter by tenant and by group IDs at query time with indexed metadata. Avoid sending a user's full list of document IDs, which hits limits such as Pinecone's 10,000 values per $in and scales badly anyway.
  • Retrieval: hybrid search with RRF, then a reranker over 50 to 100 candidates.
  • Freshness: an ingestion pipeline driven by change events, with deletes propagated quickly, since a revoked document must disappear from results.
  • Evaluation: a labeled query set per tenant type, recall@k and answer quality tracked per release.

The weak design checks permissions after retrieval and drops forbidden chunks, which leaks through ranking side effects and returns too few results. For the LLM side of the system, see our LLM engineer interview guide.

28. How does chunk size interact with the vector index?

Smaller chunks give more precise matches and more vectors, so a 10x smaller chunk size means roughly 10x more vectors, memory and index build time.

Larger chunks cut vector count but dilute the embedding, because one vector has to represent several topics, and they fill the LLM context faster.

Common patterns: overlap chunks slightly so sentences at boundaries are not lost; embed small chunks but return the parent section to the LLM; and for long documents, store a document-level embedding for routing plus chunk embeddings for detail.

Multi-vector approaches go further: Weaviate supports multi-vector embeddings with MUVERA encoding, and Milvus 3.0 added DiskANN indexing for embedding lists.

A strong candidate tunes chunk size with the same recall evaluation as index parameters, since it changes results at least as much.

What Changed Recently

Nov 17, 2025
Qdrant 1.16: ACORN filtered search, tiered multitenancy, configurable RRF k
Feb 20, 2026
Qdrant 1.17: weighted RRF, relevance feedback, audit logging
Apr 15, 2026
Pinecone Dedicated Read Nodes generally available
May 11, 2026
Qdrant 1.18: TurboQuant quantization; RocksDB support removed
Jul 29, 2026
Milvus 3.0.0: external collections, online schema backfill, SINDI sparse index
Sep 2, 2026
Pinecone full-text search generally available on API version 2026-07
Oct 1, 2026
pgvector 0.8.7 fixes a buffer overflow in IVFFlat index builds
Oct 7, 2026
Weaviate 1.40: namespaces GA, 4-bit RQ, drop vector index GA
Oct 22, 2026
Qdrant 1.20: BM25 on full-text index, turbo8 and turbo16 datatypes

29. What changed in pgvector over the last year, and what is coming in 0.9.0?

The 0.8.x line has been about stability and Postgres 18. 0.8.1 (September 4, 2025) added Postgres 18 support and sped up binary_quantize. 0.8.2 (February 25, 2026) fixed a buffer overflow in parallel HNSW builds.

0.8.3 and 0.8.4 (June 2026) fixed HNSW vacuuming bugs, including possible index corruption, and 0.8.7 (October 1, 2026) fixed a buffer overflow in IVFFlat builds.

The pgvector changelog lists 0.9.0 as unreleased, with asynchronous I/O for HNSW indexes, faster HNSW inserts for sparsevec, and support for Postgres 13 and 14 dropped.

A strong candidate running pgvector in production knows their exact version, because the vacuum fixes in 0.8.3 and 0.8.4 matter for any table with frequent deletes, and they plan the Postgres upgrade that 0.9.0 will require on older clusters.

30. What did Milvus 3.0 change for teams running Milvus 2.6?

Milvus 3.0.0 (July 29, 2026) moved toward a lake-native design. The headline features from its release notes:

  • External collections that index and search Parquet, Lance, Iceberg or Vortex files in place without copying them into Milvus.
  • Online schema changes: add, backfill and drop columns while serving.
  • A rebuilt sparse index with SINDI, Block-Max WAND and Block-Max MaxScore. Milvus reports the compressed BM25 index is about 3x smaller than in 2.6.
  • TEXT fields for long text with text_match, phrase match and BM25, and a FAISS index type that accepts Faiss factory strings.
  • Entity TTL, nullable vectors, snapshots and server-side aggregation and ORDER BY.

The operational notes matter more in an interview: Storage V3 is off by default and needed for snapshots and TEXT fields, new index versions are opt-in through dataCoord.targetVecIndexVersion, and rollback to 2.6 is guaranteed only until you enable a feature that changes the data format.

A strong candidate would upgrade, verify, and only then turn on format-changing features one at a time.

Signs of a Strong Answer

  • They measure recall against exact search, with production filters applied, before and after every index or quantization change.
  • They know pgvector's defaults (m 16, ef_construction 64, ef_search 40) and that ef_search caps the result count.
  • They match operator classes to query operators and check plans with EXPLAIN.
  • They fuse hybrid results by rank or normalized score, never by adding raw BM25 and cosine values.
  • They enforce tenant and permission filters in one place, with indexed metadata, before ranking.
  • They reindex for a new embedding model with dual writes, a backfill and an alias swap, and store the model version with each vector.

Hiring Vector Database Engineers

Engineers who have tuned HNSW under real filters, cut a vector bill with quantization and moved a production index to a new embedding model without downtime are rare, and most résumés that list "RAG" have done none of these.

The RAG engineer role guide describes the job, and our LLM engineer and AI agent developer interview guides cover the layers above retrieval.

Second Talent helps US startups hire vetted AI-Native Engineers from Asia, at $23 to $39 USD an hour billed monthly, with matches in 24 hours and a 90-day one-time replacement guarantee.

See LLM developers for hire, compare rates on the cost to hire an LLM developer page, or tell us what you need.

Get developers who ship with AI agents. Starts at $25/Hour.

Start Hiring $0 cost until you hire