DocxIntel home
DocxIntel, a product of BizfyLabs
DocxIntel, a product of BizfyLabs
by
BizfyLabs
  • Capabilities
    • Analyse

      Resolve layout, reading order, tables and handwriting

    • Identify

      Pull entities, fields and clauses with coordinates

    • Classify

      Sort document types and split multi-page packets

    • Map

      Link and reconcile entities across your estate

    • Modify

      Redact, mask and transform documents safely

    • Ask

      Query your documents and get cited answers

    • All six capabilities, one platform→
  • Deployment
  • Accuracy
  • Industries
    • Banking & Financial Services

      Statements, KYC files, and financial filings

    • Insurance

      Claims, policies, and underwriting documents

    • Government & Public Sector

      Records, correspondence, and regulatory filings

    • Healthcare

      Patient records, referrals, and lab reports

    • Legal & Compliance

      Contracts, filings, and case documentation

    • Energy & Utilities

      Engineering documents, contracts, and reports

    • Every regulated industry we serve→
  • Pricing
  • Docs
Book a Demo
Home
DocXIntel

Menu

    • All capabilities
    • Analyse
    • Identify
    • Classify
    • Map
    • Modify
    • Ask
    • All industries
    • Banking & Financial Services
    • Insurance
    • Government & Public Sector
    • Healthcare
    • Legal & Compliance
    • Energy & Utilities
    • Deployment models
    • Reference architectures
    • Sizing & throughput
    • What's in the box
    • Security posture
    • Documentation
    • Accuracy benchmark
    • Pricing
    • Proof of Value
    • Compare
    • About
    • FAQ
    • Contact Us
Sizing and throughput

How much hardware does your page volume actually need?

Capacity planning for an on-premise deployment: what drives throughput, what a GPU is worth in pages per hour, worked sizing from 50,000 to 5 million pages a month, and how to measure all of it on your own hardware before you commit to anything.

  • ~1,800 pages/hour per L40S GPU
  • Scales horizontally by adding workers
  • Interactive and bulk queues are separate
  • Reprocessing costs nothing extra
Size your deployment with an engineer
See the reference architectures
DocxIntel processing a continuous stream of documents through a GPU worker pool
1,800
Pages per hour, per GPU
mixed scanned business documents
1.9s
Median single-page latency
analyse and identify, p50
30 GB
Storage per 100,000 pages
steady state, excluding sources
Zero
Extra cost to reprocess an archive
no per-page fee, ever

Reference figures measured on an NVIDIA L40S 48 GB worker with 16 vCPU and 128 GB RAM, running analyse, identify and classify over a mixed set of scanned invoices, contracts and claim forms in Arabic and English. Your document mix will move these numbers in both directions.

What to model

Four things drive throughput, and only one of them is the GPU

Sizing conversations usually start with GPU model numbers. They should start with what is on the page, because that is the variable with the widest range.

Page complexity

A native PDF invoice and a fourth-generation fax of a handwritten Arabic claim form are not the same unit of work, even though both count as one page. Image quality recovery, dewarping and dense-script recognition are where the time goes.

  • Clean native PDF: roughly 0.9 seconds of GPU time per page
  • Standard 300 DPI scan: roughly 2.0 seconds per page
  • Phone photo or degraded fax: 3.5 to 4.5 seconds per page

Capability mix

Analyse is compulsory — everything else is built on it. Each additional capability you enable adds work, and question answering adds the most because it involves generative inference rather than recognition.

  • Analyse only: baseline
  • Analyse, identify and classify: about 1.4× baseline
  • Adding map, modify and Ask indexing: about 2.1× baseline

GPU class and memory

Memory decides how large a batch you can hold; compute decides how fast you clear it. The reference worker is an L40S 48 GB because it fits the full model set with room for a 32-page batch, but the platform is not fussy about silicon.

  • L4 24 GB: about 0.55× the reference worker
  • L40S 48 GB: the reference, 1.0×
  • H100 80 GB: about 2.3×, with headroom for larger batches

Batch versus interactive

The same cluster serves both, but they optimise for opposite things. Bulk work batches aggressively for throughput; interactive work runs small batches to keep tail latency down. Separating them is what stops one from ruining the other.

  • Bulk: batch size 32, throughput-optimised scheduling
  • Interactive: batch size 4, latency-optimised, higher priority
  • Reserved interactive headroom is configurable per environment
Worked examples

