From 913e4b60ffe49d4e017c0d31fe472fa05a5980f9 Mon Sep 17 00:00:00 2001
From: SF4524LogeshKumar <logeshkumar.dhamodharan@syncfusion.com>
Date: Mon, 16 Mar 2026 19:41:15 +0530
Subject: [PATCH 1/7] 1016259: Architecture for React PDF Viewer

---
 .../architecture/architecture-pdfviewer.md    | 251 ++++++++
 .../how-pdf-rendering-works-in-browser.md     | 605 ++++++++++++++++++
 .../standalone-vs-server-backed-pdf-viewer.md |  77 +++
 .../react/images/high-level-components.png    | Bin 0 -> 27321 bytes
 .../react/images/worker-message-flow.png      | Bin 0 -> 20846 bytes
 5 files changed, 933 insertions(+)
 create mode 100644 Document-Processing/PDF/PDF-Viewer/react/architecture/architecture-pdfviewer.md
 create mode 100644 Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
 create mode 100644 Document-Processing/PDF/PDF-Viewer/react/architecture/standalone-vs-server-backed-pdf-viewer.md
 create mode 100644 Document-Processing/PDF/PDF-Viewer/react/images/high-level-components.png
 create mode 100644 Document-Processing/PDF/PDF-Viewer/react/images/worker-message-flow.png

diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/architecture-pdfviewer.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/architecture-pdfviewer.md
new file mode 100644
index 000000000..bf2aa1289
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/architecture-pdfviewer.md
@@ -0,0 +1,251 @@
+---
+layout: post
+title: Architecture of Syncfusion React PDF Viewer
+description: High-level design, rendering pipeline, data flow, and performance considerations of the Syncfusion React PDF Viewer.
+platform: document-processing
+control: PDF Viewer
+documentation: ug
+---
+
+# Architecture of Syncfusion React PDF Viewer
+
+This guide provides a deep dive into the technical design and internal workings of the Syncfusion React PDF Viewer, including its high-level component architecture, rendering pipeline, data flow across the client and server boundaries, and performance optimization strategies. Understanding these concepts will help you make informed decisions about customization, feature integration, and troubleshooting.
+
+## Overview
+
+The Syncfusion React PDF Viewer operates on a **hybrid client-server architecture** designed for scalability, performance, and rich interactivity:
+
+- **Client-side layer**: A responsive React component that handles user interaction, rendering, annotations, and form filling directly in the browser using the PDFium-based rendering engine. The client provides a smooth, zero-latency user experience for common operations like navigation, zooming, and markup.
+- **Server-side layer**: Optional backend services (via `serviceUrl`) that enable advanced features such as document preprocessing, OCR, form field recognition, digital signatures, secure document streaming, and import/export operations using the Syncfusion PDF Library.
+
+This architecture allows you to use the viewer in a **client-only mode** (perfect for lightweight applications) or with **full server integration** (for enterprise scenarios requiring advanced document processing, security, and compliance).
+
+This page explains the internal architecture of the viewer, focusing on how major modules collaborate, how documents are parsed and rendered using PDFium, and how data flows across threads and network boundaries. This content is intended for developers and integrators who want to understand the viewer's internal design to make informed decisions about customization, performance tuning, and advanced integrations.
+
+**Key Technology Stack:**
+- **PDFium**: Google's open-source PDF rendering and manipulation engine used for fast, reliable PDF parsing and rasterization on the client.
+- **Syncfusion PDF Library**: Server-side library for advanced document processing, preprocessing, and export operations.
+
+## High-level components
+
+The React PDF Viewer is built as a set of modular components, each responsible for a specific responsibility in the viewing pipeline. The following diagram illustrates how these components interact:
+
+![High-level Component Architecture](../images/high-level-components.png)
+
+- **UI Shell** – Provides the container layout, dialogs, panels, and responsive structure. Manages the overall layout and ensures the viewer adapts responsively across different screen sizes and devices.
+
+- **Viewer Core** – Coordinates viewer state, document lifecycle, and event routing. Acts as the central orchestrator that manages document loading, page navigation, state synchronization, and event propagation across all modules.
+
+- **Rendering Engine** – Powered by PDFium, converts parsed PDF page data into visual output using canvas and SVG layers. Handles rasterization, text extraction, and visual rendering of PDF content with high fidelity.
+
+- **Worker(s)** – Perform CPU‑intensive tasks such as document parsing, font processing, and page rasterization outside the main thread. This off-thread processing ensures a responsive UI during heavy operations.
+
+- **Toolbar** – Exposes user actions such as navigation, zooming, annotation tools, printing, and download. 
+
+See [Toolbar Integration](../toolbar-customization/overview) for customization options and available tools.
+
+- **Thumbnail and Bookmark panels** – Enable page navigation and structural browsing. Allow users to quickly jump between pages and view document structure hierarchically. 
+
+See [Thumbnail Page](../navigation#thumbnail-navigation) and [Bookmark Page](../navigation#bookmark-navigation) for page navigation.
+
+- **Annotation and Forms modules** – Manage interactive PDF elements and forms. Interactive elements are indexed and maintained separately for efficient manipulation and serialization.
+
+See [Annotations](../annotation/overview) and [Working with Form Fields](../forms/overview) for detailed usage and API reference.
+
+- **Injected Services** – Enable optional features such as text search, magnification, printing, and form filling. These services are plugged into the viewer architecture based on your licensing and configuration.
+
+See [Text Search](../text-search), [Magnification](../magnification), [Printing](../print/overview) to explore more features.
+
+## Document parsing & internal data model
+
+When a PDF document is loaded, the PDFium rendering engine parses it into a structured internal data model that represents pages, content streams, fonts, images, annotations, form fields, and metadata. This model acts as the foundation for all rendering and interaction workflows in the viewer.
+
+**Key aspects of the data model:**
+
+- **Page representation**: Each page is decomposed into individual drawing commands, text blocks, images, and vector graphics.
+- **Font and resource management**: Fonts are extracted and processed; embedded and external fonts are handled gracefully.
+- **Annotation and form field tracking**: Interactive elements are indexed and maintained separately for efficient manipulation and serialization.
+- **Resource caching**: Parsed page resources are cached to minimize repeated processing during page navigation and zoom operations, improving responsiveness.
+
+For very large or complex documents, memory usage can increase significantly. In such cases, consider implementing **partial loading strategies** or streaming approaches via the server backend. See [Performance Optimization](../getting-started-overview) for best practices.
+
+## Worker model / Off-main-thread processing
+
+The viewer uses **Web Workers** to offload resource‑intensive operations such as document parsing, font processing, and page rasterization from the main UI thread. This architecture ensures smooth user interaction, responsive scrolling, and prevents UI blocking during heavy computations.
+
+**How the worker model operates:**
+
+1. The main thread (React component) receives user actions and coordinates document loading.
+2. Work items (e.g., "parse page 5", "rasterize at 150% zoom") are serialized and sent to worker threads via `postMessage()`.
+3. Workers execute PDFium rendering commands and message back rendering results (image data, text layers).
+4. The main thread receives results and updates the DOM with new rendered content.
+
+When workers are unavailable or disabled, the viewer gracefully falls back to main‑thread execution with reduced performance. This fallback is useful for debugging or in restricted environments.
+
+![Worker Message Flow and Coordination](../images/worker-message-flow.png)
+
+## Network & serviceUrl interactions
+
+The React PDF Viewer supports both **standalone client-side** and **client-server hybrid** architectures:
+
+### Client-only mode (no server)
+- Use the [`documentPath`](https://ej2.syncfusion.com/react/documentation/api/pdfviewer/index-default#documentpath) property to load PDF files directly from your web server or CDN.
+- All rendering, annotations, and form filling happen entirely on the client using PDFium.
+- No network latency for viewing operations; ideal for lightweight, offline-friendly applications.
+
+### Client-server mode (with serviceUrl)
+- The [`serviceUrl`](https://ej2.syncfusion.com/react/documentation/api/pdfviewer/index-default#serviceurl) property enables server‑backed features such as advanced document processing, OCR, streaming, and import/export operations using the Syncfusion PDF Library.
+- Documents may be streamed incrementally (useful for large files) or fetched fully before rendering, depending on your configuration.
+- Server-side preprocessing can optimize documents before delivering them to clients.
+
+**Authentication and security:**
+
+Authentication headers can be injected for secured endpoints or cloud storage integrations:
+
+```js
+ajaxRequestSettings: {
+  headers: {
+    Authorization: 'Bearer <access-token>'
+  }
+}
+```
+See How to add [custom headers in AjaxRequestSettings](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/react/how-to/add-header-value)
+
+**Common integration challenges:**
+- CORS restrictions when loading PDFs from different origins
+- Invalid or unreachable `serviceUrl` endpoints
+- Expired authentication tokens during long viewing sessions
+- Network timeouts on slow connections
+
+See [Server Integration](../getting-started-with-server-backed) for detailed configuration guidance and [Troubleshooting](../troubleshooting/troubleshooting) for common issues.
+
+## Annotation & forms architecture
+
+Annotations and form fields are core interactive elements of the PDF viewing experience. The viewer maintains a sophisticated layer-based rendering model to manage these elements efficiently.
+
+**Annotation rendering and management:**
+
+Annotations (highlights, underlines, strikethroughs, freehand drawings, shapes, stamps, ink, and text markup) are rendered as dedicated interactive layers that sit above the base PDF content. This layering approach ensures:
+
+- **Non-destructive markup**: Annotations overlay the original PDF without modifying the underlying document.
+- **Efficient rendering**: Only annotation layers update when user marks up the document; PDF content remains static.
+- **Event propagation**: User interactions with annotations generate events that flow through the Viewer Core.
+- **Persistence and serialization**: Annotation data can be exported to XFDF, JSON, or other formats for storage and reimport across sessions.
+
+See [Annotations in React PDF Viewer](../annotation/overview) for comprehensive annotation types, styling, and API usage.
+
+**Form field handling:**
+
+Form fields (text inputs, checkboxes, radio buttons, dropdowns, signature fields) are parsed from the PDF and maintained in memory with:
+
+- **Visual representation**: Each field is rendered with its defined appearance (fonts, colors, borders).
+- **Behavioral properties**: Validation rules, calculations, and interdependencies are tracked.
+- **Event binding**: User input to form fields triggers validation, calculation, and change events.
+- **State management**: Field values are synchronized across the document model and UI.
+
+Advanced form features include:
+
+- **Digital signatures**: Sign form fields with certificates; signature validation and timestamping via server integration.
+- **Form validation**: Custom validation rules and required field enforcement.
+- **Form submission**: Export form data as FDF, XFDF, or JSON formats.
+- **Form locking**: Prevent field editing after submission for read-only workflows.
+
+See [Working with Form Fields](../forms/overview) and [Digital Signatures](../digital-signature/add-digital-signature-react) for detailed examples and API documentation.
+
+**Data serialization workflows:**
+
+The viewer supports multiple serialization formats for annotation and form data:
+
+- **XFDF (XML Forms Data Format)**: Industry-standard format for portable annotation and form data.
+- **JSON**: Lightweight, programmatic format for custom integrations.
+- **FDF (Forms Data Format)**: Legacy format supported for backward compatibility.
+
+This enables workflows where annotation and form data can be:
+- Exported from the viewer and processed server-side (e.g., archiving, printing with annotations, compliance reporting).
+- Imported from external sources and merged into new PDFs.
+- Synchronized across multiple viewers or applications.
+
+See Export and Import Annotation for [Annotation](../annotation/export-import/export-annotation) and [Forms](../forms/import-export-form-fields/export-form-fields)
+
+## Accessibility & event flow
+
+The React PDF Viewer is designed with accessibility as a first-class concern, ensuring that all users—including those with visual, motor, and cognitive disabilities—can interact with PDF documents effectively.
+
+**Accessibility features:**
+
+- **Semantic markup and ARIA roles**: The viewer uses proper HTML semantics (`<nav>`, `<button>`, `<article>`) and ARIA attributes (`aria-label`, `aria-live`, `role`) to communicate structure and purpose to assistive technologies.
+- **Keyboard navigation**: All viewer functions are accessible via keyboard. Users can navigate pages, activate tools, fill forms, and create annotations without a mouse.
+- **Screen reader support**: Document structure, page information, form labels, and annotation content are announced clearly to screen readers.
+- **Focus management**: Focus is programmatically managed to guide users through interactive workflows (e.g., form filling).
+- **Color contrast**: UI elements meet WCAG 2.1 AA color contrast standards.
+- **Text extraction**: PDF text is properly extracted and made available for copying, searching, and screen reader consumption.
+
+**Event flow architecture:**
+
+Events generated by user interactions flow through a well-defined event system:
+
+1. **Input events**: Mouse clicks, touch gestures, keyboard input, and resize events are captured.
+2. **Viewer Core processing**: Events are dispatched to the appropriate module (Toolbar, Annotation, Forms, etc.).
+3. **Module handling**: Each module processes the event according to its logic (e.g., Forms module validates input).
+4. **Event propagation**: Modules emit higher-level events (e.g., `onAnnotationAdd`, `onFormFieldChanged`) that applications can listen to.
+
+This design ensures that custom event handlers integrate seamlessly with the viewer's architecture.
+
+See [Keyboard Shortcuts](../keyboard-accessibility) and [Accessibility Guidelines](../accessibility) for best practices when embedding the viewer in accessible applications.
+
+## Theming & styling
+
+The React PDF Viewer applies themes (Material 3, Material Design, etc.) and CSS styling through a cascading layer system. Understanding the recommended import order and safe style override patterns is essential to maintain consistent theming and prevent unintended side effects.
+
+**Recommended theme import order:**
+
+Import theme stylesheets **before** component-specific styles to ensure correct cascade priority and avoid style conflicts:
+
+```js
+// ✓ Correct order
+import '@syncfusion/ej2-base/styles/material.css';           // Theme
+import '@syncfusion/ej2-pdfviewer/styles/pdfviewer.css';    // Component styles
+```
+
+**Available themes:**
+
+- **Material Design**: Follows Material Design 2 guidelines with clean, familiar components.
+- **Material Design 3**: Modern Material Design 3 with updated colors, typography, and motion.
+- **Light and Dark modes**: Automatic or manual switching between light and dark color schemes.
+- **Bootstrap**: Bootstrap 5 theme compatibility.
+- **Custom themes**: Define your own color palettes and typography by overriding CSS variables.
+
+**Safe style overriding:**
+
+Custom styling can be safely applied using exposed CSS custom properties (variables) without modifying component internals or affecting viewer layout and interaction behavior. This approach isolates custom styles and makes them resilient to component updates:
+
+```css
+/* Override theme variables safely */
+:root {
+  --pdfviewer-primary-color: #1976d2;
+  --pdfviewer-text-color: #333333;
+  --pdfviewer-border-radius: 4px;
+}
+```
+
+**Best practices:**
+
+1. Always import theme before component styles to establish correct CSS cascade.
+2. Use CSS custom properties (variables) to customize colors, spacing, and typography.
+3. Avoid inline style modifications to component DOM elements; use CSS classes instead.
+4. Test theme changes across all viewer features (Toolbar, panels, dialogs, annotations).
+
+For comprehensive theme customization options, CSS variable reference, and available themes, see [Theming Guide](../theming-and-styling) and [CSS Class Reference](../theming-and-styling#supported-themes).
+
+## Related architecture and integration topics
+
+- [Getting Started with React PDF Viewer](../getting-started) – Quick setup and your first PDF viewer.
+- [Loading PDF Documents](../open-pdf-files) – Detailed guide on document sources, streaming, and error handling.
+- [Toolbar Integration and Customization](../toolbar-customization/overview) – Customize toolbar buttons and actions.
+- [Annotations in React PDF Viewer](../annotation/overview) – Complete reference for annotation types, styling, and API.
+- [Working with Form Fields](../forms/overview) – Form field rendering, validation, and submission workflows.
+- [Digital Signatures](../digital-signature/add-digital-signature-react) – Signing PDFs and validating signatures.
+- [Accessibility Guidelines](../accessibility) – Keyboard shortcuts, screen reader support, and best practices.
+- [Server Integration](../getting-started-with-server-backed) – Using `serviceUrl` for advanced preprocessing and export operations.
+- [Troubleshooting Common Issues](../troubleshooting/troubleshooting) – CORS, authentication, rendering, and worker problems.
+- [Syncfusion PDF Library Documentation]() – Server-side PDF processing and manipulation reference.
\ No newline at end of file
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
new file mode 100644
index 000000000..c85b0fb7f
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
@@ -0,0 +1,605 @@
+---
+layout: post
+title: How PDF Rendering Works in the Browser
+description: Understand how PDF files are parsed, processed, and rendered as pixels in the browser, and the performance and security considerations involved.
+platform: document-processing
+control: PDF Viewer
+documentation: ug
+---
+
+# How PDF Rendering Works in the Browser
+
+**Explanation** – A detailed walkthrough of the end-to-end PDF rendering pipeline in the browser. Learn how PDFium and the Syncfusion React PDF Viewer parse PDF documents, resolve resources, convert drawing instructions into pixels, and handle the practical trade-offs that affect performance, accuracy, and security.
+
+## Overview
+
+Rendering a PDF in the browser is a multi-stage process that transforms a binary PDF file into interactive visual content on screen. Understanding this pipeline is essential for developers and integrators who need to:
+
+- **Troubleshoot rendering issues** – Identify which stage of the pipeline is causing problems (e.g., missing images, blurry text, font misalignment).
+- **Optimize performance** – Apply targeted caching, lazy-loading, and worker strategies to improve rendering speed and responsiveness.
+- **Make informed architectural decisions** – Choose between client-side rendering, server preprocessing, or hybrid approaches based on document complexity and user experience requirements.
+- **Ensure security and compliance** – Understand cross-origin resource sharing (CORS), font handling, and memory constraints.
+
+This page explains the conceptual rendering pipeline used by the Syncfusion React PDF Viewer (powered by the PDFium rendering engine). While the specific implementation details may vary, the core concepts apply to most browser-based PDF viewers.
+
+**Key takeaway:** Each stage in the pipeline has performance implications and trade-offs. By understanding how they interconnect, you can make better decisions about viewer configuration, document preprocessing, and user experience optimization.
+
+## 1. Parsing and decoding
+
+PDF rendering begins with parsing the binary PDF file structure. The PDFium rendering engine extracts:
+
+- **Document structure**: Indirect objects, cross-reference tables, and content streams that define each page.
+- **Page hierarchy**: Resolving object references to reconstruct complete page definitions.
+- **Resources**: Associated fonts, images, graphics states, and annotations linked to each page.
+
+**Resource extraction:**
+
+Once pages are identified, the viewer extracts encoded content:
+
+- **Image streams**: Embedded images (JPEG, PNG, TIFF, etc.) are identified but **not decoded until rendering time** to minimize memory usage.
+- **Font streams**: Embedded font data is identified; subset and full fonts are handled separately.
+- **Content streams**: PDF drawing commands (path operators, text placement, fills) are extracted for later conversion to a display list.
+
+**Parsing location (main thread vs. worker):**
+
+Parsing is typically **offloaded to a Web Worker** to prevent blocking the UI thread. This is especially important for large PDFs where parsing can take hundreds of milliseconds. The main thread coordinates by sending parsing work items to the worker via `postMessage()`. If workers are unavailable, the viewer falls back to main-thread parsing with reduced responsiveness.
+
+**Performance tip:** For large documents, consider **server-side document preprocessing** using the Syncfusion PDF Library to simplify structure, reduce object count, and speed up parsing on the client. See [Server Integration](#) for details.
+
+## 2. Resolve resources (fonts, images)
+
+After parsing, the viewer resolves and fetches resources needed for rendering.
+
+**Font resolution:**
+
+- **Embedded fonts**: Full or subset fonts stored in the PDF are extracted and made available to the rendering engine.
+- **System fonts**: If a PDF references standard fonts (e.g., Helvetica, Times New Roman) not embedded, the viewer uses system fonts.
+- **Font subsetting trade-off**: Subset fonts reduce PDF file size but require careful glyph-to-character mapping during text layer creation (see [section 5](#5-html-text-layer-selectable-and-searchable-text)). If mapping fails, text selection becomes misaligned.
+
+**Image resolution:**
+
+- **Decoding**: Encoded image streams (JPEG, PNG, TIFF, flate-compressed) are identified and decoded **on-demand** during rendering, not during resource resolution. This lazy approach saves memory for documents with many images.
+- **Format handling**: Common formats are supported natively by canvas/WebGL; unsupported formats are transcoded server-side via `serviceUrl`.
+
+**Cross-origin resource sharing (CORS):**
+
+If fonts or images reference external URLs (uncommon but possible), CORS headers must permit browser access. Missing or misconfigured CORS headers cause resource load failures. Configure your server:
+
+```
+Access-Control-Allow-Origin: https://your-app-domain
+```
+
+**Caching strategies:**
+
+Effective resource caching dramatically improves performance for multi-page documents:
+
+- **Decoded resource cache**: Fonts and images are cached in memory after first decode to avoid redundant processing during page re-renders and zooms.
+- **Cache eviction**: For large PDFs on memory-constrained devices, implement cache eviction policies to free resources for unseen pages.
+- **HTTP caching**: Serve PDFs and resources with appropriate `Cache-Control` headers to enable browser caching.
+
+**Performance tip:** For documents with large or many images, consider **server-side image optimization** (compression, transcoding) before serving to clients.
+
+## 3. Convert PDF drawing instructions into an internal display list
+
+PDF content streams contain drawing instructions—operators that define how to render page content. These instructions are converted into an internal **display list** (also called a **scene graph**), which serves as an intermediate representation optimized for rendering.
+
+**PDF drawing operators:**
+
+PDF content streams consist of operators such as:
+
+- **Path operators**: `m` (moveto), `l` (lineto), `c` (curveto), `re` (rectangle), `f` (fill), `S` (stroke)
+- **Text operators**: `Tj` (show text), `TJ` (show text with adjustments), `Tf` (set font)
+- **Graphics state**: `cm` (transform matrix), `w` (line width), `ca` (fill alpha)
+- **Image operators**: `BI/EI` (begin/end inline image), `Do` (show XObject)
+- **Other**: Clipping paths, blend modes, patterns
+
+**Display list representation:**
+
+Rather than re-interpreting PDF operators on each render, PDFium converts them into an optimized internal format:
+
+- **Graphics operations**: Recorded as `draw line`, `fill path`, `show image`, etc., with resolved coordinates and properties.
+- **State stack**: Graphics state changes (color, transform, alpha) are encoded inline.
+- **Bounding boxes**: Recorded to enable efficient culling and region updates.
+
+**Why a display list improves performance:**
+
+1. **Efficient re-rendering**: Zooming, panning, or rotating requires only re-rasterizing, not re-parsing PDF operators.
+2. **Partial updates**: Only invalidated regions (e.g., annotation overlays) are re-rendered; unchanged content reuses cached results.
+3. **Memory efficiency**: The parsed display list is often smaller than the original PDF content stream.
+4. **Robustness**: Malformed PDF operators are caught during conversion; rendering is more reliable.
+
+**Trade-offs:**
+
+- **Memory usage**: The display list consumes memory proportional to page complexity. Very large or complex pages may require streaming or tiling strategies.
+- **Conversion latency**: Converting to a display list adds latency before rendering begins; this is typically hidden by off-thread processing (see section 7).
+
+## 4. Rendering (Rasterization / Vector rendering / Compositing)
+
+The display list is converted to visual output on screen through a rendering process that handles multiple rendering targets, scaling, anti-aliasing, and layer composition.
+
+**Rendering backends:**
+
+The viewer can use different rendering backends depending on platform and performance requirements:
+
+- **Canvas 2D**: Most common; rasterizes display list to a bitmap on an HTML5 `<canvas>` element. Hardware-accelerated on most devices.
+- **SVG**: Vector rendering for specific use cases (e.g., accessibility, searchability). Slower for complex pages but produces sharp text and graphics.
+- **WebGL**: High-performance GPU-accelerated rasterization for large documents or repeated re-renders (zooming, panning).
+
+**Device pixel ratio (DPR) scaling:**
+
+To render sharp content on high-DPI displays (e.g., 2x or 3x scaling on mobile), the viewer:
+
+1. Reads `window.devicePixelRatio` (e.g., 2.0 for Retina displays).
+2. Allocates canvas buffer at `canvas.width = logicalWidth × DPR` to capture physical pixels.
+3. Applies CSS scaling to display the buffer at logical size.
+
+**Blurry output** is typically caused by DPR mismatch. See [Common issues & quick troubleshooting](../troubleshooting/troubleshooting).
+
+**Anti-aliasing and quality:**
+
+PDFium applies sub-pixel anti-aliasing to smooth edges of text and graphics. Quality can be tuned via rendering parameters:
+
+- **Quality levels**: Faster (less sampling) vs. higher quality (more sampling and processing).
+- **Font hinting**: Can improve text clarity for small fonts.
+
+**Layer composition:**
+
+Multiple layers are composited to create the final output:
+
+1. **Base layer (PDF content)**: Rasterized once and cached.
+2. **Annotation layer**: Overlaid above PDF content; updated when annotations change.
+3. **Text layer**: Positioned HTML elements for selection/search (see section 5); rendered with `pointer-events: none` to allow clicks through to underlying layers.
+4. **UI layer**: Toolbar, dialogs, form highlights.
+
+This layering ensures efficient updates: only modified layers are re-rendered.
+
+**Performance considerations:**
+
+- Rendering large pages or high DPR values increases memory and CPU usage.
+- Repeated renders (e.g., continuous zooming) benefit from caching strategies (see section 8).
+
+## 5. HTML text layer (selectable and searchable text)
+
+To enable text selection, copy-paste, and search functionality, the viewer constructs an **invisible HTML text layer** that overlays the rendered PDF content. This layer bridges the gap between PDF rendering and DOM-based text interaction.
+
+**How the text layer works:**
+
+1. **Extract glyph information**: During PDF parsing, the viewer extracts text content, glyph IDs, and positioning matrices from the PDF content stream.
+2. **Render invisible HTML elements**: For each text span, an HTML element (typically a `<span>`) is positioned and sized to match the glyph positions in the rendered PDF.
+3. **Apply CSS styling**: Text elements are styled with `opacity: 0` or positioned absolutely so they're invisible but interactive.
+4. **Enable interaction**: When users select or search text, they interact with the HTML layer, which references the underlying PDF text.
+
+```html
+<!-- Example: invisible text layer overlay -->
+<div class="pdfviewer-text-layer">
+  <span style="position: absolute; left: 50px; top: 100px; width: 40px; height: 15px;">Hello</span>
+  <span style="position: absolute; left: 95px; top: 100px; width: 30px; height: 15px;">World</span>
+</div>
+```
+
+**Challenges in text layer creation:**
+
+- **Ligatures**: Some fonts replace character sequences (e.g., "fi") with single glyphs. Mapping glyphs back to characters requires special handling.
+- **Glyph-to-character mapping**: Subset fonts include only glyphs used in the document. Determining which Unicode characters correspond to subset glyph IDs is complex and error-prone.
+- **Font substitution**: If the PDF references fonts unavailable in the browser, fallback fonts are used. If fallback fonts have different metrics, text positioning becomes misaligned.
+- **Vertical text**: Right-to-left scripts (Arabic, Hebrew) and vertical text (CJK languages) require special handling.
+
+**Text selection misalignment:**
+
+If text layer elements don't align with rendered text, the root cause is usually:
+
+- **Font metric mismatch**: Embedded font and fallback font have different character widths.
+- **Subset mapping error**: Incorrect glyph-to-character mapping, causing shifted text positions.
+- **Rotation/scaling**: Transform matrices not correctly applied during positioning.
+
+See [Common issues & quick troubleshooting](../troubleshooting/troubleshooting) for diagnosis and fixes.
+
+**Performance tip:** Text layer creation is typically offloaded to a worker thread to avoid UI blocking. For documents with very large text volumes, consider lazy text layer creation (only for visible pages).
+
+## 6. Fonts: embedding, subsetting, and fallback
+
+Font handling is a critical and often overlooked aspect of PDF rendering. PDFs can reference fonts in multiple ways, each with different implications for rendering quality and text layer accuracy.
+
+**Font types and embedding:**
+
+- **Fully embedded fonts**: The PDF includes the entire font data. The viewer uses these directly; rendering is accurate and text selection is reliable. Common in documents created with office applications.
+- **Subset fonts**: Only glyphs used in the document are embedded, reducing PDF size. This saves bandwidth but complicates text layer creation (see section 5).
+- **Referenced fonts**: The PDF references standard fonts (e.g., "Helvetica", "Times New Roman") by name without embedding data. The viewer must find these on the system or use fallback fonts.
+- **Type 3 fonts**: Custom fonts defined by drawing operations. Rendering is correct, but text layer creation is impossible (text selection won't work).
+
+**Subsetting trade-offs:**
+
+| Aspect | Fully embedded | Subset |
+|--------|---|---|
+| PDF size | Larger | Smaller |
+| Rendering quality | Excellent | Excellent |
+| Text selection reliability | High | Lower (mapping errors common) |
+| Copy-paste accuracy | High | Lower |
+| Search functionality | Reliable | Prone to errors |
+
+**System font fallback:**
+
+When the viewer encounters a referenced font not available in the browser:
+
+1. Check system font directories for a matching font name.
+2. If no match, use a generic fallback (serif, sans-serif, monospace).
+3. Apply metric adjustments (spacing, size) to approximate the original font's appearance.
+
+**Font rendering quality vs. text layer accuracy:**
+
+- Embedded fonts render correctly but may introduce text layer mapping errors (subset fonts especially).
+- System fonts render with fallback fonts but may look visibly different. However, text layer is often more reliable because character-to-glyph mapping is straightforward.
+
+**Best practices and troubleshooting:**
+
+1. **Preload system fonts**: If your PDFs reference common fonts, preload them in your HTML:
+   ```html
+   <link rel="preload" href="/fonts/Helvetica.woff2" as="font">
+   ```
+
+2. **Validate glyph coverage**: Before using a fallback font, verify it covers all glyphs in the PDF. Missing glyphs will render as boxes or boxes.
+
+3. **CORS configuration**: If fonts are served from a different origin, ensure CORS headers permit access:
+   ```
+   Access-Control-Allow-Origin: *
+   ```
+
+4. **Server-side font optimization**: Use the Syncfusion PDF Library to pre-process PDFs and convert subset fonts to fully embedded fonts, improving text layer reliability. See [Server Integration](#).
+
+5. **Font substitution tables**: Some viewers allow configuring font substitution mappings (e.g., "Helvetica" → "Arial") to improve visual consistency across platforms.
+
+**Common font issues:**
+
+- **Missing glyphs** (rendered as boxes): Fallback font lacks glyphs present in the original font.
+- **Text layout errors**: Metric mismatch between embedded and fallback fonts causes misalignment.
+- **Type 3 font failure**: Text selection is disabled; consider server-side conversion to standard fonts.
+
+## 7. Off-main-thread processing (Workers / WASM)
+
+PDF rendering involves CPU-intensive tasks (parsing, font processing, rasterization) that can block the main thread and freeze the UI. The Syncfusion React PDF Viewer solves this by offloading heavy work to background threads.
+
+**Worker-based architecture:**
+
+The viewer uses **Web Workers**—background threads that run JavaScript in parallel with the main thread without blocking UI interactions:
+
+1. **Task dispatch**: The main thread sends work items (e.g., "parse page 5") to workers via `postMessage()`.
+2. **Off-thread execution**: Workers execute PDFium parsing, decoding, and rasterization commands.
+3. **Result callback**: Workers send rendered results (bitmap data, text layer, etc.) back to the main thread.
+4. **DOM update**: The main thread receives results and updates the DOM with new rendered content.
+
+**Example message flow:**
+
+```
+Main Thread:
+  → "Parse and render page 5, 100dpi"
+     ↓
+Worker Thread:
+  → Execute PDFium rendering commands
+  → Generate bitmap and text layer data
+     ↓
+  ← { image: ImageData, textLayer: Array }
+     ↓
+Main Thread:
+  → Update canvas and text layer DOM
+```
+
+**Worker pool and concurrency:**
+
+- **Multiple workers**: The viewer typically creates a pool of workers (e.g., 2-4) to parallelize work. Page 5 can be rendered while page 6 is being parsed.
+- **Queue management**: If work exceeds available workers, tasks are queued and processed in order.
+- **Configurable pool size**: Tune worker count based on device CPU cores and available memory.
+
+**WebAssembly (WASM) acceleration:**
+
+PDFium itself is implemented in C++ and compiled to WebAssembly for faster execution than equivalent JavaScript. This enables:
+
+- Fast PDF parsing
+- Efficient rasterization (rendering)
+- Reduced memory overhead
+
+**Graceful fallback:**
+
+If workers are unavailable (disabled by user, unsupported browser, or restricted environment):
+
+- Parsing and rasterization execute on the main thread.
+- UI responsiveness decreases; long operations may freeze the page.
+- Fallback mode is useful for debugging but should not be used in production.
+
+**Configuration and troubleshooting:**
+
+- **Worker count**: Adjust `workerCount` in viewer config to balance parallelism and memory usage.
+- **Worker path**: Ensure worker scripts are served from the correct location and accessible.
+- **Security**: Workers must be served from the same origin (same domain and protocol) due to browser security policies.
+
+See [Configuring Web Workers](../) and [Performance Optimization](#) for detailed tuning guidance.
+
+**Performance impact:**
+
+- **Positive**: Off-thread processing keeps the main thread responsive, enabling smooth UI interactions during rendering.
+- **Trade-off**: Message passing overhead (serializing data) adds latency for very small tasks; not all operations benefit from worker offloading.
+
+## 8. Device & performance considerations
+
+Rendering performance varies dramatically based on device capability (CPU, memory, GPU), document complexity (number of pages, image density, font count), and network conditions. Strategic optimizations can dramatically improve user experience, especially on low-powered devices and over slow networks.
+
+**Core performance optimization strategies:**
+
+### DPR-aware rendering
+
+High-DPI displays (phones, tablets, modern laptops) have `devicePixelRatio > 1`, requiring higher-resolution rendering. Without proper scaling, output is blurry. Proper handling:
+
+- Allocate canvas buffer at `physicalWidth = logicalWidth × devicePixelRatio`
+- Apply CSS scaling to display at logical size
+- Monitor DPR changes (orientation changes, moving window between displays)
+
+### Lazy page rendering (visible-only rendering)
+
+Load and render only pages currently visible to the user:
+
+- **Virtual scrolling**: Maintain a viewport; render pages entering the viewport, unload pages leaving it.
+- **Memory savings**: For 500-page documents, render only 3-5 visible pages instead of all 500.
+- **Network savings**: Fetch resources (fonts, images) only for visible pages.
+
+Implementation requires a scroll listener and dynamic page allocation.
+
+### Thumbnail prefetching
+
+While the user views page 10, prefetch thumbnails for nearby pages (9, 11, 12):
+
+- Improves perceived responsiveness when navigating quickly.
+- Use lower DPR and compression for thumbnails to minimize memory.
+
+### Resource caching and eviction
+
+- **Cache decoded images**: Store decoded images in memory; reuse during zoom operations.
+- **Cache rasterized pages**: For fixed zoom levels, cache rendered bitmaps to avoid re-rendering on scroll.
+- **Cache fonts**: Decoded fonts are reused across pages; large PDFs benefit significantly.
+- **Eviction policy**: Implement LRU (least-recently-used) or other policies to free cache when memory approaches limits.
+
+### Minimize zoom re-renders
+
+Continuous zoom events (mouse wheel, pinch) can trigger re-renders for each intermediate level:
+
+- **Debounce zoom**: Wait for zoom gestures to complete before rendering at final zoom level.
+- **Interim preview**: Show blurry upscaled/downscaled content during gestures; render at final zoom when gesture ends.
+
+### Network streaming strategies
+
+For large PDFs over slow networks:
+
+- **Byte-range requests**: Server sends only requested page ranges, not the entire PDF.
+- **Progressive rendering**: Render visible pages first; background requests fetch remaining pages.
+- **Server preprocessing**: Use the Syncfusion PDF Library to compress, optimize, or split large documents before serving.
+
+### Memory management for large documents
+
+On memory-constrained devices:
+
+- **Reduce worker pool size**: Fewer workers = lower memory overhead.
+- **Aggressive cache eviction**: Free resources aggressively; tolerate re-rendering cost.
+- **Limit zoom level**: Prevent users from zooming to extremely high levels that require huge bitmaps.
+- **Page tiling**: For very large pages, split into smaller tiles and render individually.
+
+**Quick tuning checklist:**
+
+- ✓ Enable DPR-aware scaling (check `devicePixelRatio` on init and on orientation change)
+- ✓ Implement visible-only page rendering or lazy loading
+- ✓ Cache decoded resources (images, fonts) and reuse across pages
+- ✓ Debounce or throttle zoom events to avoid excessive re-renders
+- ✓ For large PDFs: enable byte-range requests and progressive loading
+- ✓ Monitor memory usage; implement cache eviction if memory exceeds thresholds
+- ✓ Test on low-powered devices (older phones, tablets) to identify bottlenecks
+- ✓ Use Chrome DevTools Performance tab to profile rendering and identify slow stages
+
+**Performance monitoring:**
+
+Use browser APIs to measure rendering performance:
+
+```js
+// Measure render time
+const start = performance.now();
+await pdfViewer.renderPage(5);
+const renderTime = performance.now() - start;
+console.log(`Render time: ${renderTime}ms`);
+```
+
+See [Performance Optimization](#) for detailed configuration options and [Performance Profiling](#) for advanced diagnostics.
+
+## 9. Common issues & quick troubleshooting
+
+Rendering issues often trace to one of the stages in the pipeline. By understanding the likely cause, you can diagnose and resolve problems quickly.
+
+### Blurry output
+
+**Symptoms**: Text and graphics appear fuzzy or pixelated, especially on high-DPI displays.
+
+**Root causes**:
+- Incorrect `devicePixelRatio` handling (canvas buffer too small for physical pixels)
+- CSS transform or zoom applied after rendering
+- WebGL context loss and fallback to lower-quality rendering
+
+**Fixes**:
+1. Verify DPR at init and on orientation change:
+   ```js
+   console.log('devicePixelRatio:', window.devicePixelRatio);
+   ```
+2. Check canvas buffer size matches physical dimensions:
+   ```js
+   canvas.width = logicalWidth * devicePixelRatio;
+   ```
+3. Disable CSS zoom/transforms that conflict with canvas scaling.
+4. For high-resolution devices, consider reducing rendering quality to balance sharpness and performance.
+
+See [Section 4: Rendering](#4-rendering-rasterization--vector-rendering--compositing) and [DPR troubleshooting](#).
+
+### Text selection misalignment
+
+**Symptoms**: Selecting text doesn't highlight the correct characters; copy-paste gives wrong text.
+
+**Root causes**:
+- Font metric mismatch (embedded vs. fallback font)
+- Subset font glyph-to-character mapping errors
+- Transform matrix not applied correctly
+- CORS issues preventing embedded font loading
+
+**Fixes**:
+1. Check developer console for font loading errors:
+   ```
+   CORS error loading font from example.com
+   ```
+   Add CORS headers on font server.
+
+2. Verify PDF uses fully embedded fonts (not subsets). If subset fonts, enable server-side preprocessing:
+   ```js
+   const viewer = new PdfViewer({
+     serviceUrl: 'https://your-server.com/api/pdf'
+   });
+   ```
+
+3. For specific PDFs, test with server-side font optimization via the Syncfusion PDF Library.
+
+See [Section 5: HTML text layer](#5-html-text-layer-selectable-and-searchable-text) and [Section 6: Fonts](#6-fonts-embedding-subsetting-and-fallback).
+
+### Missing images
+
+**Symptoms**: Image placeholders or blank areas where images should appear; images render at lower quality than expected.
+
+**Root causes**:
+- Image stream decoding failures (unsupported format)
+- CORS restrictions preventing image loading
+- Memory limits preventing image decoding
+- Corrupted image data in the PDF
+
+**Fixes**:
+1. Check console for CORS errors:
+   ```
+   Access to image at 'https://external-domain.com/img.jpg' blocked by CORS policy
+   ```
+   Solution: Configure CORS on the external server or proxy through your server.
+
+2. Check for decoding errors. Enable debug logging to see which images fail.
+
+3. For unsupported image formats (e.g., JPEG2000), use server-side transcoding:
+   ```js
+   const viewer = new PdfViewer({
+     serviceUrl: 'https://your-server.com/api/pdf/transcode'
+   });
+   ```
+
+4. If memory-constrained, implement image caching and eviction (see [Section 8](#8-device--performance-considerations)).
+
+See [Section 2: Resolve resources](#2-resolve-resources-fonts-images).
+
+### Worker failures
+
+**Symptoms**: PDF loads slowly or not at all; console shows worker errors; viewer falls back to main-thread rendering (UI becomes sluggish).
+
+**Root causes**:
+- Worker script not found (404) due to incorrect path
+- CORS policy blocking worker script load from different origin
+- SharedArrayBuffer disabled (security restriction on some browsers)
+- Worker quota exceeded (too many workers spawned)
+- Browser or environment doesn't support workers
+
+**Fixes**:
+1. Verify worker path is correct and accessible:
+   ```js
+   const viewer = new PdfViewer({
+     workerPath: '/assets/pdfviewer-worker.js'  // Verify file exists
+   });
+   ```
+
+2. Ensure worker script is served with correct `Content-Type`:
+   ```
+   Content-Type: application/javascript
+   ```
+
+3. Check CORS headers if workers are served from a different origin. Workers require same-origin by default.
+
+4. Reduce worker pool size if hitting quota limits:
+   ```js
+   const viewer = new PdfViewer({
+     workerCount: 2  // Reduce from default 4
+   });
+   ```
+
+5. Test fallback mode (disable workers) to isolate worker-specific issues:
+   ```js
+   const viewer = new PdfViewer({
+     workerCount: 0  // Disable workers
+   });
+   ```
+
+See [Section 7: Off-main-thread processing](#7-off-main-thread-processing-workers--wasm) and [Worker Troubleshooting](#).
+
+### Performance is sluggish
+
+**Symptoms**: Slow scrolling, delayed rendering, UI freezes during zoom operations.
+
+**Root causes**:
+- No visible-only rendering (rendering all pages instead of visible pages)
+- Excessive re-renders during continuous zoom or scroll
+- Worker pool too small for document complexity
+- Insufficient caching or aggressive cache eviction
+
+**Fixes**:
+1. Enable lazy rendering if document has many pages:
+   ```js
+   const viewer = new PdfViewer({
+     enableLazyRendering: true
+   });
+   ```
+
+2. Debounce zoom and scroll events:
+   ```js
+   viewer.on('zoom', debounce(() => { /* render */ }, 300));
+   ```
+
+3. Increase worker pool for high-complexity documents:
+   ```js
+   const viewer = new PdfViewer({
+     workerCount: 4
+   });
+   ```
+
+4. Profile with Chrome DevTools to identify bottleneck stage (parsing, rendering, etc.).
+
+See [Section 8: Device & performance considerations](#8-device--performance-considerations) and [Performance Profiling](#).
+
+**General diagnostic approach:**
+
+1. **Identify the stage**: Use browser DevTools Network, Performance, and Console tabs to pinpoint which stage fails.
+2. **Check logs**: Enable debug logging in the viewer to see intermediate steps.
+3. **Test fallbacks**: Disable workers, reduce quality, or use server preprocessing to isolate the root cause.
+4. **Isolate the PDF**: Test with simple PDFs (single page, no images) to rule out document-specific issues.
+5. **Check environment**: Verify browser version, device capabilities, and network conditions.
+
+## Related topics and further reading
+
+**Architecture and design:**
+- [Architecture of Syncfusion React PDF Viewer](../architecture/architecture-pdfviewer) – Component design, module interaction, and data flow
+- [Standalone vs Server-Backed Viewer](../architecture/standalone-vs-server-backed) – Client-only vs. hybrid architectures
+
+**Performance and optimization:**
+- [Performance Optimization](../performance/performance-optimization) – Detailed tuning strategies, worker configuration, caching, and profiling
+- [Performance Profiling](../performance/performance-profiling) – Using browser DevTools to measure and diagnose rendering bottlenecks
+- [Memory Management](../performance/memory-management) – Cache policies, eviction strategies, and handling large documents
+
+**Rendering and styling:**
+- [Theming & Styling](../appearance/themes-overview) – Theme customization and CSS class reference
+- [Rendering Options](../rendering/rendering-options) – Quality levels, rendering backends (Canvas, SVG, WebGL)
+
+**Resource handling:**
+- [Font Management](../resources/font-management) – Font subsetting, fallback strategies, and troubleshooting
+- [Image Optimization](../resources/image-optimization) – Server-side image preprocessing and CORS configuration
+- [Loading PDF Documents](../getting-started/loading-documents) – Document sources, streaming, and authentication
+
+**Advanced topics:**
+- [Web Worker Configuration](../performance/web-worker-configuration) – Worker pool tuning, debugging, and fallback modes
+- [Server Integration](../server-integration/getting-started) – Using `serviceUrl` for preprocessing, OCR, and advanced features
+- [Troubleshooting Guide](../troubleshooting/troubleshooting) – Comprehensive issue resolution and FAQs
+- [Syncfusion PDF Library Documentation](../pdf-library/overview) – Server-side PDF processing and manipulation
+
+**Related technologies:**
+- [PDFium Reference](https://pdfium.googlesource.com/pdfium/) – Official PDFium documentation (external link)
+- [Canvas API Reference](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API) – MDN Canvas documentation (external link)
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/standalone-vs-server-backed-pdf-viewer.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/standalone-vs-server-backed-pdf-viewer.md
new file mode 100644
index 000000000..7df38f34f
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/standalone-vs-server-backed-pdf-viewer.md
@@ -0,0 +1,77 @@
+---
+layout: post
+title: Standalone vs Server-Backed PDF Viewer
+description: Compare standalone and server-backed PDF viewer modes to choose the best architecture for performance, scalability, and security.
+platform: document-processing
+control: PDF Viewer
+documentation: ug
+---
+
+# Standalone vs Server-Backed PDF Viewer
+
+This page helps developers and integrators understand the differences between standalone (client-side) and server-backed PDF viewer architectures, and choose the best approach based on performance, scalability, and deployment requirements.
+
+## Overview
+
+The Syncfusion React PDF Viewer can operate in two primary modes: **Standalone (client-side)** and **Server‑Backed**. Each mode defines where PDF processing occurs and how rendering, data flow, and interactions are handled.
+
+This page compares both approaches, highlights their strengths and limitations, and explains why a standalone client-side viewer is often the preferred choice for modern, high-performance web applications.
+
+See [Getting Started](../getting-started) and [Getting Started with Server Backed](../getting-started-with-server-backed) to start working with Standalone and Server Backed PDF Viewer.
+
+## Architectural models
+
+### Standalone (Client-side) viewer
+
+In standalone mode, PDF parsing, rendering, annotation handling, and user interactions are executed entirely within the browser. The viewer loads the PDF directly from a URL or local source and processes it using browser technologies such as Canvas, Web Workers, and WASM.
+
+This model minimizes network latency, reduces server dependency, and provides faster interaction for most viewing and annotation scenarios.
+
+### Server-backed viewer
+
+In server-backed mode, the browser acts primarily as a presentation layer. PDF processing operations—such as parsing, rendering, import/export, and sometimes annotations—are performed on a backend service, with the client receiving processed data or rendered output.
+
+This model is typically used when documents must remain on the server due to compliance, centralized control, or heavy server-side workflows.
+
+## Standalone vs server-backed comparison
+
+The following table summarizes the key differences between standalone and server-backed viewer architectures.
+
+| Aspect | Standalone (Client-side) | Server-backed |
+|------|--------------------------|---------------|
+| **Rendering location** | Browser (Canvas / SVG / WASM) | Server-side service |
+| **Performance** | Faster UI response, low latency | Network-dependent, higher latency |
+| **Scalability** | Scales with client devices | Scales with server resources |
+| **Server load** | Minimal or none | High (CPU, memory, I/O intensive) |
+| **Offline support** | Possible (cached/local PDFs) | Not supported |
+| **Deployment complexity** | Simple (static hosting) | Requires backend infrastructure |
+| **Cost** | Lower operational cost | Higher infrastructure cost |
+| **Customization** | High (client-side events and hooks) | Limited by server APIs |
+| **Typical use cases** | Viewing, annotations, forms, fast navigation | Compliance-heavy, controlled environments |
+
+## Why standalone (client-side) is preferred
+
+For most web applications, a standalone client-side viewer offers significant advantages. Rendering directly in the browser eliminates round-trip delays to the server, resulting in faster page load times, smoother scrolling, and instant annotation feedback.
+
+Standalone viewers also simplify deployment by removing dependency on backend services. This makes them ideal for cloud-native applications, SPAs, and scenarios where responsiveness and user experience are critical.
+
+## When to choose a server-backed viewer
+
+A server-backed viewer may be appropriate when strict data control is required, such as:
+
+- Documents must never be exposed to the client
+- Centralized processing and auditing are mandated
+- Heavy server-side workflows are already in place
+
+In these cases, the additional latency and infrastructure cost are acceptable trade-offs for compliance and centralized control.
+
+## Decision guidance
+
+If performance, scalability, and ease of deployment are your primary concerns, a **standalone client-side PDF viewer** is the recommended option. A server-backed approach should be selected only when regulatory or architectural constraints explicitly require server-side processing.
+
+## See also
+
+- [Architecture of Syncfusion React PDF Viewer](./architecture-pdfviewer)
+- [How PDF Rendering Works in the Browser](./how-pdf-rendering-works-in-browser)
+- [Getting Started standalone PDF Viewer](../getting-started)
+- [Getting Started Server Backed PDF Viewer](../getting-started-with-server-backed)
diff --git a/Document-Processing/PDF/PDF-Viewer/react/images/high-level-components.png b/Document-Processing/PDF/PDF-Viewer/react/images/high-level-components.png
new file mode 100644
index 0000000000000000000000000000000000000000..46dc86f5ece3faa122d76a7df5674b56bdcbb272
GIT binary patch
literal 27321
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
A(EtDd

literal 0
HcmV?d00001

diff --git a/Document-Processing/PDF/PDF-Viewer/react/images/worker-message-flow.png b/Document-Processing/PDF/PDF-Viewer/react/images/worker-message-flow.png
new file mode 100644
index 0000000000000000000000000000000000000000..ef9d51853b3c6b94c03a9a57ad0bb27551be95b2
GIT binary patch
literal 20846
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
Dx4ak!

literal 0
HcmV?d00001


From 81039717b70ba1f9e1217016d1fae64fa20cbb1b Mon Sep 17 00:00:00 2001
From: SF4524LogeshKumar <logeshkumar.dhamodharan@syncfusion.com>
Date: Tue, 17 Mar 2026 09:52:16 +0530
Subject: [PATCH 2/7] 1016259: Updated the architecture TOC file updates

---
 Document-Processing-toc.html                     |  7 +++++++
 .../how-pdf-rendering-works-in-browser.md        | 16 ++++++++--------
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/Document-Processing-toc.html b/Document-Processing-toc.html
index 7816b464a..f36cd724d 100644
--- a/Document-Processing-toc.html
+++ b/Document-Processing-toc.html
@@ -991,6 +991,13 @@
 									<li><a href="/document-processing/pdf/pdf-viewer/react/getting-started-with-server-backed">with Server-Backed PDF Viewer</a></li>
 								</ul>
 							</li>
+							<li>Architecture
+								<ul>
+									<li><a href="/document-processing/pdf/pdf-viewer/react/architecture/architecture-pdfviewer">Architecture</a></li>
+									<li><a href="/document-processing/pdf/pdf-viewer/react/architecture/how-pdf-rendering-works-in-browser">How PDF Rendering Works in the Browser</a></li>
+									<li><a href="/document-processing/pdf/pdf-viewer/react/architecture/standalone-vs-server-backed-pdf-viewer">Standalone vs Server-Backed Viewer</a></li>
+								</ul>	
+							</li>	
 							<li>
 								Environment Integration
 								<ul>
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
index c85b0fb7f..dd4e70c03 100644
--- a/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
@@ -581,21 +581,21 @@ See [Section 8: Device & performance considerations](#8-device--performance-cons
 - [Standalone vs Server-Backed Viewer](../architecture/standalone-vs-server-backed) – Client-only vs. hybrid architectures
 
 **Performance and optimization:**
-- [Performance Optimization](../performance/performance-optimization) – Detailed tuning strategies, worker configuration, caching, and profiling
-- [Performance Profiling](../performance/performance-profiling) – Using browser DevTools to measure and diagnose rendering bottlenecks
-- [Memory Management](../performance/memory-management) – Cache policies, eviction strategies, and handling large documents
+- **Performance Optimization** – Detailed tuning strategies, worker configuration, caching, and profiling
+- **Performance Profiling** – Using browser DevTools to measure and diagnose rendering bottlenecks
+- **Memory Management** – Cache policies, eviction strategies, and handling large documents
 
 **Rendering and styling:**
-- [Theming & Styling](../appearance/themes-overview) – Theme customization and CSS class reference
-- [Rendering Options](../rendering/rendering-options) – Quality levels, rendering backends (Canvas, SVG, WebGL)
+- [Theming & Styling](../theming-and-styling) – Theme customization and CSS class reference
+- **Rendering Options** – Quality levels, rendering backends (Canvas, SVG, WebGL)
 
 **Resource handling:**
-- [Font Management](../resources/font-management) – Font subsetting, fallback strategies, and troubleshooting
-- [Image Optimization](../resources/image-optimization) – Server-side image preprocessing and CORS configuration
+- [Font Management](../how-to/custom-fonts) – Font subsetting, fallback strategies, and troubleshooting
+- **Image Optimization** – Server-side image preprocessing and CORS configuration
 - [Loading PDF Documents](../getting-started/loading-documents) – Document sources, streaming, and authentication
 
 **Advanced topics:**
-- [Web Worker Configuration](../performance/web-worker-configuration) – Worker pool tuning, debugging, and fallback modes
+- **eb Worker Configuration** – Worker pool tuning, debugging, and fallback modes
 - [Server Integration](../server-integration/getting-started) – Using `serviceUrl` for preprocessing, OCR, and advanced features
 - [Troubleshooting Guide](../troubleshooting/troubleshooting) – Comprehensive issue resolution and FAQs
 - [Syncfusion PDF Library Documentation](../pdf-library/overview) – Server-side PDF processing and manipulation

From dba4a31b49f91611874383d3a2fc6c1d54254201 Mon Sep 17 00:00:00 2001
From: SF4524LogeshKumar <logeshkumar.dhamodharan@syncfusion.com>
Date: Tue, 17 Mar 2026 12:08:50 +0530
Subject: [PATCH 3/7] 1016259: Resolved CI failures

---
 .../architecture/architecture-pdfviewer.md    | 14 +++++-----
 .../how-pdf-rendering-works-in-browser.md     | 26 +++++++++----------
 .../standalone-vs-server-backed-pdf-viewer.md |  8 +++---
 3 files changed, 23 insertions(+), 25 deletions(-)

diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/architecture-pdfviewer.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/architecture-pdfviewer.md
index bf2aa1289..e4f6c07ed 100644
--- a/Document-Processing/PDF/PDF-Viewer/react/architecture/architecture-pdfviewer.md
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/architecture-pdfviewer.md
@@ -1,6 +1,6 @@
 ---
 layout: post
-title: Architecture of Syncfusion React PDF Viewer
+title: Architecture of Syncfusion React PDF Viewer | Syncfusion
 description: High-level design, rendering pipeline, data flow, and performance considerations of the Syncfusion React PDF Viewer.
 platform: document-processing
 control: PDF Viewer
@@ -16,7 +16,7 @@ This guide provides a deep dive into the technical design and internal workings
 The Syncfusion React PDF Viewer operates on a **hybrid client-server architecture** designed for scalability, performance, and rich interactivity:
 
 - **Client-side layer**: A responsive React component that handles user interaction, rendering, annotations, and form filling directly in the browser using the PDFium-based rendering engine. The client provides a smooth, zero-latency user experience for common operations like navigation, zooming, and markup.
-- **Server-side layer**: Optional backend services (via `serviceUrl`) that enable advanced features such as document preprocessing, OCR, form field recognition, digital signatures, secure document streaming, and import/export operations using the Syncfusion PDF Library.
+- **Server-side layer**: Optional back-end services (via `serviceUrl`) that enable advanced features such as document preprocessing, OCR, form field recognition, digital signatures, secure document streaming, and import/export operations using the Syncfusion PDF Library.
 
 This architecture allows you to use the viewer in a **client-only mode** (perfect for lightweight applications) or with **full server integration** (for enterprise scenarios requiring advanced document processing, security, and compliance).
 
@@ -34,7 +34,7 @@ The React PDF Viewer is built as a set of modular components, each responsible f
 
 - **UI Shell** – Provides the container layout, dialogs, panels, and responsive structure. Manages the overall layout and ensures the viewer adapts responsively across different screen sizes and devices.
 
-- **Viewer Core** – Coordinates viewer state, document lifecycle, and event routing. Acts as the central orchestrator that manages document loading, page navigation, state synchronization, and event propagation across all modules.
+- **Viewer Core** – Coordinates viewer state, document life-cycle, and event routing. Acts as the central orchestrator that manages document loading, page navigation, state synchronization, and event propagation across all modules.
 
 - **Rendering Engine** – Powered by PDFium, converts parsed PDF page data into visual output using canvas and SVG layers. Handles rasterization, text extraction, and visual rendering of PDF content with high fidelity.
 
@@ -67,7 +67,7 @@ When a PDF document is loaded, the PDFium rendering engine parses it into a stru
 - **Annotation and form field tracking**: Interactive elements are indexed and maintained separately for efficient manipulation and serialization.
 - **Resource caching**: Parsed page resources are cached to minimize repeated processing during page navigation and zoom operations, improving responsiveness.
 
-For very large or complex documents, memory usage can increase significantly. In such cases, consider implementing **partial loading strategies** or streaming approaches via the server backend. See [Performance Optimization](../getting-started-overview) for best practices.
+For very large or complex documents, memory usage can increase significantly. In such cases, consider implementing **partial loading strategies** or streaming approaches via the server back-end. See [Performance Optimization](../getting-started-overview) for best practices.
 
 ## Worker model / Off-main-thread processing
 
@@ -125,12 +125,12 @@ Annotations and form fields are core interactive elements of the PDF viewing exp
 
 **Annotation rendering and management:**
 
-Annotations (highlights, underlines, strikethroughs, freehand drawings, shapes, stamps, ink, and text markup) are rendered as dedicated interactive layers that sit above the base PDF content. This layering approach ensures:
+Annotations (highlights, underlines, strikethrough, freehand drawings, shapes, stamps, ink, and text markup) are rendered as dedicated interactive layers that sit above the base PDF content. This layering approach ensures:
 
 - **Non-destructive markup**: Annotations overlay the original PDF without modifying the underlying document.
 - **Efficient rendering**: Only annotation layers update when user marks up the document; PDF content remains static.
 - **Event propagation**: User interactions with annotations generate events that flow through the Viewer Core.
-- **Persistence and serialization**: Annotation data can be exported to XFDF, JSON, or other formats for storage and reimport across sessions.
+- **Persistence and serialization**: Annotation data can be exported to XFDF, JSON, or other formats for storage and reimporting across sessions.
 
 See [Annotations in React PDF Viewer](../annotation/overview) for comprehensive annotation types, styling, and API usage.
 
@@ -145,7 +145,7 @@ Form fields (text inputs, checkboxes, radio buttons, dropdowns, signature fields
 
 Advanced form features include:
 
-- **Digital signatures**: Sign form fields with certificates; signature validation and timestamping via server integration.
+- **Digital signatures**: Sign form fields with certificates; signature validation and time-stamping via server integration.
 - **Form validation**: Custom validation rules and required field enforcement.
 - **Form submission**: Export form data as FDF, XFDF, or JSON formats.
 - **Form locking**: Prevent field editing after submission for read-only workflows.
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
index dd4e70c03..0fad9cbe7 100644
--- a/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
@@ -1,6 +1,6 @@
 ---
 layout: post
-title: How PDF Rendering Works in the Browser
+title: How PDF Rendering Works in the Browser  | Syncfusion
 description: Understand how PDF files are parsed, processed, and rendered as pixels in the browser, and the performance and security considerations involved.
 platform: document-processing
 control: PDF Viewer
@@ -58,12 +58,12 @@ After parsing, the viewer resolves and fetches resources needed for rendering.
 
 **Image resolution:**
 
-- **Decoding**: Encoded image streams (JPEG, PNG, TIFF, flate-compressed) are identified and decoded **on-demand** during rendering, not during resource resolution. This lazy approach saves memory for documents with many images.
-- **Format handling**: Common formats are supported natively by canvas/WebGL; unsupported formats are transcoded server-side via `serviceUrl`.
+- **Decoding**: Encoded image streams (JPEG, PNG, TIFF, Flate-compressed) are identified and decoded **on-demand** during rendering, not during resource resolution. This lazy approach saves memory for documents with many images.
+- **Format handling**: Common formats are supported natively by canvas/WebGL; unsupported formats are trans-coded server-side via `serviceUrl`.
 
 **Cross-origin resource sharing (CORS):**
 
-If fonts or images reference external URLs (uncommon but possible), CORS headers must permit browser access. Missing or misconfigured CORS headers cause resource load failures. Configure your server:
+If fonts or images reference external URLs (uncommon but possible), CORS headers must permit browser access. Missing or mis-configured CORS headers cause resource load failures. Configure your server:
 
 ```
 Access-Control-Allow-Origin: https://your-app-domain
@@ -77,7 +77,7 @@ Effective resource caching dramatically improves performance for multi-page docu
 - **Cache eviction**: For large PDFs on memory-constrained devices, implement cache eviction policies to free resources for unseen pages.
 - **HTTP caching**: Serve PDFs and resources with appropriate `Cache-Control` headers to enable browser caching.
 
-**Performance tip:** For documents with large or many images, consider **server-side image optimization** (compression, transcoding) before serving to clients.
+**Performance tip:** For documents with large or many images, consider **server-side image optimization** (compression, trans-coding) before serving to clients.
 
 ## 3. Convert PDF drawing instructions into an internal display list
 
@@ -103,7 +103,7 @@ Rather than re-interpreting PDF operators on each render, PDFium converts them i
 
 **Why a display list improves performance:**
 
-1. **Efficient re-rendering**: Zooming, panning, or rotating requires only re-rasterizing, not re-parsing PDF operators.
+1. **Efficient re-rendering**: Zooming, panning, or rotating requires only re-rasterize, not re-parsing PDF operators.
 2. **Partial updates**: Only invalidated regions (e.g., annotation overlays) are re-rendered; unchanged content reuses cached results.
 3. **Memory efficiency**: The parsed display list is often smaller than the original PDF content stream.
 4. **Robustness**: Malformed PDF operators are caught during conversion; rendering is more reliable.
@@ -117,12 +117,12 @@ Rather than re-interpreting PDF operators on each render, PDFium converts them i
 
 The display list is converted to visual output on screen through a rendering process that handles multiple rendering targets, scaling, anti-aliasing, and layer composition.
 
-**Rendering backends:**
+**Rendering back-ends:**
 
-The viewer can use different rendering backends depending on platform and performance requirements:
+The viewer can use different rendering back-ends depending on platform and performance requirements:
 
-- **Canvas 2D**: Most common; rasterizes display list to a bitmap on an HTML5 `<canvas>` element. Hardware-accelerated on most devices.
-- **SVG**: Vector rendering for specific use cases (e.g., accessibility, searchability). Slower for complex pages but produces sharp text and graphics.
+- **Canvas 2D**: Most common; rasterize display list to a bitmap on an HTML5 `<canvas>` element. Hardware-accelerated on most devices.
+- **SVG**: Vector rendering for specific use cases (e.g., accessibility, search ability). Slower for complex pages but produces sharp text and graphics.
 - **WebGL**: High-performance GPU-accelerated rasterization for large documents or repeated re-renders (zooming, panning).
 
 **Device pixel ratio (DPR) scaling:**
@@ -146,7 +146,7 @@ PDFium applies sub-pixel anti-aliasing to smooth edges of text and graphics. Qua
 
 Multiple layers are composited to create the final output:
 
-1. **Base layer (PDF content)**: Rasterized once and cached.
+1. **Base layer (PDF content)**: Rasterize once and cached.
 2. **Annotation layer**: Overlaid above PDF content; updated when annotations change.
 3. **Text layer**: Positioned HTML elements for selection/search (see section 5); rendered with `pointer-events: none` to allow clicks through to underlying layers.
 4. **UI layer**: Toolbar, dialogs, form highlights.
@@ -311,8 +311,6 @@ If workers are unavailable (disabled by user, unsupported browser, or restricted
 - **Worker path**: Ensure worker scripts are served from the correct location and accessible.
 - **Security**: Workers must be served from the same origin (same domain and protocol) due to browser security policies.
 
-See [Configuring Web Workers](../) and [Performance Optimization](#) for detailed tuning guidance.
-
 **Performance impact:**
 
 - **Positive**: Off-thread processing keeps the main thread responsive, enabling smooth UI interactions during rendering.
@@ -479,7 +477,7 @@ See [Section 5: HTML text layer](#5-html-text-layer-selectable-and-searchable-te
 
 2. Check for decoding errors. Enable debug logging to see which images fail.
 
-3. For unsupported image formats (e.g., JPEG2000), use server-side transcoding:
+3. For unsupported image formats (e.g., JPEG2000), use server-side trans-coding:
    ```js
    const viewer = new PdfViewer({
      serviceUrl: 'https://your-server.com/api/pdf/transcode'
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/standalone-vs-server-backed-pdf-viewer.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/standalone-vs-server-backed-pdf-viewer.md
index 7df38f34f..bc032f5a8 100644
--- a/Document-Processing/PDF/PDF-Viewer/react/architecture/standalone-vs-server-backed-pdf-viewer.md
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/standalone-vs-server-backed-pdf-viewer.md
@@ -1,6 +1,6 @@
 ---
 layout: post
-title: Standalone vs Server-Backed PDF Viewer
+title: Standalone vs Server-Backed PDF Viewer  | Syncfusion
 description: Compare standalone and server-backed PDF viewer modes to choose the best architecture for performance, scalability, and security.
 platform: document-processing
 control: PDF Viewer
@@ -29,7 +29,7 @@ This model minimizes network latency, reduces server dependency, and provides fa
 
 ### Server-backed viewer
 
-In server-backed mode, the browser acts primarily as a presentation layer. PDF processing operations—such as parsing, rendering, import/export, and sometimes annotations—are performed on a backend service, with the client receiving processed data or rendered output.
+In server-backed mode, the browser acts primarily as a presentation layer. PDF processing operations—such as parsing, rendering, import/export, and sometimes annotations—are performed on a back-end service, with the client receiving processed data or rendered output.
 
 This model is typically used when documents must remain on the server due to compliance, centralized control, or heavy server-side workflows.
 
@@ -44,7 +44,7 @@ The following table summarizes the key differences between standalone and server
 | **Scalability** | Scales with client devices | Scales with server resources |
 | **Server load** | Minimal or none | High (CPU, memory, I/O intensive) |
 | **Offline support** | Possible (cached/local PDFs) | Not supported |
-| **Deployment complexity** | Simple (static hosting) | Requires backend infrastructure |
+| **Deployment complexity** | Simple (static hosting) | Requires back-end infrastructure |
 | **Cost** | Lower operational cost | Higher infrastructure cost |
 | **Customization** | High (client-side events and hooks) | Limited by server APIs |
 | **Typical use cases** | Viewing, annotations, forms, fast navigation | Compliance-heavy, controlled environments |
@@ -53,7 +53,7 @@ The following table summarizes the key differences between standalone and server
 
 For most web applications, a standalone client-side viewer offers significant advantages. Rendering directly in the browser eliminates round-trip delays to the server, resulting in faster page load times, smoother scrolling, and instant annotation feedback.
 
-Standalone viewers also simplify deployment by removing dependency on backend services. This makes them ideal for cloud-native applications, SPAs, and scenarios where responsiveness and user experience are critical.
+Standalone viewers also simplify deployment by removing dependency on back-end services. This makes them ideal for cloud-native applications, SPAs, and scenarios where responsiveness and user experience are critical.
 
 ## When to choose a server-backed viewer
 

From fe4136bbb845f75168422821cd56221393edc03b Mon Sep 17 00:00:00 2001
From: SF4524LogeshKumar <logeshkumar.dhamodharan@syncfusion.com>
Date: Tue, 17 Mar 2026 18:14:23 +0530
Subject: [PATCH 4/7] 1016259: Updated conformance, large pdf and pending files
 in Architecture

---
 Document-Processing-toc.html                  |  4 +
 .../how-pdf-rendering-works-in-browser.md     | 46 ++++-----
 .../architecture/pdf-standards-conformance.md | 94 +++++++++++++++++++
 .../performance-model-for-large-pdfs.md       | 90 ++++++++++++++++++
 .../self-hosted-on-prem-deployment.md         | 91 ++++++++++++++++++
 .../when-backend-pdf-services-are-required.md | 79 ++++++++++++++++
 6 files changed, 375 insertions(+), 29 deletions(-)
 create mode 100644 Document-Processing/PDF/PDF-Viewer/react/architecture/pdf-standards-conformance.md
 create mode 100644 Document-Processing/PDF/PDF-Viewer/react/architecture/performance-model-for-large-pdfs.md
 create mode 100644 Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
 create mode 100644 Document-Processing/PDF/PDF-Viewer/react/architecture/when-backend-pdf-services-are-required.md

diff --git a/Document-Processing-toc.html b/Document-Processing-toc.html
index f36cd724d..ab65c6e35 100644
--- a/Document-Processing-toc.html
+++ b/Document-Processing-toc.html
@@ -996,6 +996,10 @@
 									<li><a href="/document-processing/pdf/pdf-viewer/react/architecture/architecture-pdfviewer">Architecture</a></li>
 									<li><a href="/document-processing/pdf/pdf-viewer/react/architecture/how-pdf-rendering-works-in-browser">How PDF Rendering Works in the Browser</a></li>
 									<li><a href="/document-processing/pdf/pdf-viewer/react/architecture/standalone-vs-server-backed-pdf-viewer">Standalone vs Server-Backed Viewer</a></li>
+									<li><a href="/document-processing/pdf/pdf-viewer/react/architecture/when-backend-pdf-services-are-required">When Backend PDF Services Are Required</a></li>
+									<li><a href="/document-processing/pdf/pdf-viewer/react/architecture/performance-model-for-large-pdfs">Performance Model for Large PDFs</a></li>
+									<li><a href="/document-processing/pdf/pdf-viewer/react/architecture/self-hosted-on-prem-deployment">Self-Hosted and On-Prem Deployment</a></li>
+									<li><a href="/document-processing/pdf/pdf-viewer/react/architecture/pdf-standards-conformance">Supported PDF Standards and Conformance</a></li>
 								</ul>	
 							</li>	
 							<li>
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
index 0fad9cbe7..325d5835c 100644
--- a/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
@@ -9,7 +9,7 @@ documentation: ug
 
 # How PDF Rendering Works in the Browser
 
-**Explanation** – A detailed walkthrough of the end-to-end PDF rendering pipeline in the browser. Learn how PDFium and the Syncfusion React PDF Viewer parse PDF documents, resolve resources, convert drawing instructions into pixels, and handle the practical trade-offs that affect performance, accuracy, and security.
+A detailed walkthrough of the end-to-end PDF rendering pipeline in the browser. Learn how PDFium and the Syncfusion React PDF Viewer parse PDF documents, resolve resources, convert drawing instructions into pixels, and handle the practical trade-offs that affect performance, accuracy, and security.
 
 ## Overview
 
@@ -22,8 +22,6 @@ Rendering a PDF in the browser is a multi-stage process that transforms a binary
 
 This page explains the conceptual rendering pipeline used by the Syncfusion React PDF Viewer (powered by the PDFium rendering engine). While the specific implementation details may vary, the core concepts apply to most browser-based PDF viewers.
 
-**Key takeaway:** Each stage in the pipeline has performance implications and trade-offs. By understanding how they interconnect, you can make better decisions about viewer configuration, document preprocessing, and user experience optimization.
-
 ## 1. Parsing and decoding
 
 PDF rendering begins with parsing the binary PDF file structure. The PDFium rendering engine extracts:
@@ -54,7 +52,7 @@ After parsing, the viewer resolves and fetches resources needed for rendering.
 
 - **Embedded fonts**: Full or subset fonts stored in the PDF are extracted and made available to the rendering engine.
 - **System fonts**: If a PDF references standard fonts (e.g., Helvetica, Times New Roman) not embedded, the viewer uses system fonts.
-- **Font subsetting trade-off**: Subset fonts reduce PDF file size but require careful glyph-to-character mapping during text layer creation (see [section 5](#5-html-text-layer-selectable-and-searchable-text)). If mapping fails, text selection becomes misaligned.
+- **Font subsetting trade-off**: Subset fonts reduce PDF file size but require careful glyph-to-character mapping during text layer creation (see [HTML Text Layer](#5-html-text-layer-selectable-and-searchable-text)). If mapping fails, text selection becomes misaligned.
 
 **Image resolution:**
 
@@ -81,37 +79,27 @@ Effective resource caching dramatically improves performance for multi-page docu
 
 ## 3. Convert PDF drawing instructions into an internal display list
 
-PDF content streams contain drawing instructions—operators that define how to render page content. These instructions are converted into an internal **display list** (also called a **scene graph**), which serves as an intermediate representation optimized for rendering.
-
-**PDF drawing operators:**
-
-PDF content streams consist of operators such as:
-
-- **Path operators**: `m` (moveto), `l` (lineto), `c` (curveto), `re` (rectangle), `f` (fill), `S` (stroke)
-- **Text operators**: `Tj` (show text), `TJ` (show text with adjustments), `Tf` (set font)
-- **Graphics state**: `cm` (transform matrix), `w` (line width), `ca` (fill alpha)
-- **Image operators**: `BI/EI` (begin/end inline image), `Do` (show XObject)
-- **Other**: Clipping paths, blend modes, patterns
+PDF content streams contain drawing instructions that define how to render page content. The viewer converts these instructions into an internal **display list** (also called a **scene graph**), which serves as an optimized intermediate representation for efficient rendering.
 
-**Display list representation:**
+**How it works:**
 
-Rather than re-interpreting PDF operators on each render, PDFium converts them into an optimized internal format:
+PDFium processes the raw PDF drawing commands and converts them into an optimized internal format that includes:
 
-- **Graphics operations**: Recorded as `draw line`, `fill path`, `show image`, etc., with resolved coordinates and properties.
-- **State stack**: Graphics state changes (color, transform, alpha) are encoded inline.
-- **Bounding boxes**: Recorded to enable efficient culling and region updates.
+- Resolved graphics operations (paths, fills, images, text) with final coordinates and properties
+- Transformed graphics state changes (color, scaling, transparency)
+- Bounding boxes for efficient region management
 
-**Why a display list improves performance:**
+**Performance benefits:**
 
-1. **Efficient re-rendering**: Zooming, panning, or rotating requires only re-rasterize, not re-parsing PDF operators.
-2. **Partial updates**: Only invalidated regions (e.g., annotation overlays) are re-rendered; unchanged content reuses cached results.
-3. **Memory efficiency**: The parsed display list is often smaller than the original PDF content stream.
-4. **Robustness**: Malformed PDF operators are caught during conversion; rendering is more reliable.
+1. **Efficient re-rendering**: Zooming, panning, or rotating reuses the display list; no need to re-parse the original instructions
+2. **Partial updates**: Only changed regions (e.g., annotation overlays) are re-rendered; unchanged content is cached
+3. **Memory efficiency**: The optimized display list is typically smaller than the original PDF content stream
+4. **Reliability**: Rendering errors are caught early, ensuring consistent results
 
 **Trade-offs:**
 
-- **Memory usage**: The display list consumes memory proportional to page complexity. Very large or complex pages may require streaming or tiling strategies.
-- **Conversion latency**: Converting to a display list adds latency before rendering begins; this is typically hidden by off-thread processing (see section 7).
+- **Memory usage**: Complex pages consume more memory for the display list; very large pages may require tiling strategies
+- **Conversion time**: Initial display list creation adds latency, though this is typically handled off-thread (see [Off-main-thread processing](#7-off-main-thread-processing-workers--wasm))
 
 ## 4. Rendering (Rasterization / Vector rendering / Compositing)
 
@@ -194,7 +182,7 @@ If text layer elements don't align with rendered text, the root cause is usually
 
 See [Common issues & quick troubleshooting](../troubleshooting/troubleshooting) for diagnosis and fixes.
 
-**Performance tip:** Text layer creation is typically offloaded to a worker thread to avoid UI blocking. For documents with very large text volumes, consider lazy text layer creation (only for visible pages).
+N> **Performance tip:** Text layer creation is typically offloaded to a worker thread to avoid UI blocking. For documents with very large text volumes, consider lazy text layer creation (only for visible pages).
 
 ## 6. Fonts: embedding, subsetting, and fallback
 
@@ -428,7 +416,7 @@ Rendering issues often trace to one of the stages in the pipeline. By understand
 3. Disable CSS zoom/transforms that conflict with canvas scaling.
 4. For high-resolution devices, consider reducing rendering quality to balance sharpness and performance.
 
-See [Section 4: Rendering](#4-rendering-rasterization--vector-rendering--compositing) and [DPR troubleshooting](#).
+See [Rendering, Rasterization](#4-rendering-rasterization--vector-rendering--compositing) to know more about DPR conversion.
 
 ### Text selection misalignment
 
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/pdf-standards-conformance.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/pdf-standards-conformance.md
new file mode 100644
index 000000000..047a82160
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/pdf-standards-conformance.md
@@ -0,0 +1,94 @@
+---
+layout: post
+title: Supported PDF standards and conformance | Syncfusion
+description: Learn here all about supported PDF standards and conformance in Syncfusion React PDF Viewer and Component.
+platform: document-processing
+control: PDF Viewer
+documentation: ug
+---
+
+# Supported PDF standards and conformance
+
+This section explains the PDF standards supported by the Syncfusion React PDF Viewer and how the viewer handles PDF documents created according to standard specifications.
+
+## Overview
+
+The Syncfusion React PDF Viewer is engineered to **render and interact with PDF documents created according to standard PDF specifications**. It delivers accurate visual representation, smooth user interaction, and consistent behavior across different browser environments.
+
+The React PDF Viewer excels at **standards-based rendering and interaction**, providing users with a seamless viewing experience for a wide range of PDF documents created using industry-standard tools and processes.
+
+## PDF specification support
+
+The React PDF Viewer supports rendering PDF documents compliant with **ISO 32000 PDF specifications** (PDF 1.4 through 2.0), which define the structural and behavioral foundation of PDF files.
+
+The viewer provides comprehensive rendering capabilities for:
+- Text, images, and vector graphics with high fidelity
+- Embedded fonts and page resources for accurate layout preservation
+- Bookmarks and document outlines for enhanced navigation
+- Annotations and comments for collaborative workflows
+- Interactive form fields (AcroForms) with full user interaction support
+- Digital signatures with visual rendering and verification capabilities
+
+Documents created using standards-compliant PDF authoring tools are displayed and interacted with seamlessly in modern browser environments.
+
+## Viewing standards-generated PDF documents
+
+The React PDF Viewer excels at displaying documents generated for widely used PDF standards, including:
+
+- **Archival PDFs (PDF/A)** – long-term preservation documents with enhanced reliability
+- **Print-optimized PDFs (PDF/X)** – professionally prepared documents for printing workflows
+- **Tagged PDFs** – structurally enriched documents optimized for accessibility
+
+The viewer delivers **faithful layout rendering and intuitive user interaction**, empowering users to read, navigate, search, annotate, and review documents within web applications with confidence.
+
+## Conformance and standards handling
+
+The Syncfusion React PDF Viewer is optimized for **standards-based rendering and interaction**. The viewer leverages PDF documents that have been authored or processed in accordance with required PDF standards, ensuring optimal display quality and user experience.
+
+For enhanced control over PDF standard compliance and conformance requirements, the Syncfusion PDF Library provides comprehensive tooling for **document creation, conversion, and standards validation** as part of the document preparation pipeline.
+
+## Ideal use cases and applications
+
+The React PDF Viewer's standards-based rendering capabilities are optimized for:
+- **Enterprise document viewing portals** – delivering high-quality viewing across organizations
+- **Archival document access systems** – supporting long-term document preservation initiatives
+- **Compliance-driven environments** – enabling reliable viewing of standards-generated PDFs
+- **Interactive document review workflows** – facilitating annotation, collaboration, and feedback
+- **Healthcare and financial systems** – meeting industry standards for document handling
+- **Legal and regulatory platforms** – supporting document management with confidence
+
+## Complementary solutions
+
+The Syncfusion React PDF Viewer excels at rendering and displaying PDF documents created according to standard PDF specifications, including archival, print-optimized, and tagged PDFs.
+
+By focusing on accurate display and responsive user interaction, the viewer ensures consistent, standards-aware document viewing with a rich user experience.
+
+### Expanding capabilities with the PDF Library
+
+The Syncfusion ecosystem provides complementary tools for comprehensive PDF workflows:
+
+**React PDF Viewer** – Expert rendering and interaction
+- Display standards-based PDFs
+- Intuitive navigation and search
+- Annotation and collaboration features
+- Form field interaction
+
+**Syncfusion PDF Library** – Advanced PDF processing
+- Create and generate PDF documents
+- Convert documents to PDF/A or PDF/X standards
+- Add digital signatures and security
+- Validate PDF compliance
+
+For scenarios that require PDF creation, conversion, or advanced standards processing, refer to:
+
+- [Working with PDF conformance in Syncfusion PDF Library (.NET)](https://help.syncfusion.com/document-processing/pdf/pdf-library/net/working-with-pdf-conformance)
+
+By leveraging both components, you can build comprehensive document management solutions with end-to-end standards support.
+
+## See also
+
+- [Architecture of Syncfusion React PDF Viewer](./architecture-pdfviewer)
+- [How PDF Rendering Works in the Browser](./how-pdf-rendering-works-in-browser)
+- [Standlone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
+- [When backend PDF services are required](./when-backend-pdf-services-are-required)
+- [Self Hosted on](./self-hosted-on-prem-deployment)
\ No newline at end of file
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/performance-model-for-large-pdfs.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/performance-model-for-large-pdfs.md
new file mode 100644
index 000000000..b04652c1c
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/performance-model-for-large-pdfs.md
@@ -0,0 +1,90 @@
+---
+layout: post
+title: Performance model for large PDFs | Syncfusion
+description: Learn here all about Performance model for large PDF files and performance considerations in Syncfusion React PDF Viewer.
+platform: document-processing
+documentation: ug
+control: PDF Viewer
+---
+
+# Performance model for large PDFs
+
+This section explains how the React PDF Viewer handles **large PDF documents** and outlines the performance model used to deliver a smooth viewing experience across different architectures and device capabilities.
+
+It also provides guidance on where performance optimizations are already covered in existing documentation and how they relate to this model.
+
+## Overview
+
+Rendering and interacting with large PDF documents requires careful handling of memory, CPU usage, and rendering pipelines. The React PDF Viewer follows a layered performance model that adapts based on the deployment mode and document complexity.
+
+With **version 31 and above**, significant performance improvements have been introduced—especially in **standalone (client-side) mode**—making the viewer capable of handling large PDFs efficiently without requiring backend services in many scenarios.
+
+This page gives a high-level architectural view of these performance considerations.
+
+## Standalone viewer performance improvements (v31 and above)
+
+From version **31.x onward**, the standalone React PDF Viewer includes multiple optimizations that improve performance for large documents:
+
+- Incremental and on-demand page rendering
+- Reduced memory footprint during page navigation
+- Improved background worker coordination
+- Faster initial document load and page switch times
+
+These enhancements allow many large PDFs to be handled entirely on the client, provided the device has sufficient system resources.
+
+N> For most modern desktops and laptops, standalone mode is now suitable even for very large documents.
+
+## Large PDF handling strategy
+
+The PDF Viewer follows these principles when loading large documents:
+
+- Pages are rendered incrementally instead of all at once
+- Background tasks such as text extraction and thumbnail generation run independently
+- Rendering prioritizes visible pages to improve perceived performance
+
+This ensures faster user interaction while keeping memory usage under control.
+
+## How this performance model fits with large PDF optimization guides
+
+Detailed **implementation-level optimizations** for large PDFs—such as loading strategies and feature tuning—are covered in a separate User Guide.
+
+For best practices including:
+- Blob-based loading
+- Module minimization
+- Local storage optimization
+- Annotation and form-field handling
+
+See [Load Large PDF Files in React PDF Viewer](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/react/load-large-pdf) to know more about Large PDF Handling.
+
+This performance model page complements that guide by describing *why* those optimizations work from an architectural perspective.
+
+## Performance considerations
+
+The standalone (client-side) React PDF Viewer handles large PDF documents efficiently and is sufficient for most real‑world use cases, including very large files.
+
+Server‑backed processing is **not required for performance in typical scenarios**, but may be considered only in limited cases where external constraints exist, such as:
+
+- Documents exceed practical browser memory limits on specific environments
+- Uniform performance must be guaranteed across low‑end or highly constrained devices
+- PDFs require heavy batch processing or server‑side transformations
+- Enterprise environments mandate centralized control over resource usage
+
+In these scenarios, a server‑backed architecture offloads processing from the client while keeping the viewing experience responsive. For standard large‑PDF viewing and interaction, the standalone viewer remains the recommended approach.
+
+## Summary
+
+The React PDF Viewer uses an adaptive performance model designed to:
+
+- Handle large PDFs efficiently in standalone mode (v31 and above)
+- Scale processing based on document size and feature usage
+- Provide guidance-driven optimizations for heavy documents
+
+For implementation details and tuning, refer to the [Load Large PDF Files](../document-handling/load-large-pdf) guide. For architectural decisions, use this page to evaluate the appropriate performance model for your application.
+
+## See also
+
+- [Architecture of Syncfusion React PDF Viewer](./architecture-pdfviewer)
+- [How PDF Rendering Works in the Browser](./how-pdf-rendering-works-in-browser)
+- [Standlone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
+- [When backend PDF services are required](./when-backend-pdf-services-are-required)
+- [Self hosted on-prem Deployment](./self-hosted-on-prem-deployment)
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
new file mode 100644
index 000000000..6055a8efc
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
@@ -0,0 +1,91 @@
+---
+layout: post
+title: Self-hosted / On-prem deployment in React PDF Viewer
+platform: document-processing
+documentation: ug
+control: PDF Viewer
+---
+
+# Self-hosted / On-prem deployment in React PDF Viewer
+
+This section explains how the Syncfusion React PDF Viewer supports **self-hosted (on‑premises) deployment** and clarifies how the component operates without any dependency on cloud services.
+
+## Overview
+
+The Syncfusion React PDF Viewer is designed to work **entirely within your own infrastructure**. Once the license is purchased, the viewer can be deployed and used without relying on any Syncfusion cloud services.
+
+Both **standalone (client-side)** and **server-backed** deployments can be hosted on your own servers, making the PDF Viewer suitable for enterprise, intranet, and regulated environments.
+
+## No dependency on cloud services
+
+The React PDF Viewer does **not require any third‑party or Syncfusion‑managed cloud services** for production use:
+
+- PDF rendering and interaction can run fully in the browser (standalone mode)
+- Backend PDF services, if used, are hosted and controlled by your organization
+- No document data is sent to Syncfusion servers
+- Licensing is not tied to runtime cloud usage
+
+This makes the viewer suitable for **air‑gapped**, **intranet‑only**, and **high‑security** deployments.
+
+## Standalone (client-side) deployment
+
+In standalone mode, all PDF rendering and interactions are handled directly in the browser using local resources.
+
+Key characteristics:
+- No backend PDF service is required
+- PDFs are processed entirely on the client device
+- Ideal for read‑only viewing and interactive use cases
+- Recommended for most applications
+
+N> We strongly recommend using the **standalone mode** whenever backend processing is not explicitly required.
+
+## Server-backed deployment (self-hosted)
+
+For scenarios that require server-side PDF processing, the React PDF Viewer can be configured to use a **self-hosted PDF Viewer web service**.
+
+Important notes:
+- The Web API hosted endpoint used in samples or code-snippet is **for demonstration and evaluation purposes only**
+- It must not be used in production environments
+- In production, you must host your own PDF Viewer web service
+
+You can self-host the server component by:
+- Reusing the official GitHub Web Service example, or
+- Deploying the provided Docker image in your environment
+
+Once deployed, the service endpoint is configured through the viewer’s `serviceUrl` property.
+
+## Client and server usage after purchase
+
+After purchasing a license:
+- The standalone PDF Viewer can be used without any additional services
+- Server-backed PDF processing can be hosted entirely on your own servers
+- No external cloud integration is required
+
+This gives you full control over:
+- Infrastructure
+- Security policies
+- Data access and storage
+- Deployment lifecycle
+
+## Typical self-hosted deployment scenarios
+
+Self-hosted or on‑prem deployments are commonly used when:
+- Documents must remain within internal networks
+- Regulatory or compliance requirements restrict cloud usage
+- Applications are deployed on private servers or data centers
+- Internal document management or enterprise portals are involved
+
+## Summary
+
+The React PDF Viewer fully supports **self-hosted and on‑prem deployment models**. Whether used in standalone browser mode or with a self-hosted backend service, the viewer operates independently of any cloud services once licensed.
+
+For most use cases, the standalone mode is sufficient and recommended. Server-backed deployment should be used only when specific server-side processing requirements exist.
+
+## See also
+
+- [Architecture of Syncfusion React PDF Viewer](./architecture-pdfviewer)
+- [How PDF Rendering Works in the Browser](./how-pdf-rendering-works-in-browser)
+- [Getting Started standalone PDF Viewer](../getting-started)
+- [Getting Started Server Backed PDF Viewer](../getting-started-with-server-backed)
+- [Standlone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
+- [When Backend PDF Viewer are required](./when-backend-pdf-services-are-required)
\ No newline at end of file
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/when-backend-pdf-services-are-required.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/when-backend-pdf-services-are-required.md
new file mode 100644
index 000000000..04b7365c1
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/when-backend-pdf-services-are-required.md
@@ -0,0 +1,79 @@
+---
+layout: post
+title: When backend PDF services are required | Syncfusion
+description: Learn here all about when and why backend (server-side) PDF services are required in Syncfusion React PDF Viewer.
+platform: document-processing
+documentation: ug
+control: PDF Viewer
+---
+
+# When backend PDF services are required
+
+This section explains **when and why backend (server-side) PDF services are required** for the React PDF Viewer and helps you decide whether a server-backed architecture is necessary for your application.
+
+## Overview
+
+The React PDF Viewer can operate entirely in the browser using a [standalone](../getting-started) (client-side) architecture. However, certain functional, security, and performance requirements make it necessary to process PDF operations on a backend server.
+
+This page outlines the key decision factors for selecting a [server-backed PDF viewer](../getting-started-with-server-backed).
+
+## Security & Compliance Requirements
+
+Backend PDF services are required when PDF documents or operations must adhere to strict security and compliance standards.
+
+Use server-side processing when:
+- PDF files must not be directly exposed to end users
+- Document access is restricted by enterprise security policies
+- Compliance with regulations such as HIPAA, GDPR, or SOC is required
+- Operations involve certificates, private keys, or confidential data
+- Centralized auditing, logging, or access control is mandatory
+
+In these scenarios, all sensitive PDF operations are executed within a controlled server environment.
+
+## Large-scale or resource-intensive processing
+
+Browser-based PDF processing is limited by device memory and CPU constraints. Backend services are recommended for:
+
+- Large PDF documents with high page counts
+- Complex PDFs containing heavy graphics or embedded assets
+- Batch or bulk operations such as merging, splitting, or text extraction
+
+Server-side processing ensures reliable execution and allows applications to scale without impacting client performance.
+
+## Performance & consistency on low-end devices
+
+PDF processing behavior can vary across browsers and hardware configurations. Server-backed services provide consistent behavior when:
+
+- Users access the application on low-end or older devices
+- Mobile or tablet environments are frequently used
+- Browser memory limits affect rendering or interactions
+
+In a server-backed setup, processing is performed on the server while the client focuses on rendering and user interaction.
+
+## Typical use cases
+
+A server-backed PDF viewer is commonly used in:
+
+- Enterprise document management systems
+- Internal applications with restricted document access
+- Banking, healthcare, and government solutions
+- High-volume or compliance-driven PDF workflows
+
+## Getting started with a server-backed PDF viewer
+
+If your application requires backend PDF services, refer to the following guide to configure and integrate a server-backed PDF viewer:
+
+[Getting started with server-backed React PDF Viewer](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/react/getting-started-with-server-backed)
+
+This guide covers backend service setup, required endpoints, and client-server configuration details.
+
+Use a **server-backed PDF viewer** when security, compliance, scalability, or performance consistency is critical. For lightweight viewing and basic interactions, a standalone client-side viewer may be sufficient.
+
+## See also
+
+- [Architecture of Syncfusion React PDF Viewer](./architecture-pdfviewer)
+- [How PDF Rendering Works in the Browser](./how-pdf-rendering-works-in-browser)
+- [Getting Started standalone PDF Viewer](../getting-started)
+- [Getting Started Server Backed PDF Viewer](../getting-started-with-server-backed)
+- [Standlone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
+

From 1fb5ef5076737e19fd08848e9f96631f3022cdf9 Mon Sep 17 00:00:00 2001
From: SF4524LogeshKumar <logeshkumar.dhamodharan@syncfusion.com>
Date: Wed, 18 Mar 2026 11:00:59 +0530
Subject: [PATCH 5/7] 1016259: Resolved CI failures

---
 .../architecture/pdf-standards-conformance.md |  6 ++---
 .../performance-model-for-large-pdfs.md       |  8 +++----
 .../self-hosted-on-prem-deployment.md         | 15 +++++++------
 .../when-backend-pdf-services-are-required.md | 22 +++++++++----------
 4 files changed, 26 insertions(+), 25 deletions(-)

diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/pdf-standards-conformance.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/pdf-standards-conformance.md
index 047a82160..94327bb71 100644
--- a/Document-Processing/PDF/PDF-Viewer/react/architecture/pdf-standards-conformance.md
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/pdf-standards-conformance.md
@@ -54,7 +54,7 @@ The React PDF Viewer's standards-based rendering capabilities are optimized for:
 - **Archival document access systems** – supporting long-term document preservation initiatives
 - **Compliance-driven environments** – enabling reliable viewing of standards-generated PDFs
 - **Interactive document review workflows** – facilitating annotation, collaboration, and feedback
-- **Healthcare and financial systems** – meeting industry standards for document handling
+- **Health-care and financial systems** – meeting industry standards for document handling
 - **Legal and regulatory platforms** – supporting document management with confidence
 
 ## Complementary solutions
@@ -89,6 +89,6 @@ By leveraging both components, you can build comprehensive document management s
 
 - [Architecture of Syncfusion React PDF Viewer](./architecture-pdfviewer)
 - [How PDF Rendering Works in the Browser](./how-pdf-rendering-works-in-browser)
-- [Standlone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
-- [When backend PDF services are required](./when-backend-pdf-services-are-required)
+- [Standalone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
+- [When backed PDF services are required](./when-backend-pdf-services-are-required)
 - [Self Hosted on](./self-hosted-on-prem-deployment)
\ No newline at end of file
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/performance-model-for-large-pdfs.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/performance-model-for-large-pdfs.md
index b04652c1c..6dda056a0 100644
--- a/Document-Processing/PDF/PDF-Viewer/react/architecture/performance-model-for-large-pdfs.md
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/performance-model-for-large-pdfs.md
@@ -17,7 +17,7 @@ It also provides guidance on where performance optimizations are already covered
 
 Rendering and interacting with large PDF documents requires careful handling of memory, CPU usage, and rendering pipelines. The React PDF Viewer follows a layered performance model that adapts based on the deployment mode and document complexity.
 
-With **version 31 and above**, significant performance improvements have been introduced—especially in **standalone (client-side) mode**—making the viewer capable of handling large PDFs efficiently without requiring backend services in many scenarios.
+With **version 31 and above**, significant performance improvements have been introduced—especially in **standalone (client-side) mode**—making the viewer capable of handling large PDFs efficiently without requiring back-end services in many scenarios.
 
 This page gives a high-level architectural view of these performance considerations.
 
@@ -54,7 +54,7 @@ For best practices including:
 - Local storage optimization
 - Annotation and form-field handling
 
-See [Load Large PDF Files in React PDF Viewer](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/react/load-large-pdf) to know more about Large PDF Handling.
+See [Load Large PDF Files in React PDF Viewer](../document-handling/load-large-pdf) to know more about Large PDF Handling.
 
 This performance model page complements that guide by describing *why* those optimizations work from an architectural perspective.
 
@@ -85,6 +85,6 @@ For implementation details and tuning, refer to the [Load Large PDF Files](../do
 
 - [Architecture of Syncfusion React PDF Viewer](./architecture-pdfviewer)
 - [How PDF Rendering Works in the Browser](./how-pdf-rendering-works-in-browser)
-- [Standlone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
-- [When backend PDF services are required](./when-backend-pdf-services-are-required)
+- [Standalone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
+- [When back-end PDF services are required](./when-backend-pdf-services-are-required)
 - [Self hosted on-prem Deployment](./self-hosted-on-prem-deployment)
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
index 6055a8efc..8e91a8ae5 100644
--- a/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
@@ -1,6 +1,7 @@
 ---
 layout: post
-title: Self-hosted / On-prem deployment in React PDF Viewer
+title: Self-hosted / On-prem deployment in React PDF Viewer | Syncfusion
+description: Learn here all about Self-hosted / On-prem deployment in Syncfusion React PDF Viewer and component.
 platform: document-processing
 documentation: ug
 control: PDF Viewer
@@ -21,7 +22,7 @@ Both **standalone (client-side)** and **server-backed** deployments can be hoste
 The React PDF Viewer does **not require any third‑party or Syncfusion‑managed cloud services** for production use:
 
 - PDF rendering and interaction can run fully in the browser (standalone mode)
-- Backend PDF services, if used, are hosted and controlled by your organization
+- Back-end PDF services, if used, are hosted and controlled by your organization
 - No document data is sent to Syncfusion servers
 - Licensing is not tied to runtime cloud usage
 
@@ -32,12 +33,12 @@ This makes the viewer suitable for **air‑gapped**, **intranet‑only**, and **
 In standalone mode, all PDF rendering and interactions are handled directly in the browser using local resources.
 
 Key characteristics:
-- No backend PDF service is required
+- No back-end PDF service is required
 - PDFs are processed entirely on the client device
 - Ideal for read‑only viewing and interactive use cases
 - Recommended for most applications
 
-N> We strongly recommend using the **standalone mode** whenever backend processing is not explicitly required.
+N> We strongly recommend using the **standalone mode** whenever back-end processing is not explicitly required.
 
 ## Server-backed deployment (self-hosted)
 
@@ -77,7 +78,7 @@ Self-hosted or on‑prem deployments are commonly used when:
 
 ## Summary
 
-The React PDF Viewer fully supports **self-hosted and on‑prem deployment models**. Whether used in standalone browser mode or with a self-hosted backend service, the viewer operates independently of any cloud services once licensed.
+The React PDF Viewer fully supports **self-hosted and on‑prem deployment models**. Whether used in standalone browser mode or with a self-hosted back-end service, the viewer operates independently of any cloud services once licensed.
 
 For most use cases, the standalone mode is sufficient and recommended. Server-backed deployment should be used only when specific server-side processing requirements exist.
 
@@ -87,5 +88,5 @@ For most use cases, the standalone mode is sufficient and recommended. Server-ba
 - [How PDF Rendering Works in the Browser](./how-pdf-rendering-works-in-browser)
 - [Getting Started standalone PDF Viewer](../getting-started)
 - [Getting Started Server Backed PDF Viewer](../getting-started-with-server-backed)
-- [Standlone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
-- [When Backend PDF Viewer are required](./when-backend-pdf-services-are-required)
\ No newline at end of file
+- [Standalone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
+- [When Back-end PDF Viewer are required](./when-backend-pdf-services-are-required)
\ No newline at end of file
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/when-backend-pdf-services-are-required.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/when-backend-pdf-services-are-required.md
index 04b7365c1..944e37b62 100644
--- a/Document-Processing/PDF/PDF-Viewer/react/architecture/when-backend-pdf-services-are-required.md
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/when-backend-pdf-services-are-required.md
@@ -1,25 +1,25 @@
 ---
 layout: post
-title: When backend PDF services are required | Syncfusion
-description: Learn here all about when and why backend (server-side) PDF services are required in Syncfusion React PDF Viewer.
+title: When back-end PDF services are required | Syncfusion
+description: Learn here all about when and why back-end (server-side) PDF services are required in Syncfusion React PDF Viewer.
 platform: document-processing
 documentation: ug
 control: PDF Viewer
 ---
 
-# When backend PDF services are required
+# When back-end PDF services are required
 
-This section explains **when and why backend (server-side) PDF services are required** for the React PDF Viewer and helps you decide whether a server-backed architecture is necessary for your application.
+This section explains **when and why back-end (server-side) PDF services are required** for the React PDF Viewer and helps you decide whether a server-backed architecture is necessary for your application.
 
 ## Overview
 
-The React PDF Viewer can operate entirely in the browser using a [standalone](../getting-started) (client-side) architecture. However, certain functional, security, and performance requirements make it necessary to process PDF operations on a backend server.
+The React PDF Viewer can operate entirely in the browser using a [standalone](../getting-started) (client-side) architecture. However, certain functional, security, and performance requirements make it necessary to process PDF operations on a back-end server.
 
 This page outlines the key decision factors for selecting a [server-backed PDF viewer](../getting-started-with-server-backed).
 
 ## Security & Compliance Requirements
 
-Backend PDF services are required when PDF documents or operations must adhere to strict security and compliance standards.
+back-end PDF services are required when PDF documents or operations must adhere to strict security and compliance standards.
 
 Use server-side processing when:
 - PDF files must not be directly exposed to end users
@@ -32,7 +32,7 @@ In these scenarios, all sensitive PDF operations are executed within a controlle
 
 ## Large-scale or resource-intensive processing
 
-Browser-based PDF processing is limited by device memory and CPU constraints. Backend services are recommended for:
+Browser-based PDF processing is limited by device memory and CPU constraints. back-end services are recommended for:
 
 - Large PDF documents with high page counts
 - Complex PDFs containing heavy graphics or embedded assets
@@ -56,16 +56,16 @@ A server-backed PDF viewer is commonly used in:
 
 - Enterprise document management systems
 - Internal applications with restricted document access
-- Banking, healthcare, and government solutions
+- Banking, health-care, and government solutions
 - High-volume or compliance-driven PDF workflows
 
 ## Getting started with a server-backed PDF viewer
 
-If your application requires backend PDF services, refer to the following guide to configure and integrate a server-backed PDF viewer:
+If your application requires back-end PDF services, refer to the following guide to configure and integrate a server-backed PDF viewer:
 
 [Getting started with server-backed React PDF Viewer](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/react/getting-started-with-server-backed)
 
-This guide covers backend service setup, required endpoints, and client-server configuration details.
+This guide covers back-end service setup, required endpoints, and client-server configuration details.
 
 Use a **server-backed PDF viewer** when security, compliance, scalability, or performance consistency is critical. For lightweight viewing and basic interactions, a standalone client-side viewer may be sufficient.
 
@@ -75,5 +75,5 @@ Use a **server-backed PDF viewer** when security, compliance, scalability, or pe
 - [How PDF Rendering Works in the Browser](./how-pdf-rendering-works-in-browser)
 - [Getting Started standalone PDF Viewer](../getting-started)
 - [Getting Started Server Backed PDF Viewer](../getting-started-with-server-backed)
-- [Standlone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
+- [Standalone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
 

From 5a9ef425fcc2e401fb48f6cddff5d9857713d4a0 Mon Sep 17 00:00:00 2001
From: SF4524LogeshKumar <logeshkumar.dhamodharan@syncfusion.com>
Date: Wed, 18 Mar 2026 12:46:57 +0530
Subject: [PATCH 6/7] 1016259: Resolved CI failures

---
 .../architecture/performance-model-for-large-pdfs.md      | 2 +-
 .../react/architecture/self-hosted-on-prem-deployment.md  | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/performance-model-for-large-pdfs.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/performance-model-for-large-pdfs.md
index 6dda056a0..88b70919c 100644
--- a/Document-Processing/PDF/PDF-Viewer/react/architecture/performance-model-for-large-pdfs.md
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/performance-model-for-large-pdfs.md
@@ -87,4 +87,4 @@ For implementation details and tuning, refer to the [Load Large PDF Files](../do
 - [How PDF Rendering Works in the Browser](./how-pdf-rendering-works-in-browser)
 - [Standalone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
 - [When back-end PDF services are required](./when-backend-pdf-services-are-required)
-- [Self hosted on-prem Deployment](./self-hosted-on-prem-deployment)
+- [Self hosted on-premises Deployment](./self-hosted-on-prem-deployment)
diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
index 8e91a8ae5..74a6657aa 100644
--- a/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
@@ -1,13 +1,13 @@
 ---
 layout: post
-title: Self-hosted / On-prem deployment in React PDF Viewer | Syncfusion
-description: Learn here all about Self-hosted / On-prem deployment in Syncfusion React PDF Viewer and component.
+title: Self-hosted / On-premises deployment in React PDF Viewer | Syncfusion
+description: Learn here all about Self-hosted / On-premises deployment in Syncfusion React PDF Viewer and component.
 platform: document-processing
 documentation: ug
 control: PDF Viewer
 ---
 
-# Self-hosted / On-prem deployment in React PDF Viewer
+# Self-hosted / On-premises deployment in React PDF Viewer
 
 This section explains how the Syncfusion React PDF Viewer supports **self-hosted (on‑premises) deployment** and clarifies how the component operates without any dependency on cloud services.
 
@@ -66,7 +66,7 @@ This gives you full control over:
 - Infrastructure
 - Security policies
 - Data access and storage
-- Deployment lifecycle
+- Deployment life-cycle
 
 ## Typical self-hosted deployment scenarios
 

From f0a09f575155fa1d943c593e4de3bd52109641c7 Mon Sep 17 00:00:00 2001
From: SF4524LogeshKumar <logeshkumar.dhamodharan@syncfusion.com>
Date: Wed, 18 Mar 2026 12:53:37 +0530
Subject: [PATCH 7/7] 1016259: Resolved CI failure

---
 .../react/architecture/self-hosted-on-prem-deployment.md      | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md b/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
index 74a6657aa..bf67064b0 100644
--- a/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
@@ -70,7 +70,7 @@ This gives you full control over:
 
 ## Typical self-hosted deployment scenarios
 
-Self-hosted or on‑prem deployments are commonly used when:
+Self-hosted or on‑premises deployments are commonly used when:
 - Documents must remain within internal networks
 - Regulatory or compliance requirements restrict cloud usage
 - Applications are deployed on private servers or data centers
@@ -78,7 +78,7 @@ Self-hosted or on‑prem deployments are commonly used when:
 
 ## Summary
 
-The React PDF Viewer fully supports **self-hosted and on‑prem deployment models**. Whether used in standalone browser mode or with a self-hosted back-end service, the viewer operates independently of any cloud services once licensed.
+The React PDF Viewer fully supports **self-hosted and on‑premises deployment models**. Whether used in standalone browser mode or with a self-hosted back-end service, the viewer operates independently of any cloud services once licensed.
 
 For most use cases, the standalone mode is sufficient and recommended. Server-backed deployment should be used only when specific server-side processing requirements exist.