Vector Database Security and Real-Time CDC: A Buyer's Guide to Multi-Tenant Isolation and Low-Ops Kafka Pipelines
A buyer's guide to multi-tenant vector search security: where tenant isolation is enforced, how filtered ANN recall is measured, and what managed Kafka CDC pipelines absorb versus relocate.
Two decisions determine whether a multi-tenant vector search stack survives production. The first is where tenant isolation is enforced — in the vector store's own structure, in a database policy engine, or in application code that a single missing predicate can bypass. The second is whether tenant identity survives the trip from a source database row, through a CDC connector and Kafka, into the vector index and back out at query time.
This guide treats both as things you evaluate rather than things you buy. Vendor documentation is useful for establishing what a platform can do and what its documented limits are; it is not evidence that the configuration in front of you returns correct results at your tenant cardinality and your filter selectivity. The sections below build a needs assessment, then a set of criteria tied to concrete enforcement mechanisms, then a red-flag list, then the pipeline architecture and its operational cost model. Every recommendation is conditional on your answers to the assessment questions.
One framing note applies throughout: recall and isolation are properties you measure in your own environment. A benchmark run on unfiltered data tells you how an index behaves when no tenant filter is present, which is not the query your application issues.
Start With Your Own Constraints, Not a Product List
Before comparing platforms, write down five numbers and constraints. They determine which architectures are even candidates, and they are the inputs to every test later in this guide.
Current tenant count and 24-month growth. A hundred tenants and a hundred thousand tenants point to different isolation models.
Filter selectivity. For a typical query, what fraction of the index belongs to the requesting tenant? If each tenant owns a small slice of a shared collection, your filters are highly selective, and that is the regime where approximate indexes are most likely to under-return.
Isolation obligation. Is separation a product requirement, a contractual term, a regulatory requirement, or all three? The answer decides whether logical enforcement with a platform backstop is acceptable or whether each tenant needs its own physical boundary.
Deletion obligation. What must happen when a tenant leaves or exercises an erasure right, and what evidence must you be able to produce afterward?
Operational appetite. Which tasks will your team own, and which must a managed service absorb?
Tenant count and growth shape the isolation model
Isolation strategies do not scale the same way, and the documented limits are the place to start. Milvus documents four multi-tenancy levels with different ceilings: database-level isolation defaults to 64 databases (raised by changing maxDatabaseNum in Milvus.yaml), collection-level defaults to 65,536 collections (raised via maxCollectionNum), partition-level supports up to 1,024 partitions per collection, and partition-key level supports millions of tenants. Pinecone's namespace-per-tenant model documents namespace counts that vary by plan, from 100 on Starter to 1,000,000 on Enterprise, with the option to contact support for higher limits.
Those are vendor-reported figures tied to specific configuration parameters and plan terms. Verify them against the version and plan you would actually run, and treat the growth curve as the deciding variable: a model with a hard ceiling is fine if your tenant count is stable and small, and a liability if you add thousands of tenants a quarter.
The shared-collection model with a tenant field scales to millions of tenants, but it moves isolation from structure to logic. That is not automatically worse — it is a different enforcement point with different failure modes, covered in the next section.
How selective your filters are decides whether ANN recall holds
Multi-tenant vector search almost always issues a highly selective filter: return the nearest neighbors within this tenant. That is precisely the query shape where approximate nearest neighbor indexes struggle, because the graph traversal was built to find global neighbors, not neighbors inside a small subset.
The three strategies behave differently. Pre-filtering applies the filter first and then compares the query against every matching point; results are exact, but scoring every match is expensive when many points pass the filter. Post-filtering runs the vector search first and discards non-matching results afterward, which can leave you with fewer results than you asked for — or none — when the filter is selective. Filtering during the search walks the graph while skipping points that fail the filter, which is the approach Qdrant documents as its default behavior, backed by a filterable HNSW index that adds edges between points sharing an indexed payload value.
Elastic documents the counterintuitive consequence directly: in approximate kNN search with an HNSW index, filters can make a search slower rather than faster, because the search has to explore more of the graph to collect enough candidates that satisfy the filter. That is the opposite of conventional query filtering, where a stricter filter usually speeds things up. Elastic's guidance is to pre-filter when the filter is selective, and it notes that post-filtering is a reasonable choice when the filter matches most of your documents.
For your assessment, the operative question is: what share of the index does a typical tenant filter match? If the answer is a fraction of a percent, plan to measure recall under exactly that condition.
What "delete this tenant" must actually reach
A tenant deletion is not one operation. Enumerate the surfaces it must cover before you evaluate any platform:
the primary index or collection holding the tenant's vectors;
replicas and shards derived from that data;
backups and snapshots;
caches in front of the vector store, including any response cache in the retrieval layer;
derived embeddings and enrichment outputs stored elsewhere in the pipeline;
CDC topics and any intermediate storage that carried the tenant's rows.
Backup coverage is not automatic. Weaviate documents that offloaded tenants are not included in a backup because their data is not held on local disk — the tenant status is preserved, but the tenant's data is not part of the backup, and offloaded tenants must be activated before creating a backup to include their data. That is one vendor's documented behavior for one tenant state; the general lesson is that "the tenant is deleted from the index" and "the tenant is absent from every copy" are different claims, and only the second one survives an audit.
Write the deletion procedure as a checklist with a named owner for each surface, then test it. A procedure that has never been executed against a real tenant is a hypothesis.
Operational appetite: what "without lots of ops" means for you
"Low ops" is not a property of a product; it is a division of labor. Name the tasks your team is willing to own before you compare managed offerings, because a managed service that absorbs one task and relocates three others has not reduced your workload in the way you intended.
The recurring candidates are: connector upgrades and version compatibility, replication slot monitoring, WAL growth management, Kafka offset storage and recovery, schema change handling, embedding compute capacity, index rebuilds after mapping or model changes, backup verification, and tenant deletion drills. The pipeline section below itemizes these against what managed services typically absorb, relocate, or leave untouched.
Evaluation Criteria: Where Isolation and Recall Are Actually Enforced
The criteria below separate enforcement points that are structural — the platform refuses to return another tenant's data — from those that are decorative, where a bug, a missing predicate, or a misconfigured connection silently removes the boundary.
Illustration of pgvector's documented post-scan filtering arithmetic, not a benchmark. With the default HNSW candidate list (hnsw.ef_search = 40), the number of rows that can survive a filter shrinks in proportion to filter selectivity: a filter matching 10% of the corpus leaves roughly 4 candidates on average, and a 1% filter leaves well under one. This is the project's own arithmetic for the pre-iterative-scan behavior; iterative index scans (added in pgvector 0.8.0) continue searching the index to address it. Values are expected surviving rows, not measured recall.
Enforcement boundary: physical, logical, or application-level
Milvus's multi-tenancy documentation is a useful comparison because it publishes the trade-offs in one table. Database-level and collection-level isolation are described as physical, with strong search performance and no cross-tenant search support; partition-level is physical, supports cross-tenant search, and does not support RBAC; partition-key level is physical plus logical, scales to millions of tenants, supports cross-tenant search, and also does not support RBAC.
That RBAC row is the concrete example worth internalizing. If the platform does not support role-based access control at the level where your tenant boundary lives, then the boundary cannot be delegated to the platform's authorization system — you are enforcing it in application code or in query construction. That changes what you must test and what you must monitor.
Pinecone's documentation recommends one namespace per tenant for isolation, noting that in its serverless architecture each namespace is stored separately, which the docs describe as physical isolation of each tenant's data. It also flags an anti-pattern: filtering by large lists of individual user IDs, recommending access control groups, namespaces, or client-side post-filtering instead.
When you compare platforms, ask for each candidate: at which level is the tenant boundary enforced, what does the platform do when a query omits the tenant predicate, and which administrative roles can read across the boundary? The first answer tells you the failure mode; the second and third tell you the blast radius.
Row-level security in PostgreSQL and where it stops being enough
If your vector store is pgvector inside PostgreSQL, row-level security (RLS) is the natural isolation mechanism — and it has specific mechanics that determine whether it actually holds.
First, policy combination. PostgreSQL combines multiple applicable policies using OR for permissive policies (the default) and AND for restrictive policies. A permissive policy added carelessly can widen access rather than narrow it; if you need a policy that must always apply, make it restrictive.
Second, the race-condition caveat. PostgreSQL's documentation states that policy expressions considering only the current row are the simplest and best-performing case, and recommends designing row security applications to work that way. When a policy must consult other rows or tables via sub-SELECTs or functions containing SELECTs, the documentation warns that such accesses can create race conditions that could allow information leakage if care is not taken. For multi-tenant vector search, the tempting design — a policy that looks up the tenant's status in a separate table — is exactly the pattern that carries this risk.
Third, and most likely to bite in production: connection pooling. The common way to set tenant context is a session-level variable via SET or set_config, and PostgreSQL documents that SET only affects the value used by the current session. PgBouncer's feature compatibility table lists SET/RESET as supported under session pooling and never supported under transaction pooling. Under transaction pooling, a server connection is assigned to a client only for the duration of a transaction and then returned to the pool — so a session variable set by one request can be absent, or worse, stale, for the next. An RLS policy that depends on a session variable under transaction pooling is decorative enforcement: it looks correct in code review and fails at runtime.
This is testable. Run a query through the pooler in the mode you intend to deploy, in a transaction that sets tenant context, and confirm the policy filters as expected. Then run concurrent requests from different tenants through the same pool and confirm no cross-tenant rows appear. If you cannot make session context survive your pooler mode, RLS is not your isolation boundary — the application is, and it needs a platform-level backstop.
Filtered ANN: what breaks and how to measure it
The failure mode is called overfiltering: an index scan returns too few results to satisfy the query because the filter eliminates most candidates. pgvector's 0.8.0 release, published 2024-11-11, added iterative index scans to address it. When an initial index scan does not satisfy the query conditions, pgvector continues searching the index until it reaches a configurable threshold (hnsw.max_scan_tuples and ivfflat.max_probes), enabled via hnsw.iterative_scan and ivfflat.iterative_scan. The same release changed how PostgreSQL estimates when to scan an ANN index, which can lead the planner to choose a B-tree or other index instead — and the release notes observe that achieving the same performance without an ANN index is usually preferable because it yields 100% recall.
The pgvector README adds two practical notes: results are limited by the size of the dynamic candidate list (hnsw.ef_search, default 40), and there may be even fewer results due to dead tuples or filtering conditions; and a good starting point is creating an index on the filter column, with partial indexing worth considering when filtering by only a few distinct values.
Qdrant's approach is documented as filtering during the search, with a query planner that estimates filter cardinality from payload indexes and either scores matching points directly when few match or walks the HNSW graph while skipping failing points. Its filterable HNSW index adds edges between points sharing an indexed payload value. ACORN, which steps through filtered-out neighbors at search time, is off by default and, once enabled, runs only when the estimated share of matching points is below max_selectivity, which defaults to 0.4. Qdrant also documents that every field you filter on in dense vector search should be indexed before ingest, and that adding an index to a collection that already has data requires rebuilding the HNSW index to get the filter edges.
Elastic's filtered kNN documentation makes the pre-filter versus post-filter distinction concrete at the query level: in the knn query form, a filter clause placed as a sibling of the knn query is applied after the vector search, while moving the filter inside the knn query pre-filters. It also notes that Lucene falls back to brute force per segment in certain cases to limit the performance impact.
How to measure, given all of this: compare approximate results against exact search on your own data, at your production tenant cardinality and your realistic filter selectivity. The pgvector README recommends exactly this — monitor recall by comparing results from approximate search with exact search. A single global benchmark, such as those in ANN-Benchmarks, is useful for comparing algorithm families under controlled conditions, but it does not tell you what your filtered, tenant-scoped query returns. Build a query set from real tenant traffic, record the exact nearest neighbors for each, and measure overlap at the parameters you intend to run.
Tenant identity propagation from CDC event to vector index
Tenant identity can be lost at five points, and each needs a control:
The source row must carry a tenant key. If tenancy is implied by schema or table name rather than stored in a column, the CDC event has no field to propagate.
The CDC event must preserve it. Debezium's PostgreSQL connector lets you restrict captured columns with
column.include.listandcolumn.exclude.list; a tenant column excluded from capture is gone before enrichment begins.Enrichment must not drop it. Embedding generation and any transformation step must carry the tenant field through to the upsert payload.
The upsert must write it to the isolation field — the namespace, partition key, or payload field your query path filters on.
The query must supply it from an authenticated context, not from a client-supplied parameter that a caller can change.
Idempotency is the other half. Debezium's PostgreSQL connector documentation states that changes are idempotent, so a sequence of events always results in the same state. That property is what makes replay safe — but only if your upsert is keyed correctly. Incremental snapshots add a specific reason to care: the connector's watermarking strategy exists to deduplicate events that might be captured by an incremental snapshot and then recaptured after streaming resumes, with insert_insert and insert_delete as the documented options. If your sink treats every event as a new document, a replayed or duplicated event produces a duplicate vector, and duplicate vectors distort both retrieval results and tenant-level counts.
Key your upserts on tenant plus document identity, and test a replay: stop the connector, restart it, and confirm the index contains the same number of documents per tenant as before.
Red Flags and Deal-Breakers
Red flags are signals to investigate or walk away. Must-haves are pass/fail gates. Keep them separate: a red flag can be explained by context, a must-have cannot.
Red flags
Isolation enforced only by an application-side filter with no platform-level backstop. If a missing predicate returns another tenant's data, the boundary is one code review away from failing.
Filters on unindexed fields. Qdrant Cloud enables strict mode by default and rejects filters on unindexed fields, which surfaces the misconfiguration as an error rather than a latency spike. Self-hosted deployments may not have that protection, so verify the setting rather than assuming it.
Recall claims measured only on unfiltered benchmarks. An unfiltered benchmark does not exercise the query shape your tenants issue.
Tenant deletion procedures that do not name backups and caches. If the runbook stops at the index, the tenant is still present somewhere.
CDC pipelines where the replication slot is unmonitored. Debezium's PostgreSQL connector documentation warns that with
lsn.flush.mode=manual, if you do not configure an external mechanism to flush the LSN, WAL files accumulate on the database server, potentially causing storage exhaustion and performance degradation. It also documents that heartbeat messages help the connector send the latest retrieved LSN so the database can reclaim WAL space, and thatheartbeat.action.queryaddresses the case where a low-traffic database on the same host as a high-traffic one prevents the connector from acknowledging WAL positions.A pooler configuration that has never been tested with tenant context. Covered above; it is the most common silent failure in PostgreSQL-based multi-tenant designs.
Must-have criteria
A documented isolation boundary the platform enforces, at a named level, with a stated behavior when the tenant predicate is absent.
A tested filtered-recall number at your tenant cardinality and filter selectivity, produced by your own harness against exact search.
An authenticated path for tenant identity that does not trust client input, verified end to end from query to filter.
A deletion procedure with a test, covering every surface listed in the assessment section, with evidence you can show an auditor.
An operational model that names an owner for connector upgrades, replication slot monitoring, offset management, and WAL growth — whether that owner is your team or a managed service, in writing.
How the Pipeline Pieces Fit: Kafka, CDC, and the Vector Store
The architecture under evaluation is a chain: source database → CDC connector → Kafka → enrichment and embedding → vector upsert. Each hop has an operational task attached, and the "without lots of ops" question is answered by counting which of those tasks you still own after adopting managed services.
What managed connectors remove and what they relocate
Confluent Cloud's PostgreSQL CDC Source V2 connector, which is Debezium-based, is a documented example. Its documentation states that it takes an initial snapshot of existing data before streaming changes, automatically creates Kafka topics using the naming convention <topic.prefix>.<schemaName>.<tableName> with default topic.creation.default.partitions=1 and topic.creation.default.replication.factor=3, and supports offset management. The same documentation advises least privilege for the Debezium replication user, and notes that offset storage topics live in your Kafka cluster — deleting or modifying that topic has consequences.
What that removes: host provisioning, connector patching, and the mechanics of running Kafka Connect workers. AWS's MSK Connect documentation describes the same class of benefit for its managed Connect service — eliminating the operational burden of patching, provisioning, and scaling Connect clusters, with automated patching and version upgrades.
What it relocates to you: topic sizing (the default of one partition per topic is a starting point, not a capacity plan), schema evolution handling, the replication-user privilege model, offset topic protection, and monitoring. The default partition count deserves specific attention: if your embedding and upsert stage needs parallelism per table, one partition per topic serializes it until you override the setting.
A useful rule from practitioner guidance on Kafka Connect: count the operational models you are willing to own. A shared Connect cluster amortizes operations across every pipeline; if you already run Kafka, keeping CDC inside that operational model avoids adding another.
The operational cost model, itemized
For each task, the honest question is whether a managed service absorbs it, relocates it, or leaves it untouched. The entries below describe typical patterns; confirm the specifics against each vendor's current documentation.
Task | Typical managed behavior | What you still own |
|---|---|---|
Connector lifecycle and upgrades | Absorbed: provisioning, patching, version upgrades | Compatibility testing against your schema and downstream consumers |
Replication slot and WAL monitoring | Relocated: the service runs the connector, but slot health is your signal | Alerts on slot lag and WAL growth; heartbeat configuration |
Offset storage and recovery | Relocated: offsets are stored, often in your Kafka cluster | Protecting the offset topic; choosing a mismatch strategy on restart |
Schema change handling | Untouched | Deciding what happens when a captured table changes shape |
Topic sizing and partitioning | Relocated: defaults are applied | Overriding partition count and retention for your throughput |
Embedding compute | Untouched unless you adopt a managed embedding service | Capacity planning, model versioning, re-embedding on model change |
Index rebuilds | Untouched | Rebuilding after mapping changes or adding filter indexes to populated collections |
Backup verification | Relocated at best | Restore tests, and confirming tenant states are included in backups |
Tenant deletion drills | Untouched | Executing and evidencing the procedure across every surface |
The pattern is consistent: managed services absorb infrastructure mechanics and relocate configuration, monitoring, and privilege decisions to you. Budget for the relocated items explicitly, because they are the ones that surprise teams in month three.
Where a lakehouse-style platform fits
Singdata documents a set of first-party capabilities relevant to the ingestion-and-compute side of this architecture: real-time sync tasks for MySQL, PostgreSQL, and Oracle full-database CDC; Pipe continuous ingestion that writes from object storage or Kafka; vector search; and AI functions including AI_EMBEDDING for generating embeddings in SQL. The platform is described as built on an incremental computing engine and positioned as a unified lakehouse covering integration, storage, and computation.
Those are vendor-reported product capabilities, and they should be validated against the criteria above like any other claim. Two scoping notes matter. First, a platform that handles CDC ingestion, embedding generation, and vector search in one system changes the operational cost model — fewer hops means fewer places for tenant identity to be dropped — but it does not by itself answer the isolation question. You still need to establish at which level the tenant boundary is enforced, what happens when the predicate is missing, and how deletion reaches every copy. Second, this is one option among several for the ingestion-and-compute side; it is not presented here as a replacement for a dedicated vector database, and adopting it does not resolve isolation for a vector store you run elsewhere.
The practical way to evaluate it: run the same filtered-recall harness and the same cross-tenant query tests you would run against any candidate, and confirm the tenant key survives from the CDC source through AI_EMBEDDING to the vector index.
Using the Criteria to Decide
The assessment answers point to different architectures. Work through the branches in order; the first one that matches your constraints is your starting point, not your final answer.
If tenant count is small and isolation obligations are strict, physical isolation per tenant — a database, collection, or namespace per tenant — is the simplest model to reason about. The boundary is structural, deletion is a drop operation on a known object, and cross-tenant queries are impossible by construction rather than by policy. Verify the platform's documented ceiling against your growth plan before committing, because migrating from per-tenant databases to a shared collection later is a re-architecture, not a configuration change.
If tenant count is large, a shared collection with a platform-enforced tenant field plus tested filtered recall is the realistic path. The work shifts to three things: proving the platform rejects or safely handles queries that omit the tenant predicate, measuring recall at your actual selectivity, and building the deletion procedure that reaches every copy. If the platform offers a tenant-aware index type or a strict mode that rejects unindexed filters, enable it — those settings convert silent failures into visible errors.
If operational appetite is minimal, prefer managed connectors and a managed vector service, and budget for the monitoring you still own. The itemized cost model above is the budget: slot lag alerts, offset topic protection, schema change review, and deletion drills do not disappear when you adopt managed services. They become the smaller, sharper list of things your team is accountable for.
If you are already on PostgreSQL and pgvector, RLS is a viable boundary only if you can prove tenant context survives your pooler mode and your policies do not depend on cross-table subqueries in ways that create race conditions. If either test fails, treat the application as the enforcement point and add a platform-level backstop rather than relying on the policy alone.
In every branch, the decision is reversible only at cost. Run the acceptance checklist against two candidate stacks before committing, and keep the harness — you will need it again after the first major version upgrade.
Acceptance Checklist Before Go-Live
Each item below is a test with a pass condition, not a configuration checkbox. Run them in an environment that resembles production in tenant count and data volume.
Cross-tenant query test. Issue queries as tenant A that attempt to retrieve tenant B's documents, including queries with the tenant predicate removed or altered. OWASP's RAG Security Cheat Sheet recommends auditing chunk isolation regularly by running cross-tenant test queries and verifying zero cross-boundary results. Pass condition: zero cross-boundary results, and a defined error or empty result when the predicate is absent.
Filtered-recall measurement. Compare approximate results against exact search at production tenant cardinality and realistic filter selectivity, using a query set drawn from real traffic. Pass condition: a recall figure you have agreed to, recorded with the parameters and index settings that produced it.
Tenant deletion drill. Execute the full procedure against a test tenant: primary index, replicas, backups, caches, derived embeddings, and intermediate CDC storage. Pass condition: no residual data on any surface, with evidence recorded.
Connection-pooling test. Confirm tenant context survives the pooler mode in use, including under concurrent requests from different tenants. Pass condition: no cross-tenant rows and no stale context across pooled connections.
CDC replay test. Stop and restart the connector, and replay a window of events. Pass condition: idempotent upserts keyed on tenant plus document identity produce the same document count and the same retrieval results.
WAL and slot monitoring alert. Configure alerts on replication slot lag and WAL growth, and verify they fire. Pass condition: a deliberately stalled connector produces an alert before disk pressure becomes an incident.
Backup inclusion check. Confirm that every tenant state in use is included in backups, and that a restore returns the tenant's data. Pass condition: a restored environment contains the test tenant's documents.
Authenticated tenant identity path. Trace the tenant identifier from the authenticated session to the query filter, and confirm no client-supplied parameter can override it. Pass condition: a forged tenant parameter in the request has no effect on the filter applied.
FAQ
Does row-level security alone secure a multi-tenant vector store?
Not by itself. RLS is a real enforcement mechanism, but it depends on tenant context being set correctly on the connection that executes the query. PostgreSQL documents that SET affects only the current session, and PgBouncer's compatibility table lists SET/RESET as never supported under transaction pooling. If your pooler runs in that mode, a session-variable-based policy may not apply as intended. RLS also carries documented race-condition risk when policies consult other tables via subqueries. Treat RLS as one layer, test it through your actual pooler configuration, and add a platform-level backstop if the test fails.
Is post-filtering ever acceptable?
Elastic's documentation states that post-filtering is a reasonable choice when the filter matches most of your documents and you would rather not pay the cost of filtered graph traversal, and that when the filter is selective, you should pre-filter. For multi-tenant search, tenant filters are usually highly selective, which puts them on the pre-filter side of that line. OWASP's RAG guidance goes further for security-sensitive retrieval, noting that pre-retrieval filtering is more secure because it prevents the similarity scores of restricted documents from being observed.
How do I measure recall for filtered search?
Build a query set from real tenant traffic, compute exact nearest neighbors for each query within the tenant's data, then run the same queries through your approximate index with the tenant filter applied and measure the overlap. pgvector's README recommends monitoring recall by comparing approximate search results with exact search. Record the index parameters, filter selectivity, and tenant cardinality alongside the number, because recall measured at one selectivity does not transfer to another.
Does a managed CDC service remove the need to monitor replication slots?
No. Managed services remove host provisioning and connector patching, but the replication slot still exists on your source database and still retains WAL until the connector acknowledges it. Debezium's documentation warns that without an external LSN-flushing mechanism in manual mode, WAL files accumulate and can cause storage exhaustion. Confluent's connector documentation describes heartbeat settings that help prevent unbounded WAL growth in common cases. Keep the alert regardless of who runs the connector.
What should a tenant deletion test include?
Every surface the tenant's data touches: primary index, replicas, backups, caches, derived embeddings, and intermediate CDC storage. The test should also confirm that tenant states which are excluded from backups by design — Weaviate documents that offloaded tenants are not included in a backup unless activated — are handled explicitly in the procedure rather than assumed to be covered. Record the evidence; an untested procedure is not a control.
Conclusion
The two decisions are coupled. Where you enforce tenant isolation determines what you must test, and how tenant identity travels through the CDC pipeline determines whether the isolation boundary ever sees the right value. A platform with strong structural isolation and a pipeline that drops the tenant key is not isolated; a pipeline that preserves identity perfectly and queries a store with decorative enforcement is not isolated either.
The single principle that ties the guide together: isolation and recall are properties you test at your own tenant cardinality and filter selectivity, not properties you adopt from a datasheet. Vendor documentation tells you what mechanisms exist and what limits apply — 64 databases by default, max_selectivity of 0.4, hnsw.ef_search of 40, SET/RESET unsupported under transaction pooling. Those are the inputs to your test plan, not the conclusion.
The next action is concrete: pick two candidate stacks, run the acceptance checklist against both in an environment that resembles production, and compare the results before committing. Keep the harness afterward. The first major version upgrade, model change, or tenant-count milestone will require you to run it again.