Sizing for 50,000 to 5 million pages a month

Four realistic volumes, sized for a mixed scanned document set running analyse, identify and classify, with enough headroom to clear a full monthly backlog inside a working week.

Sizing for 50,000 to 5 million pages a month
Criterion50K pages/month250K pages/month1M pages/month5M pages/month
GPU workers1× L40S 48 GBsingle node2× L40S 48 GBtwo nodes6× L40S 48 GBthree nodes24× L40S 48 GBeight to twelve nodes
Total vCPU16includes control plane48144576
Total RAM128 GB256 GB768 GB3 TB
Local NVMe2 TBrender cache and model weights6 TB16 TB60 TB
Object storage, year one4 TB16 TB60 TBresults, cache and audit trail300 TB
Sustained throughput~1,800 pages/hr~3,600 pages/hr~10,800 pages/hr~43,200 pages/hr
Time to clear one month~28 hours~69 hours~93 hoursunder four days of continuous run~116 hours
Matching topologyRA-01 single nodeRA-02 HA clusterRA-02 or RA-04RA-02 with DR
Licence impact of volumeNoneNoneNonesized by footprint, not pagesNone

GPU workers

50K pages/month
1× L40S 48 GBsingle node
250K pages/month
2× L40S 48 GBtwo nodes
1M pages/month
6× L40S 48 GBthree nodes
5M pages/month
24× L40S 48 GBeight to twelve nodes

Total vCPU

50K pages/month
16includes control plane
250K pages/month
48
1M pages/month
144
5M pages/month
576

Total RAM

50K pages/month
128 GB
250K pages/month
256 GB
1M pages/month
768 GB
5M pages/month
3 TB

Local NVMe

50K pages/month
2 TBrender cache and model weights
250K pages/month
6 TB
1M pages/month
16 TB
5M pages/month
60 TB

Object storage, year one

50K pages/month
4 TB
250K pages/month
16 TB
1M pages/month
60 TBresults, cache and audit trail
5M pages/month
300 TB

Sustained throughput

50K pages/month
~1,800 pages/hr
250K pages/month
~3,600 pages/hr
1M pages/month
~10,800 pages/hr
5M pages/month
~43,200 pages/hr

Time to clear one month

50K pages/month
~28 hours
250K pages/month
~69 hours
1M pages/month
~93 hoursunder four days of continuous run
5M pages/month
~116 hours

Matching topology

50K pages/month
RA-01 single node
250K pages/month
RA-02 HA cluster
1M pages/month
RA-02 or RA-04
5M pages/month
RA-02 with DR

Licence impact of volume

50K pages/month
None
250K pages/month
None
1M pages/month
Nonesized by footprint, not pages
5M pages/month
None

Sizing assumes a mixed scanned set at roughly 2.0 seconds of GPU time per page with the analyse, identify and classify capability set. Enabling Ask indexing across the same corpus adds about 50% to GPU time — plan an extra worker per five, or accept a longer bulk window. These are engineering starting points to be validated on your hardware.

See the matching topologies
Horizontal scaling

You scale by adding workers, not by upgrading a plan

Capacity is a property of your cluster, not of a contract tier. A GPU worker is a stateless pod that pulls page tasks off a shared queue, so adding one is a node label and a replica count — no re-architecture, no migration, no renegotiation.

  • Workers are stateless: they hold no job state, so they can be added, cordoned, drained or lost without affecting in-flight documents
  • Page-level parallelism: a 400-page packet is split across every available worker, so a single large document is not stuck behind one GPU
  • Queue-depth autoscaling: the horizontal pod autoscaler and cluster autoscaler both key off orchestrator queue depth rather than CPU, which is the only signal that correlates with real backlog
  • Failure handling: if a worker dies mid-batch, its page tasks are re-queued with an incremented attempt count and picked up elsewhere. Nothing is silently lost and nothing is processed twice
  • The usual first bottleneck is not the GPU: it is PDF rasterisation on the CPU tier or read throughput on your object store. Both show up clearly in the shipped Grafana dashboards

Because the licence is sized by deployment footprint rather than pages, adding a worker inside your licensed environment is a hardware decision your infrastructure team can make on its own.

A DocxIntel GPU worker pool scaling horizontally behind a shared orchestrator queue
Reference

Latency, queue behaviour and backpressure

What to promise your users, and what the platform does when you ask it for more than it has.

Interactive latency, reference worker

