Hybrid Product Search Without the Copy: Lexical, Semantic and Filtered Retrieval Served Directly from a Data Lake

Raghvendra Yadav, Xiang Fu, Chinmay SomanarXiv 2026 · arXiv

TL;DR

This paper demonstrates how to perform high-performance hybrid product search directly on "lakehouse" tables (Apache Iceberg/Parquet) without the need to copy data into separate search engines. By extending Apache Pinot with global BM25 statistics and SQL-based rank fusion, the authors achieve search relevance and sub-10ms latency comparable to traditional stacks while eliminating the operational nightmare of data synchronization pipelines.

What Problem Does This Paper Address?

In modern e-commerce, product catalogs are typically stored in a "data lakehouse" (like Apache Iceberg) for analytics. However, to power the actual search bar, companies usually copy that same data into two additional systems: a lexical engine (like Elasticsearch) for keyword search and a vector database for semantic search.

This "triple-copy" architecture creates significant friction:

  1. Operational Overhead: You have to manage three ingestion pipelines, three schemas, and three bills.
  2. Consistency Issues: Data in the search engine is often "stale" compared to the lake.
  3. Complexity: Every schema change or data backfill must be performed three times.

The authors ask a fundamental question: Can we build a search tier that indexes the lake's files directly, serving as a "single system of record" without sacrificing speed or relevance?

Methods

The authors built their solution on Apache Pinot, a real-time OLAP engine. Their "lake-native" architecture (shown in Figure 1) treats each Parquet file in the lake as a Pinot segment.

![Fig.

  1. Hybrid retrieval served from lakehouse files. Rows stay in the lake (blue); only indexes and caches live on the search tier (orange).](/figures/art_a2c86192db744ea4b35cb175d14de996)

Key technical innovations include:

  • Two-Phase BM25: BM25 scoring relies on global corpus statistics (like Inverse Document Frequency). In a distributed system, scoring against local file statistics leads to poor results. The authors implemented a two-phase protocol (TEXT_SCORE_STATS) that gathers global term statistics before scoring, ensuring results are comparable across the entire lake.
  • Zero-Copy Indexing: When a new file is registered in the lake, Pinot builds Lucene (text) and HNSW (vector) indexes on its own tier. It never "ingests" the rows; it only stores the indexes and uses range requests to fetch raw data from the lake when needed.
  • SQL-Based Fusion: Instead of a custom "hybrid" operator, they implemented Reciprocal Rank Fusion (RRF) using standard SQL. This allows lexical and semantic results to be combined and filtered in a single query.
  • Pruning: The system uses file-level metadata to skip irrelevant files. For a brand-specific search, the engine might only touch one file out of thousands.

Datasets

The authors evaluated their system using:

  1. Amazon ESCI (Shopping Queries Dataset): A benchmark of 1.2 million US products and ~22,000 test queries with human relevance judgments.
  2. Synthetic Scale-up: To test performance at scale, they replicated the ESCI catalog to 277 million products (0.8 TB), organized into over 2,000 files.

Key Insights and Ideas

  • Global Stats are Non-Negotiable: The paper shows that using per-file statistics for BM25 drops relevance significantly (nDCG@10 falls from .312 to .271). The two-phase "DFS-style" protocol is what makes lake-native search viable.
  • The "Aha" of Pruning: For product search, most queries are "selective" (filtered by brand, category, etc.). By sorting the lake files by these common filters, the engine can achieve incredible speeds because it only has to load a tiny fraction of the total indexes into memory.
  • Freshness is about Metadata, not Indexing: As shown in Figure 2, the actual time spent building indexes for a new commit is less than a third of the total "commit-to-searchable" time. The bottleneck is often the coordination of metadata and object storage persistence.

![Fig.

  1. Breakdown of the 3.8 s from a lake commit to searchable. Index building is under a third of it.](/figures/art_3c5beb5b51444dd999ac1034095ba459)

Key Results

  • Relevance: The lake-native approach matched the relevance of "exact" reference retrievers, achieving an nDCG@10 of 0.361 on the ESCI benchmark.
  • Latency: On the 277M product lake, a single 16-vCPU node answered brand-scoped hybrid searches in just 8.9 ms (p50).
  • Throughput: The system sustained over 1,100 vector searches per second on a single node.
  • Freshness: New data became searchable in just 3.8 seconds after a lake commit, rivaling the performance of dedicated search engines that require full data ingestion.
  • Efficiency: By avoiding the "row copy," the system reduced infrastructure costs by roughly 10% at low loads and significantly more when integrated into existing lake analytics clusters.

Limitations and Future Work

  • Non-Selective Queries: The design is optimized for queries that can be "pruned." A query that hits every single file in a massive lake would likely suffer from high latency compared to a fully ingested, force-merged index.
  • Index Size: While they avoided copying the raw data, the vector indexes (HNSW) are still large (~3.1 KB per product). For a 277M product catalog, the indexes alone take up 1.1 TB.
  • Scaling: The throughput tests were conducted on a single node; the authors note that multi-server scaling is a subject for future work.
  • Community Contribution: The authors plan to propose these new scoring and statistics functions to the Apache Pinot community.

Summary updated

Abstract

E-commerce catalogs increasingly live in lakehouse tables: Apache Iceberg metadata over Parquet files in object storage. Product search, however, still runs on copies of that catalog, in a lexical engine and a vector database, each with its own ingestion pipeline, schema, staleness window and bill. We show that search applications can be hosted directly on the data lake, with the lakehouse table as the single system of record. We extend Apache Pinot, a real-time OLAP engine that already serves Iceberg tables in place, with BM25 relevance scoring over its Lucene text index, corpus-wide term statistics so that scores are comparable across files, and reciprocal rank fusion in plain SQL; a real-time table fed by a stream can sit behind the same table, merged by the broker. On the Amazon ESCI benchmark (1.2M US products, 22,458 test queries), hybrid search served from the lake matches exact retrieval (nDCG@10 .361). The lake table is queryable 149 s after its files are registered, and a lake commit is searchable in 3.8 s, close to indexing directly into a search engine. On a brand-sorted lake of 277M products (0.8 TB), one 16-vCPU node answers brand-scoped vector, BM25 and client-fused hybrid searches in 6.5-9 ms (p50), sustains 1,100 vector and 635 BM25 searches per second at under 180 ms p99, and makes a commit searchable in 4.3 s. Search adds only its indexes: no copy of the catalog, no sync pipeline and no second schema, which cuts storage, rebuild time and the operational work of keeping copies consistent.
BibTeX
@misc{yadav2026hybrid,
  author = {Raghvendra Yadav and Xiang Fu and Chinmay Soman},
  title = {{Hybrid Product Search Without the Copy: Lexical, Semantic and Filtered Retrieval Served Directly from a Data Lake}},
  year = {2026},
  eprint = {2611.11031},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.11031},
}
Figure