1h 45m read

How to Search Database Tables and Documents Together Without Copying Everything

A practical guide to searching tables and documents across systems without bulk copying: zero-copy access, metadata and derived-index copies, federated query limits, open table format portability, storage-compute separation, compute contract risk, and residency constraints, with an acceptance checklist to test before you sign.

How to Search Database Tables and Documents Together Without Copying Everything

A user types a question, and the answer depends on a contract clause in a PDF, a renewal date in a billing table, and a support note in a ticketing system. The obvious move is to copy all three into one search product. The problem is that the copy immediately begins to age, and the team that owns the source systems has just acquired a second estate to govern.

This article treats "without copying everything" as a design problem with a small set of honest answers rather than a product category. Almost every architecture that spans tables and documents copies something. The useful question is what gets copied, how much, how stale it is allowed to become, and whether a deletion at the source ever reaches the copy.

The patterns below are tested against five constraints that decide whether a search layer survives contact with procurement, security review, and the second year of operation: workload portability, data center siting, open table format, compute contract risk, and storage-compute separation. The article closes with a selection framework and an acceptance checklist you can run in a proof of concept.

What "Without Copying Everything" Actually Means

The phrase "no copy" is usually a claim about the data plane. The bytes of the source records stay where they are, and the search layer reaches them at query time. It is almost never a claim about the control plane: schemas, statistics, credentials, query plans, and result caches all get duplicated somewhere, because that duplication is what makes a query fast enough to be useful.

Sorting architectures by what they copy gives three patterns that behave very differently under the five constraints.

Zero-copy access: the query goes to the data

In the strictest pattern, the search or query engine reads the source system in place at query time and keeps no persistent secondary store. Nothing is materialized between queries except transient results.

For this to work, the engine needs three capabilities against each source. It must be able to push predicates down so the source evaluates filters rather than returning whole tables. It must be able to read the source's native representation, whether that is a relational table, an object-store file, or a document API. And it must be able to authenticate as the querying user or a delegated identity, which is often the hardest of the three to arrange across heterogeneous systems.

The boundary sits at the source's own interface. If the source cannot evaluate a filter, the engine has no choice but to pull more data than the query needs. That boundary is a property of the connector and the source version, not of the search product's marketing page.

Metadata-only copy: catalogs, manifests, and statistics

The middle pattern copies pointers and descriptions rather than content. A catalog holds table names, schemas, file manifests, and column statistics; the data files stay in object storage.

Apache Iceberg is the clearest documented example. Its table metadata tracks snapshots, and each snapshot references manifests that list data files along with per-file statistics such as record counts, null counts, and lower and upper bounds for columns. The Iceberg documentation describes scan planning as fast enough that a distributed SQL engine is not needed to find the files for a query, and describes data files being pruned with partition and column-level statistics drawn from table metadata.

That is a copy of derived information, not of the corpus. It is small relative to the data, it is regenerated by the writer on each commit rather than by a separate pipeline, and it is what allows a planner to skip most of a table without reading it.

Derived-index copy: the search index and the embedding store

For documents, most teams end up here. A search index or vector store holds chunks of text, embeddings, and metadata derived from source content. The source remains authoritative; the index is a projection optimized for retrieval.

The mechanics are well documented. Azure AI Search's guidance on semantic chunking shows a pipeline that splits a document by structure, generates embeddings per chunk, and projects parent-child relationships into an index so that a chunk can be traced back to its source document. That is a copy of derived data by design.

The real cost is not storage. It is synchronization. Every source update, schema change, permission change, and deletion has to reach the index within whatever window the application promises. When that pipeline lags, the index is not merely stale; it can return content the user is no longer entitled to see.

Why the distinction matters for freshness, cost, and deletion

The three patterns differ on three consequences that show up in operations rather than in architecture diagrams.

Freshness. Zero-copy access is as fresh as the source, minus query latency. Metadata copies are as fresh as the last table commit. Derived indexes are as fresh as the last indexing run, and that lag is a number you should be able to state.

Cost. Zero-copy moves data at query time, so you pay in latency and in whatever egress the source charges. Metadata copies are cheap to store and cheap to refresh. Derived indexes cost storage for chunks and embeddings plus compute for embedding generation, and object-store pricing can make that non-trivial: AWS's S3 pricing page notes, for example, that PUT requests are subject to a minimum charge of 128 KB per PUT and recommends batching multiple vectors per request to lower that cost.

