Newsroom

Consistent data for consistent decision making

Read more

How BigHat Biosciences built a configurable data query engine to scale antibody therapeutic development

“What’s the KD of our lead antibody for Program X?”

A seemingly simple question. But the answer hinges on a handful of implicit choices: which antigen species: mouse or human? Which model did we fit to the raw curve? Do we consider the single result or prior results as well that had better or worse fits? Each choice is defensible on its own. Together, they can swing the answer by 10x, which is cause for alarm. Reproducing one analysis is a problem most scientific organizations know how to solve. Document the choices, freeze the inputs, save the code. The hard problem is reproducing analyses at scale: making every number on every dashboard, in every model, and in every figure continuously reproducible. 

At BigHat Biosciences, every therapeutic program involves iterative antibody optimization through weekly design-build-test cycles. Across our portfolio, we are actively working on several therapeutic programs, each containing multiple antibodies being optimized for up to 20+ antibody properties (metrics) each week. Across the platform, we routinely express and characterize more than 3,000 antibodies every week, amassing tens of thousands of new metric values every week. Our data must be consistently collected and analyzed in a way that is visible, inspectable, and trackable to enable this throughput without an army of experts managing every step of the process.

To enable and scale our analyses, we built a data query engine that is structured enough for reproducible analysis, flexible enough to follow the whims of scientific exploration, and fast enough that scientists can iterate on their own analyses without having to constantly partner with a data engineer. This post is about how we got there and the unit of abstraction that made it possible: the "metric recipe".

V1: Metrics Baked Into the Data Pipeline

When we first created BigHat's data analytics system, the simplest approach was to make our antibody metrics a direct output of our data pipelines. The pipeline did everything (filtering, grouping, QC screening, summarization) and emitted one number per antibody property (e.g. "The KD of Antibody Y to Target Z is 10 nM"). It was reproducible. It was also rigid. That rigidity broke down when faced with the realities of biological research.

We originally wanted one data pipeline to serve every program, but programs quickly hit irreconcilable differences in how they wanted their data treated. Consider sample monomer fraction as assessed by size-exclusion chromatography (SEC), a core protein-quality metric: Program A is in early discovery and accepts purities as low as 85% because we’re only screening for binding versus non-binding to a given target, while Program B is preparing to nominate a development candidate and demands ≥98%. Both requirements are valid and tied to scientific context, not to a global QC threshold the pipeline can pick on their behalf. Additionally, changes to data pipeline logic required a scientist working with a data engineer to get their results. Simply: scientists couldn’t independently explore their own data.

To solve this, we needed a data query engine that utilized our metric recipes.

‍

Figure 1 | How the data query engine decouples analyses across programs. In V1, every program shared the same end-to-end pipeline. This meant that changing it for one program affected all the others. In V2, the shared pipeline has fewer responsibilities. Instead, per-program logic lives in configurable metric recipes. These are processed by our data query engine to produce metric values for individual antibody properties. This approach allows each program to own its own analytical choices.

V2: The Metric Recipe

Figure 2 | A metric recipe. A metric recipe provides a fully-configurable definition for experimental data analysis at BigHat.

Informed by these challenges, we designed the second generation of our data analytics system with a new core concept: the metric recipe. The metric recipe is a single user-defined configuration that captures every choice that goes into producing a number for a given antibody property. It is the atomic unit of analysis at BigHat. One metric recipe is sufficient to fully answer “What’s the KD of our lead antibody Y for Program X and Target Z?” This includes which conditions to filter on, which experts are allowed to override programmatic quality filters, and how to summarize the data (Figure 2). We show how a metric recipe query operationally runs in Figure 3.

Figure 3 | The metric recipe query. The full set of operations defined in a single metric recipe.

The Impact: One Number, Many Viewers

The modular design of the metric recipe enables BigHatters to integrate knowledge from across the company. Each employee contributes their expertise to a single source of truth without needing to understand the others’ choices: data scientists set the automated QC thresholds and the model fit type parameters; program leads specify the scientific conditions that matter for their program; scientific or technical experiment experts annotate samples and have their judgment expressed in the QC stage and incorporated into model learning and collaborate with data scientists to define QC thresholds for new experiment types.

And because the same metric recipe is the source of truth for every downstream consumer, the entire organization reads from one number. Lab technicians sanity-check their results against it. Data scientists use it as the basis for their analyses. Platform operations monitor QC pass rates against it for platform stability. ML engineers train sequence-function models on it. LLM agents query it through MCP to answer ad hoc scientific questions in natural language. Program leads track program progress through it. And we even use the same numbers to present optimization progress to external partners (Figure 4).

‍

Figure 4 | One metric recipe, many views. A metric recipe provides the single source of truth for all places in which we view and make decisions on our antibody property data.

This is why metric recipes are the right unit of abstraction: each one is a small, self-contained answer to a single scientific question, and we operate them at scale. Each program tracks 20+ metrics related to various important features of a molecule: developability (SEC, thermostability), production yield (concentration, purity), functional assays (internalization, T-cell-dependent cellular cytotoxicity), and liabilities (humanness, isoelectric point). The tens of thousands of metric values we produce per week are all aligned, all instantly updated, and all visible to everyone (Figure 5).

‍

Figure 5 | The metric recipe is the atomic unit of analysis that we scale. The full value of the metric recipe is realized once it is scaled to the program and portfolio level. We currently have over 600 active metric recipes across our portfolio.

So now when someone asks 'What's the KD of our lead antibody Y to target Z in Program X?', the answer is already there. It's computed the moment the data lands. Every analytical choice is on record. And the number is identical on every dashboard, in every model, and in every partner deck. Decisions get made in the meeting they came up in rather than having to wait. A program lead, an ML engineer, and an external partner can discuss a molecule knowing they're looking at the same number. And when a program advances or discards a candidate, the basis for that call is reproducible months later. 

Our approach delivers consistent data for consistent decision making, ultimately powering BigHat's creation of transformative medicines for patients.