A 3-slide overview of the performance bottleneck we solved, the architecture transformation, and the business impact.
July 2026 · InvestorCOM
The proposed architecture does not change the core document-generation business logic. It changes how work is distributed and coordinated.
The current solution behaves largely as one long processing chain, where delays in one stage can affect the entire batch.
The new architecture breaks that chain into independent processing stages connected through queues. This allows multiple documents and batches to be processed concurrently, isolates failures, improves visibility, and allows us to increase capacity only where it is needed.
Faster processing, better stability during peak volumes, improved recovery from failures, clearer real-time progress for users, and a more cost-effective path for future growth.
Before: The current architecture processes most batch activities as a tightly connected workflow. When a batch slows down or fails, it can be difficult to immediately determine whether the issue originated in document generation, compression, AODA/Crawford, packaging, or another dependency.
With the New Architecture: Each processing stage is separated through dedicated queues and workers, providing clear visibility into where every document and batch is in the processing lifecycle. Delays, failures, and growing backlogs can be associated with a specific stage.
Impact: Teams can identify the source of processing issues faster, reduce troubleshooting and recovery time, and isolate failures without impacting other documents or batches.
A summary of the architectural changes that unlock parallel processing, independent scaling, and real-time visibility.
Multiple documents can be generated concurrently, eliminating sequential bottlenecks.
Generation, compression, AODA, and packaging operate independently.
Processing capacity automatically adapts to workload.
A failure in one document or stage does not block the entire pipeline.
More batches and documents can be processed simultaneously.
Scale only the processing stage that requires additional capacity.
Users can see document and batch processing progress.
Exstream, Crawford/AODA, compression, and existing business rules remain in place.
A monolithic, tightly-coupled system where one component controls the entire processing flow.
BatchProcessor controlled the entire flow. PublisherWS handled multiple responsibilities. Single worker processed batches sequentially with no parallelism.
No horizontal scaling, no failure isolation, no real-time visibility, and resource contention between components.
An event-driven, decoupled pipeline where each processing stage runs independently and scales on demand.
Azure Function orchestrator publishes one Service Bus message per document. Multiple DocumentWorker instances consume messages concurrently. Dedicated workers handle each stage independently.
Horizontal scaling, failure isolation, real-time monitoring, and independent worker evolution.
9 test cases · 22,132 documents · 128 batches · identical hardware — legacy engine vs refactored pipeline.
The three batches ran in parallel, at the same time, not one after another.
The re-architecture delivers measurable improvements across reliability, capacity, and operational efficiency.
128 out of 128 batches completed successfully. Stuck batches are detected and recovered automatically in under 15 minutes — no manual intervention required.
Overnight capacity increases from ~37,800 to ~135,000 documents. The system now handles 2× today's peak load with room to spare.
Queue depth metrics expose bottlenecks by stage. Structured logging with full context. Provable SLAs with weekly published metrics.
No additional Exstream licenses needed. The existing per-machine license supports multiple engine instances. Scaling is an infrastructure decision (VM spec), not a procurement decision.
Each processing stage can be updated, scaled, or replaced independently. Adding new features doesn't require touching the entire system.
Beyond the core re-architecture, these improvements compound the performance gains and improve the user experience.
Unlock the screen during batch processing — users continue working while jobs run in the background.
Automatic alerts when VM is down or incidents occur — no more discovering problems when users call.
Structured logging with full context — debug issues in minutes instead of hours.
Analyze and optimize template rendering, memory allocation, and I/O patterns to reduce per-document composition time.
Real-time visibility into batch processing, throughput, and SLA compliance with historical trend analysis.
The new architecture enables real-time monitoring, faster diagnosis, and better capacity planning through per-stage telemetry and centralized observability.
Parallel processing and independent workers allow the platform to process more documents concurrently, improving throughput and reducing overall batch processing time.
Grafana provides a centralized view of processing times, throughput, queue activity, worker utilization, and infrastructure health.
Processing stages can now be monitored independently, making it easier to identify whether delays or failures originate in document generation, compression, AODA/Crawford, packaging, or infrastructure.
Historical and real-time metrics help the team identify workload trends, understand resource utilization, tune worker concurrency, and determine when additional capacity may be required.