Deletion. This is the one that gets designed last and should be designed first. A deletion at the source must propagate to every derived copy, including chunks, embeddings, and cached results. If your index cannot answer "was this document deleted at the source, and when did the index learn about it," you have a compliance problem rather than a freshness problem. Treat deletion propagation as a first-class requirement with a stated window, and test it the same way you test recall.

Federated Query and Data Virtualization: What Actually Moves

Federated query, or data virtualization, connects a query engine to multiple sources and presents them as one namespace. It genuinely reduces bulk copying. It does not eliminate data movement, and the movement happens in places you can name.

What pushdown actually pushes

Pushdown means the engine sends part of the query to the source for evaluation. Three kinds matter most for search across tables and documents.

Predicate pushdown sends filters to the source, so only matching rows travel back. Projection pushdown sends the column list, so only needed columns are read. Partition pushdown uses the source's partitioning to skip whole segments.

AWS's Well-Architected Analytics Lens, in best practice 15.6, describes the mechanism concretely: with columnar formats such as Parquet and ORC, a query engine can use metadata stored in the files to determine which sections to read, and when querying a federated source it can push down some, but not all, predicates. The same page recommends researching the specific engine to determine when pushdown applies.

That qualifier is the whole story. Pushdown is a capability of the connector and the source, not a guarantee of the architecture. A predicate the source cannot evaluate degrades silently into pulling more data than the query needs, and the query still returns the right answer, which is why the degradation goes unnoticed until the bill arrives.

Where federation still copies: result sets, joins, and staging

Three kinds of movement are unavoidable in a federated design.

Result sets. Whatever the source returns has to travel to the coordinating engine. Pushdown shrinks this; it does not remove it. A query that aggregates a billion rows at the source returns one row; a query that returns a billion rows moves a billion rows.

Cross-source joins. Joining a table in one system against documents in another is where federation's cost concentrates. The engine has to bring one side to the other, or shuffle both to an intermediate location. Trino's dynamic filtering documentation describes the optimization that reduces this by pushing runtime-derived filters to the probe side, but it is an optimization of the shuffle, not a replacement for it.

Staging and spill. Sorts, aggregations, and large joins spill to local or remote storage when they exceed memory. That spill is a temporary copy of real data, and in a residency-sensitive deployment it lands wherever the engine's spill directory is configured.

When federation is the wrong tool

Federation is the right answer when queries are ad hoc, selective, and infrequent against any given source. It is the wrong answer in three recurring cases.

Repeated heavy aggregation over the same remote data. If the same expensive rollup runs every morning against a remote source, you are paying the movement cost daily to produce the same answer. A materialized copy, refreshed on a schedule, is cheaper and more predictable.

Latency-sensitive interactive search. A user typing into a search box expects a response in well under a second. A federated query that fans out to three sources and joins the results will not reliably deliver that, and the tail latency will be dominated by the slowest source.

Cross-source joins at scale. When the join is the query rather than an incidental step, the shuffle dominates and federation becomes a slower way to do what a local copy does well.

In those cases the derived-index or metadata-copy patterns are the honest alternative. They accept a copy and pay for synchronization instead of paying for movement on every query.

Open Table Format: What Portability It Buys and What It Doesn't

An open table format is often presented as the answer to portability. It is a necessary part of the answer and a sufficient part of nothing.

Delta Lake features raise the minimum reader version a client must support Minimum reader protocol version (minReaderVersion) required by selected Delta Lake table features, from the Delta Lake versioning documentation. Basic functionality requires reader version 1; column mapping requires 2; deletion vectors, timestamp without timezone, row tracking, type widening and variant require 3. A client that does not implement the required reader version cannot read a table that enables the feature. Delta Lake features raise the minimum reader version a client must support. horizontal bar data: Basic functionality 1; Column mapping 2; Deletion vectors 3; Timestamp without timezone 3; Row tracking 3; Type widening 3; Variant type 3.Source: Delta Lake versioning documentation — feature and protocol version table . Delta Lake features raisethe minimum reader version aclient must support Basicfunctionality 1 Column mapping 2 Deletion vectors 3 Timestampwithout timezone 3 Row tracking 3 Type widening 3 Variant type 3 Source: Delta Lake versioning documentation —feature and protocol version table

