💻 computer science

PoolPy: Automated combinatorial pooling for high-throughput molecular profiling

The paper introduces PoolPy, a unified end-to-end framework and web platform that automates the design, benchmarking, and decoding of combinatorial group testing strategies to overcome implementation challenges and enable scalable, cost-effective high-throughput molecular profiling across diverse assay modalities.

Original authors: Lorenzo Talamanca, Julian Trouillon

Published 2026-08-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Lorenzo Talamanca, Julian Trouillon

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the vast world of biological research, scientists often face a simple but costly dilemma: how to check thousands of samples without spending a fortune or waiting years for results. Imagine a lab trying to find a single faulty component in a massive shipment, or a researcher looking for a specific genetic trait in a population of thousands. The traditional approach is to test every single item one by one. While accurate, this method becomes prohibitively expensive and slow as the number of samples grows. To solve this, researchers have long used a strategy called combinatorial group testing. Instead of testing items individually, they mix small amounts of many different samples together into a single "pool" and test that mixture. If the pool tests negative, every sample inside it is cleared at once. If it tests positive, the researchers know at least one sample in that group is the one they are looking for, and they can use logic to narrow down the search. This approach can drastically cut costs and time, but it has remained underused because designing the right way to mix the samples is incredibly complex. There are too many ways to combine the groups, and without the right tools, scientists often guess wrong, leading to missed results or wasted effort.

A team of researchers at ETH Zurich has now built a solution to this problem called PoolPy. This is a unified software platform and website that acts as a complete guide for scientists who want to use group testing. Rather than leaving researchers to guess how to mix their samples, PoolPy automatically designs the most efficient pooling strategy for any specific experiment. The software takes into account the number of samples, how many positive results are expected, and the physical limits of the lab equipment, such as how much a signal might weaken when diluted in a large mixture. It then generates a step-by-step plan, including files that can be read directly by robotic arms to mix the samples automatically. The researchers tested this system by simulating over 100,000 different screening scenarios. They found that no single design works best for every situation. Instead, the best approach depends entirely on the specific constraints of the experiment. For instance, if a scientist is looking for a very rare event in a large group, the software can design a plan that requires as few as nine tests to find a single positive sample out of 500. However, if the positive samples are more common, or if the chemical signal is weak and gets lost when mixed with too much liquid, the software suggests different mixing patterns to ensure the results remain clear.

To prove that these computer-generated plans work in the real world, the team applied PoolPy to two very different types of biological experiments. First, they tested a method for finding how proteins interact with drugs. They used a robot to mix 96 samples according to a PoolPy design and screened them for a specific interaction. They compared two different designs generated by the software: one that aimed to use the fewest tests possible, and another that aimed to keep the chemical signals strong. The results showed a clear trade-off. The design that used the fewest tests, which involved mixing large groups of samples, failed to detect the positive sample because the signal became too diluted to measure. The design that used slightly more tests but kept the groups smaller successfully identified the positive sample. This experiment demonstrated that simply trying to minimize the number of tests is not enough; the design must also fit the physical limitations of the assay.

In a second, more complex experiment, the researchers used PoolPy to study how ten different proteins, known as transcription factors, bind to DNA in bacteria. This is a high-complexity task where each protein can bind to thousands of locations in the genome. Traditionally, testing ten proteins would require ten separate, expensive experiments. Using PoolPy, the team mixed the ten proteins into just four pooled assays. The software decoded the results from these four tests to figure out exactly which protein was binding where. The results from the pooled tests were nearly identical to the results from running ten separate tests. This approach allowed them to screen ten proteins with the effort of only four experiments, representing a 2.5-fold increase in speed and a significant reduction in cost. The researchers confirmed that the software correctly identified known binding sites and the specific DNA patterns the proteins prefer.

The work establishes PoolPy as a flexible tool that can adapt to the unique needs of any experiment, from drug discovery to large-scale genetic profiling. By automating the complex math behind group testing and providing a way to compare different strategies, the software removes the barrier that has kept this powerful method from being widely adopted. The researchers emphasize that the key to success is not just finding a design that uses fewer tests, but finding the right balance between efficiency and the ability to detect the signal. PoolPy provides the guidance needed to make that choice, allowing scientists to scale up their experiments to explore vast search spaces that were previously too expensive to investigate. The tool is open-source and available online, offering a practical way for the scientific community to integrate these advanced pooling strategies into their daily work.

Technical Summary: PoolPy – Automated Combinatorial Pooling for High-Throughput Molecular Profiling

Problem Statement

Biomedical screening and molecular profiling experiments traditionally rely on measuring each sample individually. As experimental scales increase, this approach becomes prohibitively expensive and labor-intensive. Combinatorial group testing offers a solution by pooling samples into defined groups prior to testing, thereby increasing the information obtained per test and significantly reducing costs and turnaround time. However, the widespread adoption of this approach is hindered by three primary challenges:

Design Complexity: The mathematical design and decoding of pooling strategies are complex.
Varying Applicability: Multiple strategies exist with different performance profiles and ranges of application, making it difficult to select the optimal design for specific use cases.
Lack of Implementation Tools: There is a scarcity of accessible tools for designing, comparing, and decoding these strategies. Consequently, studies often re-implement basic methods without comparative evaluation, leading to suboptimal experimental designs and laborious additional steps.

