diff --git a/Document-Processing-toc.html b/Document-Processing-toc.html
index 7816b464a..ab65c6e35 100644
--- a/Document-Processing-toc.html
+++ b/Document-Processing-toc.html
@@ -991,6 +991,17 @@
with Server-Backed PDF Viewer
+ Architecture
+
+
Environment Integration
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..261585a43
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/architecture-pdfviewer.md
@@ -0,0 +1,90 @@
+---
+layout: post
+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
+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, form filling, digital signature creation, and import/export operations directly in the browser. The client provides a smooth, zero-latency user experience for common operations like navigation, zooming, markup, and lightweight document export/import.
+
+- **Server-side layer**: Optional back-end services (via `serviceUrl`) that enable advanced or heavy-weight features such as OCR, document conversions (DOCX/Excel/PowerPoint to PDF), digital signature validation, encryption/decryption and extensive document preprocessing using the Syncfusion PDF Library.
+
+**Key Technology Stack:**
+- **PDFium**: Google's open-source PDF rendering and manipulation engine used for rasterization on the client. We use PDFium for PDF to image conversion alone.
+- **Syncfusion PDF Library**: Server-side library for advanced document processing, preprocessing, Embedded Text extraction, Metadata, Annotation, Form fields data, export operations Parsing and Rasterization.
+
+## 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:
+
+- **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 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 Worker** – Uses `PDFium` to rasterize individual PDF pages into visual page images for display. Page rasterization is performed off the main thread to ensure smooth scrolling and a responsive user interface. All higher‑level document processing, including text extraction, annotations, form handling, and UI behavior, is managed separately by the `Syncfusion PDF Library` and viewer logic.
+
+- **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, it is processed to build an internal data model that supports rendering and user interaction in the viewer. PDFium is used only to rasterize pages into images, while all document parsing and data modeling is handled by the Syncfusion PDF Library.
+
+This internal data model acts as the foundation for features such as text selection, search, annotations, forms, and accessibility.
+
+**Key aspects of the data model:**
+
+ - **Page representation**: Each page is represented as an image for rendering; extracted text, vector commands and other resources are provided as separate layers for search, accessibility, annotations, and form overlays.
+- **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.
+
+## 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 viewing, annotations, and form interactions occur on the client, with page rendering handled locally and document logic managed by the viewer and PDF Library.
+- 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.
+
+## 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](https://help.syncfusion.com/document-processing/pdf/pdf-library/javascript/overview) – 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..422ab61d0
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/how-pdf-rendering-works-in-browser.md
@@ -0,0 +1,109 @@
+---
+layout: post
+title: How PDF Rendering Works in the Browser in React | Syncfusion
+description: Understand how PDF documents are parsed, rasterized, and displayed in the browser using the Syncfusion React PDF Viewer.
+platform: document-processing
+control: PDF Viewer
+documentation: ug
+---
+
+# How PDF Rendering Works in the Browser
+
+Rendering a PDF in the browser involves converting a structured PDF document into visual and interactive content that users can view and work with. The Syncfusion React PDF Viewer uses a combination of **PDFium**, [Syncfusion PDF Library](https://help.syncfusion.com/document-processing/pdf/pdf-library/javascript/overview), and viewer-side logic to achieve accurate rendering, smooth interactions, and scalable performance.
+
+This page explains the **conceptual rendering flow** used by the viewer, focusing on responsibilities and data flow rather than low-level engine internals.
+
+## Overview of the Rendering Pipeline
+
+PDF rendering in the browser follows a staged pipeline:
+
+**PDF Loading → Parsing & Processing → Page Rasterization → Layer Composition → User Interaction**
+
+Each stage is designed to isolate responsibilities and ensure responsiveness, even for large or complex documents.
+
+## 1. PDF Loading and Parsing
+
+When a PDF document is opened in the viewer:
+
+- The PDF file is loaded from a URL, local file, or streamed source.
+- The document structure (pages, objects, and resources) is parsed.
+- Parsing and document-level processing are handled using the [Syncfusion PDF Library](https://help.syncfusion.com/document-processing/pdf/pdf-library/javascript/overview).
+
+Large documents are processed incrementally so that initial pages can be displayed without waiting for the entire document to be parsed.
+
+## 2. Document and Resource Processing
+
+After parsing, the **Syncfusion PDF Library** manages document-level features and metadata, including:
+
+- Text extraction and layout information
+- Annotation data (highlights, shapes, comments, stamps)
+- Form fields and form data
+- Document structure and page hierarchy
+
+This processing stage prepares the data required for rendering and interaction but does not generate visual output.
+
+## 3. Page Rasterization (PDFium)
+
+Visual rendering of PDF pages is performed using **PDFium**, which is used **exclusively to rasterize pages into images**.
+
+The rasterization process works as follows:
+
+- Individual pages are passed to PDFium for rendering.
+- PDFium converts each page into a raster image at the required resolution.
+- The generated image is returned to the viewer for display.
+
+Rendering is **DPI-aware**, ensuring sharp output across standard and high‑resolution displays. Page images may be cached and reused during scrolling or zooming to improve performance.
+
+N> PDFium is used only for **page-to-image rendering**. It is not responsible for text extraction, annotations, form logic, or UI behavior.
+
+
+## 4. Rendering and Interaction Layers
+
+Once a page image is generated, the viewer composes the final output using multiple viewer-managed layers:
+
+- **Page Image Layer**
+ The page image produced by PDFium after rasterization. This serves as the visual base of the page.
+
+- **Text Layer**
+ Generated using data from the **Syncfusion PDF Library** and viewer logic. This invisible layer enables text selection, search, and copy‑paste while aligning precisely with the page image.
+
+- **Annotation and Form Layer**
+ Managed entirely by the **PDF Library and viewer**. This layer supports annotations, highlights, comments, and interactive form fields.
+
+- **UI Layer**
+ Viewer interface elements such as toolbars, thumbnails, navigation controls, and dialogs.
+
+This layered approach allows interactive elements to update independently without requiring page images to be re-rendered.
+
+## 5. Processing Model and Thread Usage
+
+PDF rendering and processing involve CPU-intensive operations. To maintain UI responsiveness:
+
+- **PDFium rasterization** is typically executed in **Web Workers**.
+- **PDF Library processing** (text, annotations, form data) is coordinated by viewer logic.
+- The main thread is responsible for DOM updates and handling user interactions.
+
+
+## 6. Lazy Rendering and Performance Optimization
+
+To efficiently handle large PDF documents:
+
+- Only pages that are visible in the viewport undergo rasterization and are displayed initially.
+- Additional pages are rendered on demand as the user scrolls or navigates.
+- Previously rendered page images may be reused when possible.
+
+This lazy rendering approach reduces memory usage and improves performance across devices.
+
+## Summary
+
+The Syncfusion React PDF Viewer renders PDF documents in the browser using a clear separation of responsibilities. The **Syncfusion PDF Library** handles document parsing, text extraction, annotations, and form logic, while **PDFium** is used solely to rasterize pages into images. Viewer-managed layers and lazy rendering ensure smooth interaction, accurate visuals, and scalable performance for documents of all sizes.
+
+---
+
+## See Also
+
+- [Architecture of Syncfusion React PDF Viewer](../architecture/architecture-pdfviewer)
+- [Loading PDF Documents](../open-pdf-files)
+- [Working with Annotations](../annotation/overview)
+- [PDF Forms in React PDF Viewer](../forms/overview)
+- [Syncfusion PDF Library Overview](../../../PDF-Library/overview)
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..9a86d44d4
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/pdf-standards-conformance.md
@@ -0,0 +1,97 @@
+---
+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
+
+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 and conversion** in server side as part of the document preparation pipeline.
+
+N> Check on [PDF Library Conformance Guide](https://help.syncfusion.com/document-processing/pdf/pdf-library/net/working-with-pdf-conformance) to know more about conformance and standards handling.
+
+## 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.
+- **Health-care 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 print-optimized 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 features
+- Form field interaction
+
+**Syncfusion PDF Library** – Advanced PDF processing
+- Create and generate PDF documents
+- Convert documents to PDF/A standards in server side.
+- Add digital signatures and security
+- Validate PDF compliance
+
+N> Check the [PDF Library UG Guide](https://help.syncfusion.com/document-processing/pdf/pdf-library/net/working-with-pdf-conformance#pdf-to-pdfa-conversion) to know more about PDF/A conversion.
+
+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)
+- [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
new file mode 100644
index 000000000..88b70919c
--- /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 back-end 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](../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.
+
+## 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)
+- [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-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
new file mode 100644
index 000000000..bf67064b0
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/react/architecture/self-hosted-on-prem-deployment.md
@@ -0,0 +1,92 @@
+---
+layout: post
+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-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.
+
+## 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)
+- 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
+
+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 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 back-end 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 life-cycle
+
+## Typical self-hosted deployment scenarios
+
+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
+- Internal document management or enterprise portals are involved
+
+## Summary
+
+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.
+
+## 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)
+- [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/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..bc032f5a8
--- /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 | 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
+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 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.
+
+## 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 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 |
+
+## 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 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
+
+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/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..944e37b62
--- /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 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 back-end PDF services are required
+
+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 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
+
+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
+- 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. back-end 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, health-care, and government solutions
+- High-volume or compliance-driven PDF workflows
+
+## Getting started with 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 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.
+
+## 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)
+- [Standalone vs Server Backed PDF Viewer](./standalone-vs-server-backed-pdf-viewer)
+
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 000000000..46dc86f5e
Binary files /dev/null and b/Document-Processing/PDF/PDF-Viewer/react/images/high-level-components.png differ
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 000000000..ef9d51853
Binary files /dev/null and b/Document-Processing/PDF/PDF-Viewer/react/images/worker-message-flow.png differ