Minimum reader protocol version required by selected Delta Lake table features, per the Delta Lake versioning documentation. A client that does not implement the listed reader version cannot read a table that enables the feature. Values are protocol version numbers, not performance measures.

What the open table format standardizes

The format standardizes the table's on-disk contract: how metadata files describe snapshots, how manifests list data files, how schemas evolve, how partitioning is declared, and how readers determine which files satisfy a query.

The Iceberg table spec is explicit that the format version increments when new features break forward compatibility, meaning older readers would not read newer table features correctly. The spec also states a design goal of storage separation, with partitioning treated as table configuration and reads planned from predicates on data values rather than partition values.

On the engine side, the Iceberg documentation lists Spark, Trino, PrestoDB, Flink, Hive, and Impala as engines that add tables using the format, and describes schema evolution, hidden partitioning, partition layout evolution, time travel, and version rollback as format-level capabilities. Delta Lake's documentation describes a comparable surface: ACID transactions, scalable metadata handling, time travel, and a connector ecosystem spanning Spark, Flink, Hive, Trino, Athena, and others.

That is a real and valuable standardization. It means a table written by one engine can be read by another without an export step.

What it does not standardize: catalogs, credentials, and engine features

The format does not standardize how a client discovers a table, how it obtains credentials to read the underlying files, or which engine features are available once it connects.

Catalog interoperability is a separate problem with its own specification. The Iceberg REST catalog spec describes a common API for interacting with any Iceberg catalog, motivated by exactly this gap: pluggable catalogs had to be implemented in multiple languages, and it proved difficult for commercial offerings to support many catalogs and clients. The spec also notes that the protocol supports secure table sharing using credential vending or remote signing.

Credential vending is where the abstraction meets reality. Databricks' documentation on accessing tables from Apache Iceberg clients states plainly that if credential vending is unsupported for your client, you must configure access from the client to the storage location containing the files and metadata. In other words, the format gave you a readable table and left you to arrange storage credentials yourself. The same page notes that clients reading tables on AWS need an explicit region configured, or scans fail at runtime.

Engine feature support varies too. Trino's Delta Lake connector publishes a table of Delta features marked as readers only, writers only, or both, which is a useful reminder that "can read the table" and "can do everything the writing engine can do" are different claims.

The forward-compatibility trap in Delta and Iceberg versioning

Both formats let a table declare requirements that a client must meet.

Delta Lake uses minReaderVersion and minWriterVersion. The Delta versioning documentation explains that features are always backwards compatible, so tables written by a lower Delta Lake version can be read and written by a higher one, but that enabling some features breaks forward compatibility with workloads running in a lower version, and those workloads must be updated. The same page lists the protocol versions each feature requires; column mapping, for example, requires minReaderVersion 2, and deletion vectors require minReaderVersion 3.

Microsoft's feature compatibility documentation adds the operational consequence: all protocol change operations conflict with concurrent writes, and streaming reads fail when they encounter a commit that changes table metadata, requiring the affected streams to be restarted.

Iceberg's versioning follows the same logic. The spec increments the format version when new features would break older readers, and notes that tables may continue to be written with an older version to preserve compatibility by not using unimplemented features. Trino's Iceberg connector documentation, for instance, records that format version 3 support is experimental and that certain procedures are unsupported on version 3 tables.

The practical consequence is blunt: "open format" does not mean "any engine, any version, tomorrow." It means any engine that implements the version and features your table actually uses. Before you standardize on a format, pin the version and the feature set, and test your second engine against a table that uses them.

Storage-Compute Separation: Portable Data, Not Portable Workload

Storage-compute separation is often described as though it made the workload portable. It makes the data addressable. Those are different achievements.

What separation decouples

Separation puts data durability and lifecycle in one layer and query processing in another. Storage is sized for the corpus and its retention; compute is sized for concurrency and query complexity. Each can scale without the other, and each has its own cost line.

This is the precondition for the multi-engine reads that open table formats promise. If the data files sit in object storage and the metadata describes them, any engine with credentials and a compatible reader can query them. The Iceberg spec treats storage separation as a design goal, and the format's reliance on immutable data files in cloud object stores is what makes concurrent readers practical.

What stays coupled: governance, performance, and operations

Three things do not become portable when the storage does.

Governance. Access control, row-level and column-level policies, masking, and audit logging live in a control plane that is usually specific to the engine or catalog. A second engine reading the same files does not inherit the first engine's policies unless the catalog mediates access for both. This is precisely why credential vending and catalog protocols matter: they are the mechanism by which governance travels with the data.