Single page, analyse and identify
p50 1.9 s, p95 4.2 s, measured from API submission to structured result
20-page scanned packet
p50 11 s, p95 26 s with page-level fan-out across the worker pool
Classification and auto-split
p50 0.6 s per page, running alongside analysis rather than after it
Ask query over an indexed corpus
p50 900 ms to first token, p95 6 s to a complete cited answer
Reviewer console page load
Under 400 ms for a queue view, including the annotated page render

Bulk and batch behaviour

Batch size
32 pages per GPU batch by default, tuned automatically to available GPU memory
Priority classes
Interactive and bulk are separate queues. Interactive always pre-empts bulk at the scheduler
Reserved headroom
A configurable share of the pool — 20% by default — is held for interactive work even during a backfill
Scheduled windows
Bulk jobs can be pinned to an overnight window, with automatic pause and resume at the boundary

Backpressure and overload

Queue high-water mark
5,000 queued page tasks by default, per environment, adjustable in Helm values
What happens at the mark
Bulk submissions receive HTTP 429 with Retry-After. Interactive submissions continue to be accepted
Retry policy
Three attempts with exponential backoff, then a dead-letter queue that is visible in the console
Durability
Job state is committed to PostgreSQL before acknowledgement, so a cluster restart resumes rather than restarts

Storage growth, per 100,000 pages

Structured results
About 9 GB — blocks, tables, tokens, coordinates and confidence scores
Page render cache
About 24 GB while warm, expiring on a 14-day TTL by default
Retrieval index
About 1.5 GB including index overhead, only for corpora you enable Ask on
Audit and trace records
About 1.5 GB, retained for as long as your own policy requires
Practical planning figure
About 30 GB steady state, 55 GB peak. Source documents stay where they already are

Latency figures are measured inside the cluster and exclude your own network round trip. All of them are emitted as Prometheus histograms, so you can hold us to the same numbers on your own dashboards.

Benchmarking

Measuring throughput on your own hardware

Every deployment ships a benchmark harness. During the Proof of Value we run it with you, on your documents, on the hardware you would actually buy.

  1. 1
    Step 1

    Assemble a representative sample

    Two to five thousand pages that look like your real workload, including the difficult tail — phone photos, handwritten Arabic, stamped contracts, multi-generation faxes and multi-document packets that need splitting. A clean sample produces a flattering number you cannot plan against.

  2. 2
    Step 2

    Run the single-worker baseline

    One GPU, one worker, the capability mix you intend to run in production. This produces pages per hour, GPU utilisation, p50 and p95 latency and a per-stage time breakdown showing exactly where the seconds go.

  3. 3
    Step 3

    Scale to four workers and check linearity

    Repeat with four workers. If throughput does not scale close to four times, the harness tells you which tier saturated first — rasterisation, object storage read bandwidth, or the database write path — before you commit to a hardware order.

  4. 4
    Step 4

    Run interactive and bulk together

    Drive a bulk backfill and an interactive load at the same time, which is what a real Monday morning looks like. Confirm that interactive p95 stays inside your service target while the backlog drains behind it.

  5. 5
    Step 5

    Measure accuracy alongside speed

    Throughput without accuracy is not capacity. The same run produces field-level accuracy against a human-adjudicated ground truth, so you can see the cost of a faster configuration before you choose it.

  6. 6
    Step 6

    Turn the measurements into a sizing document

    The harness output becomes a written sizing recommendation: GPU count, node shapes, storage classes and expected pages per hour at your volume. You keep that document whether or not you proceed.

The economics

Reprocessing your archive costs nothing, so you will actually do it

On a metered platform, every improvement to the models is an invoice you have to justify before you can benefit from it. That is why archives sit unprocessed at organisations that own perfectly good extraction tooling.

  • A fixed annual licence sized by deployment footprint means volume is a capacity question, not a budget question
  • Re-running two million archived pages against a newer model costs GPU hours you have already bought — at 10,800 pages per hour that is about eight days of background processing
  • For illustrative arithmetic only: at a published metered rate of $0.0125 per page, 1,000,000 pages a month is roughly $150,000 a year, and at $0.30 per page roughly $3.6M a year. These are list-rate calculations, not vendor quotations
  • Backfills run at bulk priority in an overnight window, so historical reprocessing does not compete with the work your users are waiting on
  • The practical effect is behavioural: teams on unmetered infrastructure reprocess after every model upgrade, and teams on metered infrastructure almost never do

