Examiner‑Facing Delivery at Scale: Rendering 10,000‑Page Documents for 20,000+ Users with NodeJS, React, and Docker

In earlier articles, we covered how structured data, modeling, and retrieval work together to produce grounded, citation‑rich summaries. This article shifts to the part of the system examiners interact with every day: the delivery layer — where massive documents must load instantly, navigation must feel effortless, and performance must remain stable for 20,000+ users.

This is where engineering meets ergonomics.
Where 10,000‑page documents must feel lightweight.
Where national‑scale workloads must behave like local files.
Where every click, scroll, and search must be predictable.

This article explains how we built a high‑performance, workflow‑optimized UI using NodeJS, ReactJS, and Docker, and how we deliver consistent performance on commodity hardware.

The Challenge: Documents That Break Normal Viewers

Most document viewers assume:

• A few dozen pages
• A single PDF
• A single user
• A single workflow

Our reality is different.

We routinely handle:

• Documents exceeding 10,000 pages
• Dozens of documents per case
• 20,000+ concurrent users
• High‑frequency navigation between structured regions
• Cached summaries generated at case‑processing time

A traditional “load the entire PDF” approach would collapse under its own weight.
So we built something fundamentally different.

The Core Principle: Documents Are Logical Units, Pages Are Delivery Units

Upstream, documents are processed as single logical units to preserve clinical context.

But in the UI, we serve individual pages on demand from a distributed file store. This gives us:

• Instant initial load
• Predictable memory usage
• Smooth scrolling
• Zero blocking on large documents
• No multi‑gigabyte downloads

React renders only what’s visible. Node streams only what’s requested.
The result is a viewer that feels lightweight, even when the underlying document is enormous.

Nodejs: The High‑Throughput Routing And Delivery Engine

Our NodeJS layer is optimized for:

• High concurrency
• Low‑latency page retrieval
• Efficient streaming
• Direct routing to the correct SOLR server
• Fast access to cached summaries
• Predictable performance under heavy load

Node’s event‑driven model is ideal for this workload. It allows us to:

• Serve thousands of simultaneous page requests
• Maintain consistent performance for 20,000+ users
• Avoid thread contention
• Scale horizontally using Docker

Node doesn’t just serve pages — it orchestrates the entire examiner workflow.

Reactjs: Rendering At Scale Without Overwhelming The Browser

Rendering a 10,000‑page document in the browser is impossible — unless you design around the constraints.

We use several techniques:

1. Virtualized rendering

React only renders the pages currently in view.
Everything else is a placeholder.

This keeps:

• Memory usage flat
• Frame rates high
• Scrolling smooth

2. Predictive prefetching

As the examiner scrolls, we prefetch the next few pages.
This makes the viewer feel instantaneous.

3. Region‑aware navigation

Because upstream processing identifies structured regions (encounters, imaging, ADLs, etc.), we can:

• Jump directly to relevant sections
• Highlight structured hits
• Sync the viewer with cached summaries

This turns a 10,000‑page document into a navigable, structured experience.

Docker: Predictable Performance And Easy Scaling

Every part of the delivery layer runs in Docker containers:

• NodeJS servers
• React build artifacts
• Supporting services needed for routing and UI delivery

Docker gives us:

• Consistent performance across environments
• Fast horizontal scaling
• Easy deployment
• Isolation between workloads
• Predictable resource usage

When user load spikes, we scale out.
When cases shift, we rebalance.
When documents grow, performance stays flat.

Workflow Optimization: The Real Differentiator

Rendering is only half the story.
The real value comes from how we optimize examiner workflows.

1. Structured navigation

Examiners jump directly to:

• Regions
• Encounters
• Imaging
• Physician notes
• Summaries

No scrolling. No hunting. No wasted time.

2. Cached summaries

Summaries are generated at case‑processing time, not on demand.
Node simply retrieves them instantly.

This ensures:

• Zero latency
• Zero variability
• Zero load on LLM infrastructure during user activity

3. Fast, filtered search

SOLR search results appear instantly, filtered by:

• Region
• Encounter type
• Date
• Document type

Examiners can find what they need in seconds, even in massive documents.

Performance At National Scale

Supporting 20,000+ users means:

• Every millisecond matters
• Every page request must be predictable
• Every UI interaction must be smooth

We monitor:

• Page retrieval latency
• Render times
• Scroll performance
• Query patterns
• User behavior

When we see repeated patterns, we optimize:

• New structured fields
• New region detectors
• New prefetch rules
• New routing strategies

The system evolves based on real usage.

Why This Architecture Works

NodeJS + ReactJS + Docker gives us:

• High concurrency
• Low latency
• Predictable performance
• Smooth rendering
• Easy scaling
• Workflow‑optimized navigation

And most importantly:

It makes 10,000‑page documents feel small.