Performance. Query performance depends on the optimizer, the execution engine, and the statistics available. A workload tuned for one engine's join strategy and file layout will run on a second engine, but not necessarily well. The format guarantees correctness of the read, not the speed of the plan.

Operations. Scheduling, monitoring, alerting, cost attribution, and incident response are built around specific tooling. Moving a workload means rebuilding that tooling or accepting reduced visibility.

The honest summary is that separation makes the data portable and leaves the workload where it was. If your portability requirement is "we can read our tables from a second engine during a migration," separation plus an open format delivers it. If your requirement is "we can move our entire analytics operation to another vendor in a quarter," separation is one input among several, and the contract terms in the next section may matter more.

Compute Contract Risk: When the Discount Becomes the Lock-In

The constraint that most often defeats portability in practice is not technical. It is a discount agreement signed eighteen months earlier.

Commitment-based discounts are billing constructs. They reduce the price of eligible usage in exchange for a commitment to a spend rate or a resource quantity over a term. Their scope, not the data architecture, frequently determines how freely a team can move.

How commitment scope limits movement

The range of scopes is wide, and the difference between two products from the same provider can be larger than the difference between providers.

AWS documents two Savings Plan types on its Compute Savings Plans pricing page. Compute Savings Plans apply to EC2 usage regardless of instance family, size, AZ, Region, OS, or tenancy, and also apply to Fargate and Lambda usage. EC2 Instance Savings Plans offer a deeper discount in exchange for commitment to usage of individual instance families in a Region, with flexibility across AZ, size, OS, and tenancy within that family and Region.

Google Cloud's documentation draws a similar distinction. Its committed use discounts overview separates resource-based CUDs, which apply to a specific region and can be scoped to a single project or shared across projects linked to a Cloud Billing account depending on the CUD sharing configuration, from spend-based CUDs, which are purchased at the billing account level and apply to eligible usage in any project linked to that account, across all regions.

Microsoft's savings plan overview states the principle directly: savings plans are billing offers that do not affect the runtime state of your resources, and unused commitment for an hour expires and does not roll over.

The lesson is to read the scope, not the discount. A commitment scoped to a region constrains where you can run. A commitment scoped to an instance family constrains what you can run. A commitment scoped to a spend rate at the billing account level constrains less, but it still requires you to keep spending at that rate somewhere.

The egress and minimum-duration costs that survive migration

Even when compute is genuinely portable, several costs persist and should be modeled before signing.

Inter-region data transfer. Replicating a corpus to a second region incurs transfer charges. AWS's S3 pricing page states that for Cross-Region Replication you pay for inter-region data transfer out from S3 to each destination region, in addition to storage and request charges.

Minimum storage duration. Objects deleted or transitioned before a minimum duration incur a pro-rated charge. The same S3 pricing page states that objects deleted, overwritten, or transitioned to a different storage class before the minimum storage duration incur the normal storage charge plus a pro-rated charge for the remainder of the minimum duration. A migration that deletes a large corpus early can therefore generate a charge for data you no longer store.

Expiring commitment. Unused commitment expires rather than rolling over, per Microsoft's savings plan documentation. If you move a workload off a committed platform mid-term, the remaining commitment is a sunk cost, not a credit.

These three items are the true cost of moving. Model them at the corpus size and term length you are actually considering, and put the number next to the discount in the business case. A discount that saves a predictable percentage for three years and a migration that costs an unpredictable amount in year two are not comparable until both are on the same page.

Data Center Siting and Residency: Keeping Documents and Tables in Bounds

Residency is the constraint that can make a technically portable architecture legally non-portable. It attaches to data, and also to the systems and personnel that can access it, which means it constrains where search can run and who can operate it.