Competitor figures reflect publicly documented list pricing for metered document-parsing platforms as of 2026. Verify against current vendor documentation before making a decision — we would rather you checked.

An on-premise DocxIntel cluster reprocessing an archived document corpus with no per-page charge

Capacity questions before a hardware order

What platform teams need to know before they size a cluster, answered with numbers.

On the reference worker — an NVIDIA L40S with 48 GB — plan on roughly 1,800 pages per hour for a mixed scanned business document set running analyse, identify and classify. Clean native PDFs run closer to 4,000 pages per hour, and a heavy mix with question answering over dense Arabic scans drops to around 900. The spread is real, which is why we benchmark on your documents rather than quoting a single number.

Close to it, up to the point where something else becomes the constraint. GPU inference is embarrassingly parallel at page granularity, so adding a worker adds throughput almost proportionally. In practice the first ceiling is usually PDF rendering on the CPU tier or read bandwidth on your object store, both of which are cheaper to fix than GPUs.

The orchestrator queues it and applies backpressure rather than dropping it. Interactive and bulk work run in separate priority classes, so a two-million-page backfill cannot starve a teller waiting on a customer document. Once queue depth crosses the configured high-water mark, bulk submissions receive HTTP 429 with a Retry-After header while interactive traffic continues.

Around 30 GB of DocxIntel-owned storage per 100,000 pages at steady state, rising to roughly 55 GB while the page render cache is warm. That excludes your source documents, which stay where they already live — the platform reads them in place rather than taking a second copy unless you configure it to.

Nothing. The licence is a fixed annual fee sized by deployment footprint, not by pages processed, so re-running two million archived pages against a newer model costs you the electricity and the wall-clock time and nothing else. On a metered per-page platform that same exercise is a second full invoice, which is why most organisations on those platforms simply never reprocess.

That is what the Proof of Value is for. We deploy into your environment, point the benchmark harness at your own document mix, and produce pages per hour, p50 and p95 latency, GPU utilisation and field-level accuracy on your hardware. The numbers on this page are starting points for a sizing conversation, not a substitute for measuring.

Keep reading

Reference architectures→The five topologies these sizing figures map onto, with ports, data flow and GPU placement.Deployment models→Air-gapped, private cloud, managed single-tenant and evaluation sandbox, compared in depth.What's in the box→The services that consume this capacity, and the open-weight models they load.Accuracy benchmark→The methodology behind the 99% field-level figure, and the document mix it was measured on.Pricing→Why a fixed annual licence sized by footprint changes how you plan capacity.Operations documentation→Tuning guides, autoscaling configuration and the metrics reference for your dashboards.

Bring your page volume. We will size the cluster.

A Proof of Value gives you measured pages per hour, p50 and p95 latency and field-level accuracy on your own hardware and your own documents, with the threshold agreed in writing before we begin.

Talk to an engineer
How the Proof of Value works
  • No per-page metering
  • Runs in your environment
  • Written accuracy threshold
DocxIntel Logo

A product of BizfyLabs

Document intelligence that never leaves your building. Analyse, identify, classify, map, modify and ask — inside your own infrastructure.

BizfyLabs on LinkedInDocxIntel documentationBizfyLabs

Product

  • Capabilities
    • Analyse
    • Identify
    • Classify
    • Map
    • Modify
    • Ask
  • Accuracy benchmark
  • Pricing
  • Proof of Value

Technical

  • Deployment models
  • Reference architectures
  • Sizing & throughput
  • What's in the box
  • Security posture
  • Model licences
  • Documentation
  • API reference

Solutions

  • All industries
  • Insurance & TPAs
  • Healthcare
  • Banking & finance
  • Government
  • Legal
  • Energy & logistics

Compare

  • Compare approaches
  • LlamaParse alternative
  • Docsumo alternative
  • On-premise document AI

Company

  • About DocxIntel
  • FAQ
  • Partners
  • BizfyLabs
  • Careers
  • Contact

© 2026 BizfyLabs FZC LLC. All rights reserved.

DocxIntel™ is a product of BizfyLabs FZC LLC.

  • Privacy Policy·
  • Terms of Service·
  • Data Processing Addendum·
  • Acceptable Use·
  • Model Licences·
  • Security·
  • Cookies

Registered in the United Arab Emirates. Delivery partner: Bizfy Solutions LLP, Indore, India.

DocxIntel