How Mittsure Automated Educational Content Review and Cut Quality Assurance Costs by 80%

File upload bypasses the backend server entirely. The client browser receives a cryptographically signed temporary write URL and uploads the manuscript file sometimes 400+ pages with embedded images directly to cloud object storage. This was the only viable approach for large textbook PDFs: routing files through the application server would hit request-body size limits mid-upload, and doing so for concurrent sessions would saturate backend memory. By decoupling file ingest from the application layer, the backend remains stateless and upload reliability is independent of server load. Every downstream process reads from object storage, not from a transient request payload.

Splitting a textbook into processable units cannot be done with fixed-length chunking. A Chapter 1 introduction might be 8 pages; a Chapter 5 worked-example set might be 42. Fixed splits would bisect chapters mid-argument and destroy the semantic coherence that makes audit findings meaningful. The segmentation layer uses visual layout analysis on the document stream to identify chapter title patterns and major structural boundaries. Alternatively, editors can upload a table-of-contents page image, which a vision model parses to determine chapter start pages directly. Semantic chapter boundaries not arbitrary length limits are the minimum unit of coherent auditing, because cross-page contradictions and narrative continuity errors only become visible when the full chapter is in scope at once.

The seven quality pipelines Grammar and Style, Semantic and Factual Accuracy, Layout and Margin Inspection, Illustration and Media Relevance, Cross-Page Continuity, Curriculum Compliance and Bias Auditing, and Originality and AI-Content Detection run concurrently against the same chapter segment. Each pipeline receives the same raw chapter content plus the pedagogical context summary and returns structured JSON findings. The alternative, a sequential cascade where each check fed into the next, would have reintroduced the silo problem that made manual review structurally deficient: upstream assumptions would anchor downstream analysis, and errors that lived between categories would still escape. Independent parallel execution with a downstream merge is the only architecture that catches cross-category defects.

Running twelve parallel chapter workers against a 400-page textbook generates a volume of API calls that hits rate limits without key rotation. The credential manager cycles access configurations per call across the model pool, distributing load so that no single credential path saturates during peak parallel execution. When consecutive API errors occur on a given path, the system automatically escalates to a secondary model rather than returning an error to the user. This was non-optional engineering for educational textbook quality assurance automation at production scale: a review job that fails mid-run and requires a restart is operationally indistinguishable from the manual process it was built to replace.

Task metadata processing state, concurrency semaphores, user session context lives in a fast in-memory cache. Heavy payload data chapter JSON results, page image arrays, layout coordinate sets is sharded into discrete objects stored in cloud object storage, with the cache holding only thin reference pointers. This split was driven by a specific constraint: textbook-scale analysis arrays exhaust in-memory limits quickly when multiple documents process concurrently. Keeping the backend stateless by offloading large payloads to object storage allows horizontal scaling without each new server instance inheriting memory pressure from active jobs. The relational database handles only transactional records authentication, audit trails, user data where query predictability matters more than raw throughput.

The output system has two parallel paths. Corrections to text content are applied directly to the source document's XML structure, preserving fonts, column layouts, spacing, and all style attributes without touching the presentation layer a distinction that matters because modifying rendered text rather than source XML is what causes the formatting corruption that previously required design rework after every editorial pass. For Indic script annotations, a companion proofing sheet is generated separately using a vector markup generator that renders Devanagari and Sanskrit diacritics at native fidelity outside the PDF annotation layer. Standard PDF annotation popups do not render complex scripts reliably at print resolution building the annotation layer on top of PDF reader rendering is the single most common failure point in multilingual educational content tooling, and it is invisible until you test at actual print output. The companion sheet sidesteps the problem entirely.

Signed temporary write URLs for direct client-to-storage upload chosen specifically to bypass backend body size limits that would otherwise truncate large textbook PDFs, and to eliminate upload failure as a function of concurrent server load.

Asynchronous web router with cooperative task scheduling selected over a synchronous framework because the workload is I/O-bound across external model APIs, not CPU-bound; concurrency without threading overhead is the correct fit for this call pattern.

Vision-model-guided chapter boundary detection with optional TOC image parsing chosen over fixed-length chunking because textbook chapters vary from 8 to 42+ pages; splitting on semantic boundaries produces coherent audit units, fixed splits do not.

Multimodal vision-language models configured for structured JSON output with rotating credential pool and escalation fallback vision capability required for layout inspection and complex-script page rendering; JSON output enforced to make parallel result merging deterministic.

Hybrid in-memory cache for task metadata plus cloud object storage for chapter JSON payloads and page images keeps the backend stateless for horizontal scaling while preventing large payloads from exhausting per-instance memory limits.

Direct XML modification of source document structure format-preserving correction requires operating at the document structure level, not the presentation layer; modifying rendered text is what causes the formatting corruption that triggers design rework.

Vector markup generator producing companion proofing sheets Devanagari and Sanskrit diacritics do not render reliably in standard PDF annotation overlays; native-fidelity companion sheets are the only approach that works at print resolution.

Server-Sent Events stream from analysis server to editor UI chosen over WebSockets because the flow is unidirectional; SSE eliminates bidirectional connection overhead without sacrificing any needed capability.

Relational database for authentication, audit trails, and user records separates transactional record queries from large binary payloads, keeping query performance predictable as document volume scales.