DOJ Data Security Program bulk thresholds by data category Number of U.S. persons (or U.S. devices for precise geolocation) at or above which a data category counts as bulk under 28 CFR § 202.205, measured at any point in the preceding 12 months. Human genomic data: more than 100 U.S. persons. Biometric identifiers, precise geolocation, and other human omic data: more than 1,000. Personal health data and personal financial data: more than 10,000. Covered personal identifiers: more than 100,000. DOJ Data Security Program bulk thresholds by data category. horizontal bar data: Human genomic data (U.S. persons) 100; Biometric identifiers (U.S. persons) 1000; Precise geolocation (U.S. devices) 1000; Other human omic data (U.S. persons) 1000; Personal health data (U.S. persons) 10000; Personal financial data (U.S. persons) 10000; Covered personal identifiers (U.S. persons) 100000.Source: 28 CFR § 202.205 — Bulk thresholds for sensitive personal data . DOJ Data Security Programbulk thresholds by datacategory Human genomicdata (U.S.persons) 100 Biometricidentifiers(U.S. persons) 1000 Precisegeolocation(U.S. devices) 1000 Other human omicdata (U.S.persons) 1000 Personal healthdata (U.S.persons) 10000 Personalfinancial data(U.S. persons) 10000 Covered personalidentifiers(U.S. persons) 100000 Source: 28 CFR § 202.205 — Bulk thresholds forsensitive personal data

Bulk thresholds in 28 CFR § 202.205, measured at any point in the preceding 12 months across single or aggregated covered data transactions. Each bar is the number of U.S. persons (or, for precise geolocation, U.S. devices) at or above which the data category is treated as bulk. The thresholds define scope for the DOJ Data Security Program; they are not a compliance determination for any particular dataset.

Residency requirements that bind the search layer

Two documented examples show the shape of the constraint.

IRS Publication 1075, which sets safeguarding requirements for federal tax information, states in its offshore operations section that FTI cannot be accessed by agency employees, agents, representatives, contractors, or subcontractors located outside the legal jurisdictional boundary of the United States, and that systems containing FTI must be located, operated, and maintained by personnel physically located within the United States. The publication explicitly notes that this prohibits foreign remote maintenance, foreign call centers, and help desks.

For a search layer, that is not only a storage-location rule. It reaches the personnel who operate the index, the support engineers who can reach the environment, and any managed service whose operations staff sit outside the boundary.

The U.S. Department of Justice's Data Security Program addresses a different risk with a different mechanism. It establishes what the Department describes as effectively export controls, prohibiting or restricting countries of concern and covered persons from engaging in certain categories of transactions that can give them access to U.S. Government-related data or Americans' bulk sensitive personal data. The final rule became effective April 8, 2025, with certain due diligence, audit, and reporting requirements effective October 5, 2025. Its bulk thresholds are defined in 28 CFR § 202.205, which sets category-specific numbers, such as personal health data maintained on more than 10,000 U.S. persons and personal financial data on more than 10,000 U.S. persons.

These examples illustrate the category. They are not a compliance determination for any particular reader, and the mapping from a specific dataset to a specific rule requires legal review.

Searching across regions without moving the sensitive side

The architectural response follows from where the constraint attaches. If the sensitive corpus and the personnel who can access it must stay in-region, then the index for that corpus stays in-region too, and the search layer queries across the boundary only for results that are permitted to cross it.

In practice that means three things.

First, partition the corpus by residency class before you design the index. A single global index that mixes restricted and unrestricted content will eventually return a restricted chunk to a user outside the boundary, and the fix will be a re-architecture rather than a configuration change.

Second, keep the retrieval step local and return only permitted fields across the boundary. A cross-region query that returns document identifiers and permitted metadata is a different risk from one that returns chunk text.

Third, verify where the derived copies land. Embeddings, chunks, query logs, and cached results are all copies, and each has a location. A managed vector service hosted outside the approved region is a residency problem regardless of where the source documents sit.

Cross-region search of restricted content is a policy question first and a technical one second. The technical work is to make the policy enforceable; the policy work is to decide what may cross, and that decision belongs to the data owner and legal counsel, not to the platform team.

Putting It Together: A Decision Framework

The five constraints reduce to a small number of decisions. Work through them in order, because an early answer can eliminate later options.

Step 1: Classify the corpus by residency and sensitivity. If any part of the corpus is subject to an access-location or personnel-location rule, that part is fixed in place. Everything downstream is designed around it. If nothing is restricted, skip to step 2.

Step 2: State the freshness requirement as a number. How long after a source update must search reflect it? Seconds, minutes, hours, or next business day. Zero-copy access gives you source freshness at query time. Metadata copies give you commit freshness. Derived indexes give you pipeline freshness. If the requirement is "seconds," a nightly indexing pipeline is disqualified before you evaluate any product.