Existing tools typically focus on standard single-readout assays and support only a limited number of methods (1–2), failing to address the needs of complex, multi-readout functional assays required for genome-scale profiling.

Methodology

The authors present PoolPy, a unified end-to-end framework and web platform designed to benchmark, automate, and decode combinatorial group testing strategies tailored to application-specific constraints.

Core Framework

PoolPy implements 10 conceptually different algorithms (detailed in Supplementary Notes 1–2), including standard methods and a novel design based on the theoretical limits of information theory. The system generates 8–13 distinct designs for each use case, allowing users to rationally select optimal designs based on logistical constraints such as:

Prevalence: The expected fraction of "positive" hits.
Cost and Time: Constraints on the number of tests and steps.
Signal Dilution: The reduction in signal strength caused by pooling large numbers of samples.

Algorithmic Implementations

The framework includes the following design strategies:

Matrix and N-dimensional Designs: Arranging samples in square or N-dimensional matrices to form row/column pools.
Binary Design: Rewriting sample indices in base 2; highly efficient for $D=1$ (one positive) but performance degrades as $D$ increases.
Random Design: Randomly assigning samples to pools, optimized by testing multiple configurations of pool size and number.
Shifted Transversal Design: A non-adaptive design using cyclic shifts to limit sample co-occurrence and maximize information content.
Chinese Remainder Designs: Based on the Chinese Remainder Theorem, including standard, backtrack (optimized for minimal pools), and special cases for $D=2$ and $D=3$ using base-3 and base-2 representations respectively.
Hierarchical Design: A strictly adaptive method that iteratively splits positive pools to zoom in on specific samples, optimized using partition problem logic (splitting into groups of 3).

Decoding and Automation

Multi-readout Decoding: Unlike existing tools, PoolPy supports multi-readout decoding, where each readout (e.g., a specific protein-DNA binding event) is treated as an individual signal and uniquely decoded.
Automation: The platform generates method files for robot-assisted liquid handling, enabling seamless transition from design to experimental execution.
Prevalence Estimation: The system provides tools to determine pooling hyperparameters based on estimated prevalence, balancing the trade-off between test reduction and error rates (specifically the risk of $D < \bar{d}$ , where the design cannot resolve the actual number of positives).

Key Results

In Silico Benchmarking

The authors benchmarked over 100,000 screening scenarios. Key findings include:

Efficiency at Low Prevalence: PoolPy designs can identify up to one positive sample in a set of 500 using as few as nine tests (0.018 tests per sample).
Trade-offs: Designs utilizing large groups (up to half the samples) minimize test numbers but suffer from signal dilution. Conversely, designs with smaller groups reduce dilution but require more tests and often additional validation steps.
No Universal Optimal Design: Performance varies significantly based on prevalence and the number of positives. Six different designs emerged as best-in-class for specific scenarios (minimizing test number vs. minimizing signal dilution) across sample sizes of 10–100 with up to 10% positives.
Error Rates: Lowering the threshold for maximum positives reduces test numbers but increases error rates in identifying positives, highlighting the necessity of accurate a priori prevalence estimation.

Experimental Validation 1: Protein-Ligand Interaction Screening

The framework was tested on a protein-ligand screen for human carbonic anhydrase II (hCAII) using a thermal shift assay.

Setup: 96 samples were screened, with one containing the ligand acetazolamide.
Comparison: Two designs were compared: one minimizing test number (7 tests) and one minimizing signal dilution (20 tests).
Outcome: The high-efficiency design (7 tests) failed to identify the positive sample due to signal dilution from large pools. The design minimizing signal dilution (20 tests) correctly identified the positive sample.
Conclusion: Tailoring designs to application-specific constraints (specifically signal dilution limits) is essential for robust screening.

Experimental Validation 2: Genome-wide Molecular Profiling

PoolPy was applied to profile genome-wide DNA interactions for ten E. coli transcription factors (TFs) using DAP-seq.

Setup: Ten TFs were profiled using four pooled assays (multi-readout batch mode) versus standard individual profiling.
Outcome: The four pooled assays successfully recovered most known binding sites, consensus DNA-binding motifs, and expected similarity levels compared to individual assays.
Throughput: This approach represented a 2.5-fold increase in throughput (reducing 10 assays to 4).
Conclusion: PoolPy enables the scaling of large-scale functional genomics while maintaining the high resolution of standard individual assays, provided signal dilution is managed.

Significance and Claims

The paper claims that PoolPy addresses the current need for a flexible, comparative framework to tailor combinatorial designs to specific experimental requirements. Its significance lies in:

Unified Ecosystem: It provides a complete end-to-end solution, from design generation and benchmarking to robot-assisted automation and decoding.
Multi-readout Capability: It uniquely enables combinatorial testing for genome-scale molecular profiling assays with complex, multi-readout outputs, a capability lacking in existing tools.
Rational Design Selection: By offering a comprehensive benchmark of 10 algorithms across 100,000+ scenarios, it allows researchers to move beyond ad-hoc re-implementations and select designs based on real-world constraints (cost, time, signal dilution, prevalence).
Scalability: It demonstrates the potential to scale up functional assays (e.g., drug discovery, CRISPR screening, transcriptomics) by significantly reducing costs and turnaround times, potentially enabling the exploration of search spaces previously deemed cost-prohibitive.

The authors emphasize that PoolPy is open-source, includes a user-friendly web interface, and is designed to integrate potential novel designs in the future.