Skip to content

LearnOperate

Pages per $1

Pages per dollar

An ingestion cost measure: how many pages one dollar processes, computed as pages processed divided by the dollars spent processing them.

In DocSlurpIllustrated explainer

On this page
What one dollar buys on two workersIllustrative rates. Worker A costs $0.40 an hour and processes 20 pages per minute, so 100 pages take 5.0 minutes and $1 buys 3,000 pages. Worker B costs $1.20 an hour and processes 90 pages per minute, so 100 pages take 1.1 minutes and $1 buys 4,500 pages. The pricier worker processes 1.5 times as many pages per dollar.WORKER (illustrative rates)WHAT $1 BUYS · each icon = 250 pagesWorker A · small$0.40 / hour20/min100 pages in 5.0 min3,000pages per $120 × 60 / 0.40 = 3,000Worker B · large$1.20 / hour90/min100 pages in 1.1 min4,500pages per $190 × 60 / 1.20 = 4,500Worker B buys 1.50× the pages per $1 of Worker A, at 3× the hourly price.
You pay for time, so the faster, pricier worker buys more pages. Worker B costs 3× as much per hour but runs 4.5× faster, so $1 buys 4,500 pages instead of 3,000. Add a per-page model cost that both workers pay and the gap shrinks: the dashed outlines show what compute alone would buy. Rates are illustrative.

The problem: the cheap worker that costs more

You need to ingest a backlog of scanned contracts and have two worker types to choose from. One rents for $0.40 an hour, the other for $1.20. The obvious pick is the cheaper one: it costs a third as much.

That comparison is missing half the picture. Compute is billed by time, not by page. A worker that costs more per hour but finishes the batch much sooner can spend fewer dollars in total. The only fair way to compare is to fix the output, pages, and ask what each one costs to produce.

Two formulas

Pages per $1 measures cost efficiency:

pages per $1 = pages_processed / cost_dollars

Pages per minute measures speed:

pages per minute = pages_processed / runtime_minutes

For a worker billed by the hour that does nothing but ingest, the two connect directly:

pages per $1 = pages per minute × 60 / hourly_cost

A third number turns speed into something people can picture:

time to ingest 100 pages = 100 / pages per minute   (minutes)

Higher is better for pages per $1 and pages per minute, lower is better for time to ingest 100 pages. Avoid quoting dollars per page: the numbers get tiny (0.0003), people misread the zeros, and they don’t compare well at a glance.

A worked comparison

The rates below are illustrative, not anyone’s real prices or measured speeds.

Worker A (small) Worker B (large)
Hourly cost $0.40 $1.20
Pages per minute 20 90
Time to ingest 100 pages 100 / 20 = 5.0 min 100 / 90 = 1.1 min
Pages per hour 1,200 5,400
Pages per $1 1,200 / 0.40 = 3,000 5,400 / 1.20 = 4,500

Check it with a 1,000-page batch. Worker A takes 50 minutes, which is 50/60 of $0.40, about $0.33. Worker B takes 1,000 / 90 = 11.1 minutes, which is 11.1/60 of $1.20, about $0.22. B is three times the price per hour and still a third cheaper for the batch, because it is 4.5 times faster. It also finishes 39 minutes sooner.

The figure shows the same comparison as “what $1 buys”. Each page icon stands for 250 pages.

Model calls change the answer

Real ingestion rarely costs only compute. OCR models, vision-language models, embeddings and summaries are billed per token, and their cost per page doesn’t care which worker sent the request.

Costs that both scale with pages add as dollars, so pages per $1 combines like resistors in parallel:

1 / total = 1 / compute + 1 / model calls

Say model calls on their own run at 1,000 pages per $1. Worker A becomes 1 / (1/3,000 + 1/1,000) = 750 pages per $1. Worker B becomes 1 / (1/4,500 + 1/1,000) = 818 pages per $1. B still wins, but the 50% gap has shrunk to 9%. Push model cost to 250 pages per $1 and the two land at 231 and 237: once a model call dominates, the worker choice barely matters, and the money is in routing pages so only the hard ones reach the model. Use the buttons in the figure to watch the gap close.

What to state alongside the number

A pages per $1 figure without context can’t be compared with anything. Report it with:

  • Worker class and region. vCPU, memory, GPU, and the hourly rate you assumed.
  • Concurrency. How many documents ran at once. A worker processing four documents in parallel has four times the pages per minute of the same worker running one.
  • What the cost includes. Compute only, or compute plus model calls, storage and network. Say which, every time.
  • Scope. One stage, one document, one run, or a whole project. Parser-only speed is not pipeline speed.
  • Measured or estimated. Label numbers derived from historical averages as estimates.

Where it breaks

  • Idle time is paid time. The formula assumes the worker is busy. A worker that sits idle half the hour has half the effective pages per $1. In the example, Worker A at 50% utilization drops from 3,000 to 1,500.
  • Pages aren’t equal. A text-layer PDF page and a dense handwritten scan differ by orders of magnitude in effort. Compare configurations on the same corpus, not on whatever each happened to process.
  • Faster isn’t always cheaper. The large worker wins here because it is 4.5 times faster for 3 times the price. If it were only 2 times faster, it would lose: 2,400 pages per hour / $1.20 = 2,000 pages per $1.
  • Cold starts. Short batches on freshly started machines pay for boot and model loading. Separate warm from cold runs.

When to use it

Use pages per $1 whenever you choose a worker size, a parser, an OCR model or a page-routing policy. Pair it with pages per minute: one says what a page costs, the other says how long people wait.

In DocSlurp

In DocSlurp

The worker records pages-per-dollar, pages-per-minute and time-to-ingest-100-pages with the worker class, region, vCPU and memory attached (core/worker/src/pipeline/local-compute-cost.ts). Project telemetry reports pages per $1 from recorded ingest spend plus an estimated, flagged worker-compute share (core/server/src/services/project-board-telemetry.ts).

Sources

Jump to