What It Costs to Screen a Compound Library With AI

There is no price list for screening a compound library. What there is is arithmetic: a per-compound time, a machine rate, and a library size. Everything below is derived from inputs named in the sentence that uses them, and the inputs are assumptions you should replace with your own.

The inputs, stated as assumptions

Four numbers determine the answer. Each is stated here as an assumption, not as a measurement, and each is the kind of thing that varies by an order of magnitude between projects.

• Library size: 10,000,000 compounds. A mid-sized make-on-demand subset. Vendor catalogues of on-demand chemical space now run to tens of billions of enumerated compounds, so this is a slice, not a whole.
• Docking time: 30 CPU-seconds per compound. A single receptor, a moderate box, default exhaustiveness, a ligand with a handful of rotatable bonds. Rigid small molecules run faster; flexible ones with a dozen rotatable bonds run several times slower.
• Compute rate: $0.02 per vCPU-hour. A preemptible or spot rate for commodity cores. On-demand pricing is commonly several times that, and an owned cluster has a different cost model entirely.
• Preparation: 0.5 CPU-seconds per compound. Protonation, tautomer selection, one 3D conformer, format conversion.
• Cheap ranking: 3 CPU-milliseconds per compound. Fingerprint generation plus a scored pass through a trained model.

The docking bill, derived

brute force: dock everything

  10,000,000 compounds x 30 CPU-seconds
    = 300,000,000 CPU-seconds
    = 300,000,000 / 3,600
    = 83,333 CPU-hours

  preparation
  10,000,000 x 0.5 s = 5,000,000 s = 1,389 CPU-hours

  total 84,722 CPU-hours x $0.02/CPU-hour
    = $1,694

wall-clock on 2,000 vCPUs:
  84,722 / 2,000 = 42 hours

Under these assumptions the compute for a ten-million-compound docking run is on the order of a couple of thousand dollars and under two days. That is the headline, and it is the least interesting part, because it is dominated by a per-compound time that you have not measured yet.

Note what is absent. Storage of poses is not free: keeping one pose per compound at roughly 2 KB is 20 GB, which is trivial, but keeping nine poses with full metadata for later rescoring is closer to 200 GB and starts to matter for egress. The receptor preparation, the box definition and the validation redock of a known ligand are human hours, not CPU hours, and they are the ones that decide whether the 84,722 CPU-hours were spent on a sensible target definition.

What the cheap stage costs, and saves

stage 1  sanitation and property filters, negligible CPU
         62% survive              -> 6,200,000 compounds

stage 2  cheap ML ranking over the survivors
         6,200,000 x 0.003 s = 18,600 CPU-seconds
                             = 5.2 CPU-hours
                             = $0.10

         keep the top 1%      -> 62,000 compounds

stage 3  dock only those
         62,000 x 30 s = 1,860,000 s = 517 CPU-hours
         plus preparation 62,000 x 0.5 s = 8.6 CPU-hours
         total 526 CPU-hours x $0.02 = $10.51

funnel total   ~ $11
brute force    ~ $1,694
ratio          ~ 160x cheaper

The cheap stage costs ten cents and removes 99% of the docking. That ratio — not the absolute figures — is the durable result, and it is why every large campaign is a funnel rather than an exhaustive dock.

The saving is not free. A cheap ranker that discards actives before the expensive stage sees them costs you hits invisibly, and you cannot detect it from the output. The standard defence is to dock a random sample of the discarded population — say 20,000 compounds from below the cutoff, adding about 170 CPU-hours and roughly $3.40 — and check that their score distribution really is worse than the retained set’s. That control costs a third of the funnel’s entire compute budget and is worth it.

The assumptions that move the answer

Vary each input and see which one matters.

baseline brute force  $1,694

docking time 5 s instead of 30 s      ->  $282     (0.17x)
docking time 300 s instead of 30 s    ->  $16,806  (9.9x)
on-demand rate $0.09 instead of $0.02 ->  $7,625   (4.5x)
library 1 billion instead of 10 M     ->  $169,400 (100x)
ensemble of 5 receptors               ->  $8,403   (5x)
9 poses retained, rescored with an
  ML function at 0.2 s per pose:
  10 M x 9 x 0.2 s = 5,000 CPU-hours  ->  +$100

Per-compound docking time is the dominant unknown and it spans two orders of magnitude. It scales with the number of rotatable bonds, with the search exhaustiveness setting, with the volume of the search box, and with how many poses you keep. A campaign that sets exhaustiveness high “to be safe” without measuring has multiplied its bill by a factor it never computed.

GPU-accelerated docking and ML rescoring change the shape rather than the story: a GPU hour costs perhaps twenty to fifty times a spot vCPU hour, so it pays only if the throughput ratio exceeds that. Derive it the same way — measure compounds per hour on both, divide by the respective hourly rates, compare cost per compound.

Two costs that do not appear in any of these lines are worth naming because they are the ones that surprise people. Spot capacity is reclaimed, so a job of this shape needs checkpointing and a work queue; without them a reclaimed fleet re-docks compounds it already finished and the effective rate is no longer the spot rate. And a run this size produces tens of millions of small output files unless you write to a columnar format, which turns a trivial storage bill into a listing problem that costs more in engineering time than the compute did.

Measure your own rate before you commit

1. Sample 1,000 compounds at random from your prepared library. Random, not the first thousand, which are usually sorted by something — supplier, catalogue number or molecular weight — and a sample sorted by molecular weight will mis-estimate the per-compound time in whichever direction the sort runs.
2. Run the full pipeline on them on one machine, with the settings you intend to use in production, and record total wall-clock and total CPU time separately.
3. Divide CPU-seconds by 1,000 for your real per-compound cost, and record the spread as well as the mean — the distribution is right-skewed, and a few very flexible ligands dominate the tail.
4. Multiply by library size and by your provider’s current rate for the instance type you sampled on. Add 20% for retries, failed preparations and the compounds that time out.
5. Add the control: the cost of docking a random sample from below your prefilter cutoff, which is the only way to know your funnel is not discarding actives.

The arithmetic is the thing worth keeping from this page. The numbers in it are inputs chosen to make it legible, and the moment you have measured your own per-compound time, every figure here should be replaced.

One last cost sits outside the compute entirely and dwarfs it. Under the assumptions above the whole ten-million-compound funnel costs about eleven dollars in CPU; the fifty compounds it produces have to be synthesised or purchased, shipped, and run through an assay, and that is the part with a real invoice attached. The consequence for how you spend the compute is direct: it is almost always worth spending more CPU — a receptor ensemble, a rescoring pass, the discarded-sample control — to improve the quality of a shortlist whose downstream cost is orders of magnitude larger. Optimising the cheap stage of a pipeline whose expensive stage is a laboratory is the wrong optimisation.