Step 3: Decide whether the query is a lookup or a join. Selective lookups against one source favor zero-copy or federation. Queries that join tables to documents at scale favor a derived index or a materialized copy, because the join is the cost and federation only relocates it.

Step 4: Check the contract exposure. Read the scope of every active commitment: region, instance family, spend rate, term, and what happens to unused commitment. If the commitment is scoped in a way that pins the compute to one platform for the term, then portability is a post-term property, and the architecture should be designed for the term you are in rather than the one you hope for.

Step 5: Choose the copy pattern and write down the sync contract. Zero-copy for selective, freshness-critical lookups. Metadata copy for scan planning over large tables. Derived index for document retrieval and semantic search. Whichever you choose, specify the synchronization window, the deletion propagation window, and who is paged when either is breached.

The failure mode this framework is designed to prevent is choosing the pattern that demoed best. A demo shows retrieval quality on a curated corpus. It does not show you the storage growth after connecting a source, the lag on a deletion, or the exit cost of the commitment. Those are the properties that decide whether the system is still in production in year two.

What to Test Before You Sign

An acceptance test is a claim you can falsify in a proof of concept. Each item below should produce a measurement, not a vendor confirmation.

Non-duplication tests

Measure storage growth after connecting a source. Record storage consumption before connecting, connect the source, run a representative set of queries, and measure again. Growth proportional to the corpus means the data plane is being copied. Growth proportional to metadata and index size means it is not. State the ratio you are willing to accept.

Verify update propagation within a stated window. Change a record at the source, note the timestamp, and poll the search layer until the change appears. Repeat enough times to see the distribution, not just the best case. Compare the observed window to the window in the contract.

Verify deletion propagation. Delete a record at the source and confirm it disappears from search results, from any cached results, and from any embedding store. Then check whether a query can still retrieve the deleted content through a stale index shard or a cached response. This test finds more problems than any other on the list.

Verify permission propagation. Change a user's access at the source and confirm the search layer reflects it within the stated window. A search layer that returns content the user can no longer open is a governance failure even when the content itself is accurate.

Portability tests

Read the same table from a second engine. Not a sample table created for the demo, but a production-shaped table that uses the format version and features you actually depend on. Confirm the second engine reads it correctly, including the columns and types you rely on.

Confirm the catalog and credential path works for that engine. The format gives you a readable table; the catalog and credentials give you access. Test the full path, including region configuration and any credential vending limitations documented for your client.

Calculate the cost of exiting the commitment term early. Take the remaining term, the committed rate, and the unused commitment, and compute the sunk cost of moving. Add the inter-region transfer cost for the corpus and any minimum storage duration charges on data you would delete or transition. Put the total next to the projected savings.

Test the rollback. If the second engine cannot handle a table after a feature is enabled, you need to know before the feature is enabled in production. Enable a candidate feature on a test table, attempt the read from the second engine, and record the failure mode.

Frequently Asked Questions

Does an open table format alone make compute movable?

No. The format standardizes the table's on-disk contract, which is what allows a second engine to read the files. It does not standardize the catalog implementation, credential vending, or engine feature support, and both Delta Lake and Iceberg allow tables to declare minimum reader and writer requirements that older clients cannot meet. Portability requires the format, a catalog path that works for the second engine, credentials, and a compatible client version.

Does federation ever copy data?

Yes, in three places: result sets returned to the coordinating engine, data shuffled for cross-source joins, and spill to local or remote storage when operations exceed memory. Pushdown reduces the volume that travels but does not eliminate it, and a predicate the source cannot evaluate degrades into pulling more data than the query needs.

Does storage-compute separation make a workload portable?

It makes the data addressable by multiple engines. The workload, meaning queries, pipelines, permissions, and operational tooling, stays coupled to the engine and catalog that run it. Governance and performance characteristics in particular do not travel with the files unless the catalog mediates access for every engine.

How does residency interact with cross-region search?

Residency rules can attach to data location, to the systems that process it, and to the personnel who can access it. Where a rule prohibits offshore access, the sensitive corpus and its index stay in-region, and only permitted results cross the boundary. Which results are permitted is a policy decision for the data owner and legal counsel, and the architecture should make that decision enforceable rather than assumed.

Is a derived index a copy?

Yes. It is a copy of derived data: chunks, embeddings, and metadata generated from source content. That is acceptable when the synchronization and deletion windows are specified and tested, and it is a compliance exposure when they are not.

Further Reading

Related Articles