---
title: "AI document automation workflows: From extraction to action"
canonical_url: "https://www.nutrient.io/blog/ai-document-automation-extraction-to-action/"
md_url: "https://www.nutrient.io/blog/ai-document-automation-extraction-to-action.md"
last_updated: "2026-06-15T16:32:07.815Z"
description: "AI document automation is more than extraction. Validation, routing, approvals, and downstream actions are where pipelines stall. A decision framework for 2026."
---

**TL;DR**

- **Pulling data out of a document is the easy part.** What happens next is harder: validation, routing, approvals, and the downstream systems that close the loop.

- **Most “AI document automation” projects stall at the action layer.** Extraction works in a demo; nobody owns what happens when a field is ambiguous, a value is out of range, or a document is misclassified.

- **Reliable pipelines run three layers:** extraction (perception), decision (validation, routing, human-in-the-loop), and action (workflow execution and integration). Pick the wrong tool for decision and action and you’re back to scripting glue.

- **The buyer question isn’t “which AI is best?”** It’s “which workflow am I automating, and where does AI fit in?” The workflow is the product. AI is a feeder.

Most AI document automation demos are impressive. A model parses vendor name, total, line items, and dates out of an invoice in a few seconds, and the conversation usually ends there. In production, that’s where the real work starts.

What happens to the extracted fields? Who validates them? What happens when an invoice total exceeds an approval threshold, the vendor isn’t in the master data list, the model returns a confidence score below your tolerance, or the document type was misclassified? Every one of those questions is an action — a decision that has to fire, a person who has to be looped in, a downstream system that has to receive the result.

The buyer question — “how do we automate decisions?” — isn’t answered by a better optical character recognition (OCR) engine. The architecture that turns extracted data into completed work matters more than the model behind extraction. Agentic AI is reshaping how documents flow through enterprise systems in 2026, but the gains depend on what happens *after* extraction, not on the perception layer itself.

## What is AI document automation?

AI document automation uses intelligent document processing (IDP), large language models (LLMs), and AI agents to turn unstructured files — PDFs, emails, scanned forms, images — into structured data that drives downstream work. It replaces the manual loop of data entry, classification, routing, and approvals that document-heavy workflows used to depend on, cutting processing time and error rates while making compliance traceable.

In a working pipeline, four capabilities have to line up.

### 1. Intelligent capture and classification

The first step goes beyond raw [OCR](https://www.nutrient.io/sdk/ocr/). The system has to identify the document type — invoice, contract, claim, ID — without depending on rigid templates, and read text from scanned pages, photographs, and mixed-language documents. Modern capture combines OCR with layout-aware models so structure (tables, signatures, headers) survives the transition into structured data.

### 2. Data extraction and validation

LLM-based and intelligent content recognition (ICR) models extract specific fields — vendor, total, due date, signatory — and emit per-field confidence. Common patterns include [key-value pair extraction](https://www.nutrient.io/blog/extract-key-value-pairs-programmatically/) for structured fields and table extraction for line items. Validation rules check those fields against master data, business rules, and other systems of record before they propagate. Without validation, you ship confident-looking values that fail downstream.

### 3. Agentic processing

AI agents chain extraction, decision, and action into one runtime: Read an invoice, match it against a PO, post the result to the ERP, and email the vendor — driven by natural-language instructions rather than hand-coded scripts. The agent layer is where 2026’s gains are concentrated, but it depends on the perception and decision layers underneath being right.

### 4. Intelligent routing

Classification, confidence, and business rules together decide where each document goes: which approver, which queue, which downstream system. Documents below confidence thresholds route to human review with the document and extracted fields visible in one place. Above thresholds, they auto-process.

A few claims are worth retiring before you start evaluating vendors:

- **AI replaces business logic.** It doesn’t. AI extracts and classifies; rules, schemas, and human review still drive the decision.

- **One workflow handles every document type.** Invoices, contracts, claims, and onboarding forms each have different validation, routing, and integration shapes. A platform that pretends it’s one workflow ends up with the worst of all four.

- **End-to-end automation means no humans.** The right answer is selective human review on the cases where the cost of being wrong is high, not a fully automated pipeline that quietly produces bad data.

- **Extraction accuracy is the metric.** Pipeline-level metrics — first-pass automation rate, exception rate, time-to-resolve — matter more than field-level accuracy in isolation.

## How AI document automation projects actually fail in production

The demo is about 20 percent of the work. The other 80 percent shows up as a small set of recurring failure modes — none of which appear in vendor pitches:

- **The pilot worked, but then the second document type doubled the maintenance cost.** The demo handled one vendor’s invoice layout. Production has 200, and each new one breaks routing assumptions hard-coded into the extraction script.

- **Confidence scores existed, but nobody wired them into routing.** The model emitted per-field confidence; nothing read it. Low-confidence values reached the ERP alongside high-confidence ones — discovered during a finance audit, not from monitoring.

- **Validation was syntactic, not semantic.** The “total” field had a number, but it didn’t reconcile with the line items. The “vendor name” was a valid string, but not one in the approved supplier list.

- **Human review was a queue with no SLA.** Exceptions piled up faster than throughput because nobody owned the queue. Reviewers had three browser tabs and a spreadsheet — not the document, fields, and correction interface in one screen.

- **Routing logic was tribal knowledge.** Invoices more than $10K to one approver, non-standard contracts to legal, regional claims to a regional handler — none of which lived in the system. It lived in the operations lead’s head, but they left.

- **The integration was “phase 2” and stayed that way.** Every workflow ends in a write to another system: ERP, CRM, signature platform, ticketing. “We’ll integrate later” is how pilots stay pilots forever.

The pattern: Each failure mode is owned by a different product than the one that did the extraction. Pipelines stall because no one owns the seams between them. Nutrient is built around these seams — extraction with [Nutrient AI Document Processing](https://www.nutrient.io/sdk/ai-document-processing/), and decision and action with [Nutrient Workflow Automation](https://www.nutrient.io/workflow-automation/), all on one platform.

## The architecture that works

Reliable end-to-end document automation has three layers.![Three-layer AI document automation architecture: documents flow into Extraction (perception, OCR/ICR/VLM, classification, per-field confidence), then into Decision (validation, schema checks, confidence-based routing, human-in-the-loop), then into Action (workflow execution, approvals, signing, ERP/CRM integrations, notifications). A validation layer runs across all three layers.](@/assets/images/blog/2026/ai-document-automation-extraction-to-action/three-layer-architecture.png)

**Layer 1 — Extraction (perception):** This layer handles OCR, classification, key-value extraction, and table extraction. The output is structured data plus per-field confidence scores. The tools here include [Nutrient AI Document Processing](https://www.nutrient.io/sdk/ai-document-processing/), [Nutrient Vision API](https://www.nutrient.io/api/vision-api/) (OCR through VLM-based layout analysis), traditional OCR, and IDP services. This is the layer most vendors talk about.

Try the classification and extraction step yourself in the AI Document Processing demo.

**Layer 2 — Decision (validation and routing):** Schemas constrain the extraction output. Validation rules check semantic correctness — does the total reconcile, is the vendor approved, is the date in range? Confidence thresholds determine which records auto-process and which route to a human. Routing logic maps documents to the right downstream owner. The tools here include [Nutrient Workflow Automation](https://www.nutrient.io/workflow-automation/), schema validation libraries, and custom rule engines.

**Layer 3 — Action (workflow execution):** The decision layer’s output triggers something — an approval task in a queue, a signature request, a record write to an ERP, a notification, a follow-up workflow. This is where the buyer’s “automate decisions” question gets answered. The tools here include Nutrient Workflow Automation, robotic process automation (RPA) platforms (for UI-only systems), and custom integration code.

Most AI document automation products are strong on Layer 1 and weak on Layers 2 and 3, leaving teams to glue them together with custom code. The platforms that close the loop treat all three layers as one product surface.

### Tradeoffs at a glance

| Layer      | What it does                                  | Failure mode if missing                                     | Owner skill         |
| ---------- | --------------------------------------------- | ----------------------------------------------------------- | ------------------- |
| Extraction | Turns documents into structured fields        | Garbage into the rest of the pipeline                       | ML/data engineering |
| Decision   | Validates, scores, routes, and escalates      | Wrong values reach downstream systems silently              | Process owner       |
| Action     | Executes tasks and writes to downstream tools | Pipeline ends at JSON; humans copy-paste it into other apps | Workflow/operations |

The further down the stack, the higher the cost of a failure — and the further the typical AI demo gets from showing it.

### A worked example: Invoice arrives → posted to ERP

To make the seams concrete, here’s what one document looks like end to end:

1. **Ingest.** An invoice arrives in a shared inbox. Workflow Automation picks it up and routes it to the extraction service.

2. **Extract.** AI Document Processing returns vendor name, total, line items, due date, and per-field confidence. Vendor name confidence: 0.82.

3. **Validate.** Schema check passes (total is numeric, date parses). Business-rule check fails: vendor name doesn’t exactly match the approved supplier list. Total reconciles against line items.

4. **Decide.** Confidence on vendor name is below the 0.90 threshold *and* validation failed. Workflow Automation routes the document to the AP clerk’s review queue with the document, the extracted fields, and the validation failure flagged.

5. **Human review.** The clerk sees “Acme Logistics LLC” extracted, recognizes it as “Acme Logistics, LLC” in the master list, corrects the field, and submits.

6. **Revalidate.** Vendor now matches. Workflow proceeds.

7. **Approve.** Total is $14,230 — more than the $10,000 threshold. Workflow routes to the department head for approval. They approve in the mobile app.

8. **Act.** Workflow Automation posts to the ERP via integration, attaches the source PDF, closes the matching PO, and notifies the requester.

Every step has an owner and a fallback. No step is “we’ll add it later.”

### See it in action

**Featured Content**

**Build this pipeline on Nutrient**

AI Document Processing for extraction, Workflow Automation for routing and approvals — one platform, no glue code.

[Start free trial](https://www.nutrient.io/try/)

## A decision framework for buyers

Before evaluating vendors, answer these four questions. The right architecture follows from the answers — not from the demo.

**1. Where do extracted documents need to end up?**

If the answer is “we read the JSON and copy values into our ERP,” you don’t have an automation pipeline; you have a faster manual workflow. The integration surface — ERP, CRM, signature, content store, ticketing — needs to be specified before you pick an extraction vendor. Tools that can’t write into your downstream systems leave the last mile to you.

**2. What percentage of documents need human review?**

This is a planning constraint, not a quality metric. If 30 percent of your invoices have non-standard layouts that drop below confidence thresholds, you need a review queue, an interface, and an SLA — not a vendor promise of “95 percent accuracy.” The review layer is the difference between a pipeline that runs and one that requires a babysitter.

**3. How complex is your routing and approval logic?**

Two-stage approvals are easy. Branching by amount, vendor, geography, document type, and exception state is not. If your real workflow has more than three branches, you need a workflow engine, not an extraction API with a couple of webhook hooks.

**4. What does compliance require to stay inside your perimeter?**

For regulated workflows, the answer often rules out cloud-only vendors. Self-hosted deployment, audit trails on every decision, and data residency controls are prerequisites, not optional add-ons. The architecture has to support them at every layer, not just at extraction.

## What to ask vendors before you buy

Vendor demos all look the same — happy-path extraction on a clean document. The interesting questions are about the unhappy path. Here are six questions to bring to every evaluation:

1. **Show me a low-confidence extraction. What does the user see?** A vendor that can’t show this is hiding the review interface (or doesn’t have one).

2. **Can you walk me through your review queue end to end?** Document, extracted fields, correction interface, send-back-to-pipeline — all in one screen, or three tabs and a spreadsheet?

3. **Can a process owner change routing logic without redeploying code?** If routing lives in the extraction script, every threshold change is an engineering ticket.

4. **What happens when the model misclassifies a document type?** “It doesn’t” is the wrong answer. The right one is a defined recovery path.

5. **How do exceptions get back into the pipeline after human correction?** If the answer involves CSV exports, you’ll be writing the integration yourself.

6. **Can you show me your integration with [your specific ERP/CRM/signature platform]?** “Yes we integrate with that” and “here’s a working integration to that” are different sentences.

The honest demos answer all six without flinching. The rest end at the JSON.

## Common use cases

The same three-layer pattern shows up across departments. The shape of the workflow changes; the seam between extraction and action doesn’t.

### Finance and invoicing

[Invoice processing](https://www.nutrient.io/blog/invoice-processing-automation/) is the canonical use case. Documents arrive from hundreds of vendors in a mix of layouts. Extraction pulls vendor, total, line items, and dates; validation checks against the master vendor list and matches the line items to a purchase order; routing sends the document to the right approver based on amount and department; the pipeline posts the result to the ERP and closes the PO. Reducing manual [AP touch](https://www.nutrient.io/blog/ap-automation-requirements/) is the metric most teams optimize against. **Nutrient fit:** AI Document Processing handles invoice parsing, and Workflow Automation handles AP approval routing.

### Legal and compliance

Contract review, clause extraction, and [redaction](https://www.nutrient.io/sdk/redaction/) sit on top of the same pipeline. Extraction identifies parties, effective dates, renewal terms, and non-standard clauses; validation flags anything outside template language; routing sends ambiguous contracts to legal. Redaction workflows add a discovery step that finds and obscures sensitive identifiers before documents leave the perimeter. **Nutrient fit:** AI Document Processing handles clause extraction and personally identifiable information (PII) detection, Workflow Automation runs the legal review queues, and Document Engine covers self-hosted deployment.

### HR and onboarding

Resume parsing, [employee onboarding documents](https://www.nutrient.io/blog/benefits-automating-workflows-hr-department/), ID verification, and benefit forms all fit the pattern. Extraction pulls structured fields out of free-form documents (resumes, signed offer letters); validation checks against HRIS records; routing distributes to the right team — recruiting, IT provisioning, payroll. The volume per document is low, but the workflow surface (form proliferation, downstream integration) is wide. **Nutrient fit:** Workflow Automation runs the HR-side process, and AI Document Processing handles resume and form parsing.

### Sales operations

Proposal generation, order documents, and customer-supplied forms benefit from the inverse of extraction: Structured data from a CRM gets composed into branded documents, sent for review, and signed. The decision and action layers (routing, approvals, eSignature) are the same architecture, even when the document is being *generated* rather than parsed. **Nutrient fit:** Workflow Automation handles proposal routing and approvals, with built-in document generation and eSignatures.

### Customer support and back office

Ticket triage, claims intake, KYC document handling — anywhere a document arrives, gets classified, and triggers downstream work. The unifying constraint is that the workflow has to handle exceptions visibly. Pipelines that hide failures are pipelines that fail their first audit. **Nutrient fit:** AI Document Processing handles ID and form parsing, and Workflow Automation runs the case-management workflow with audit logging.

## AI document automation vs. RPA: When each fits

RPA platforms (UiPath, Automation Anywhere, Blue Prism) automate user interface interactions — they click through screens a human would click through. They don’t extract from documents natively; they call out to a separate AI service for that. RPA is a fit when most of your work is moving data between two systems that already render it onscreen.

AI document automation inverts that model. The pipeline reads, classifies, validates, decides, and acts on documents directly — the UI is incidental. The seam between perception and action lives inside one platform instead of being stitched together with bots.

The practical decision: If your workflow is “extract from documents, then act,” AI document automation is the architecture; RPA is what you reach for when the system you have to integrate with has no API. Most production deployments end up with both, with clear boundaries between them.

## Why Nutrient for AI document automation

Real document workflows run into the same handful of problems:

- Extraction that works in the demo but breaks on real documents

- Validation rules that no one wants to maintain

- Approval logic hard-coded into a script that breaks every quarter

- Integration glue that nobody wants to own

- Compliance reviews that stall deployment for months

Nutrient is built around the full chain — not just the extraction step. The three products map directly to the three layers above.

**Stop stitching extraction to a workflow engine yourself.** [Nutrient Workflow Automation](https://www.nutrient.io/workflow-automation/) handles the decision and action layers natively — routing, conditional branching, approvals, escalations, and integration are configurable, not code. The output of [Nutrient AI Document Processing](https://www.nutrient.io/sdk/ai-document-processing/) flows into a workflow without a custom integration layer between them.

**Catch validation failures before they reach downstream systems.** AI Document Processing emits per-field confidence and supports schema-constrained extraction, so the decision layer has the signals it needs to route exceptions. Workflow Automation surfaces those exceptions as review tasks instead of letting bad values cascade through to your ERP.

**Keep sensitive workflows inside your perimeter.** Contracts, claims, and onboarding forms can’t always transit a third-party server. AI Document Processing runs every engine on your infrastructure — cloud LLMs are an optional connection, not a default. Workflow Automation supports private-cloud, on-premises, and hybrid deployments. [Nutrient Document Engine](https://www.nutrient.io/sdk/document-engine/) self-hosts the document backend as a Docker-ready server.

**Configure the workflow instead of writing it.** Most automation platforms ask you to either accept a black box workflow or write the orchestration code yourself. Workflow Automation gives you a configurable workflow surface — build it once in the UI, version it, and iterate without redeploying.

**Treat the workflow as the product, not the extraction.** The AI extraction step is a perception layer feeding a workflow that owns the actual business logic. That’s the inversion most buyers need: The workflow is what they’re automating; the AI is the input.

### The three products

**Extraction — [Nutrient AI Document Processing](https://www.nutrient.io/sdk/ai-document-processing/)**

It performs OCR, classification, key-value extraction, and table extraction with validation. Schemas, confidence scoring, and human-review hooks are built in. It runs on your infrastructure as a self-hosted REST microservice or embedded SDK, and cloud LLM providers are an optional connection, not a default.

**Decision and action — [Nutrient Workflow Automation](https://www.nutrient.io/workflow-automation/)**

It’s a low-code workflow platform with a drag-and-drop process builder, conditional routing, parallel approvals, SLA tracking, audit logging, and native integration. This is the layer where extraction output becomes completed work.

**Self-hosted backbone — [Nutrient Document Engine](https://www.nutrient.io/sdk/document-engine/)**

It’s a Docker-ready server for self-hosted document infrastructure. It’s the deployment story when compliance rules out cloud.

| Product                | Cloud SaaS | Private cloud/on-premises | Embedded SDK |
| ---------------------- | ---------- | ------------------------- | ------------ |
| AI Document Processing | —          | Yes                       | Yes          |
| Workflow Automation    | Yes        | Yes                       | —            |
| Document Engine        | —          | Yes                       | —            |

The [free trial](https://www.nutrient.io/try/) gives you access to the platform before you commit.

## FAQ

#### What’s the difference between document AI and document workflow automation?

Document AI extracts fields from a document. Document workflow automation handles what happens to those fields next — validation, routing, approvals, and triggering downstream systems. Most failed automation projects buy document AI and discover too late that the workflow side is still manual.

#### Do I need a separate workflow engine on top of an extraction API?

If your workflow has more than a couple of conditional branches, yes. Hard-coding routing and approvals into the same script that calls the extraction API mixes concerns that change at different rates. A workflow engine lets process owners change routing without redeploying code.

#### When is human-in-the-loop review needed?

Human-in-the-loop review is needed whenever the cost of a wrong value is higher than the cost of a person looking at it. For invoices above an approval threshold, contracts with non-standard clauses, or fields with confidence below tolerance, human review pays for itself by preventing downstream errors. The review *interface* is what most extraction-only tools don’t ship.

#### Can document automation pipelines run on-premises?

Yes — but every layer has to support it. AI Document Processing offers on-prem REST and embedded SDK. Workflow Automation supports on-premises and private cloud. Document Engine self-hosts the backend. If a vendor only supports cloud at any layer, your data crosses that boundary regardless.

#### How do I measure success for an AI document automation pipeline?

Measure success with pipeline-level metrics, not field-level accuracy. First-pass automation rate (how many documents process without human touch), exception rate, time-to-resolve, and downstream error rate matter more than the model’s accuracy on a benchmark. A 99 percent accurate model that requires human review on 30 percent of documents is a worse pipeline than a 95 percent accurate one that auto-processes 90 percent.

#### How does Nutrient compare to RPA platforms like UiPath or Automation Anywhere?

RPA platforms automate UI interactions — they click through screens a human would click through. They don’t extract from documents natively; they call out to a separate AI service for that. Nutrient combines extraction (AI Document Processing) and workflow execution (Workflow Automation) on the same platform, so the seam between perception and action isn’t your maintenance problem.

#### What’s the typical implementation timeline?

For a single document type with a defined workflow, the timeline is weeks — not months. The variable is the integration surface, not the AI. If you already have well-defined approval logic and the downstream systems exposed via API, the timeline is fast. If routing rules are undocumented or downstream systems require custom integration, plan for that work explicitly before evaluating vendors.

## Choosing an AI document automation approach

The buyer question — “how do we automate decisions?” — isn’t answered by extraction. Extraction is one input to a workflow that needs a decision layer, an action layer, and the seams between them owned by a single platform. The architectures that work treat all three as one surface; the ones that fail treat extraction as the product and leave the rest to whoever is on call.

The workflow is what you’re automating. AI is one feeder into it. Nutrient ships the products that own each layer: [AI Document Processing](https://www.nutrient.io/sdk/ai-document-processing/) for extraction, [Workflow Automation](https://www.nutrient.io/workflow-automation/) for decision and action, and [Document Engine](https://www.nutrient.io/sdk/document-engine/) when self-hosted infrastructure is the requirement.

[Start free trial](https://www.nutrient.io/try/)

[Talk to Sales](https://www.nutrient.io/contact-sales/)

## Related reading

- [OCR vs. intelligent document processing: Choosing the right extraction engine](https://www.nutrient.io/blog/ocr-vs-intelligent-document-processing-choosing-extraction-engine/) — When to use OCR, document AI, or a hybrid pipeline

- [Building an AI data extraction workflow](https://www.nutrient.io/blog/ai-data-extraction-workflow/) — Extracting structured data from documents

- [Invoice processing automation](https://www.nutrient.io/blog/invoice-processing-automation/) — Applied example for invoice-specific workflows

- [Extract key-value pairs programmatically](https://www.nutrient.io/blog/extract-key-value-pairs-programmatically/) — The building block for structured extraction

- [Nutrient AI Assistant](https://www.nutrient.io/guides/ai-assistant.md) — For document Q&A, summarization, and translation (a different layer than workflow automation)
---

## Related pages

- [The business case for accessibility: Five ways it drives enterprise value](/blog/5-ways-accessibility-drives-enterprise-value.md)
- [Accessibility Untangled Why It Matters Guide](/blog/accessibility-untangled-why-it-matters-guide.md)
- [Advanced Techniques For React Native Ui Components](/blog/advanced-techniques-for-react-native-ui-components.md)
- [Auto Tagging And Document Accessibility In Dotnet Sdk](/blog/auto-tagging-and-document-accessibility-in-dotnet-sdk.md)
- [Complete Guide To Pdfjs](/blog/complete-guide-to-pdfjs.md)
- [The CEO’s AI playbook: Why decision architecture beats model selection](/blog/ceo-ai-playbook-decision-architecture.md)
- [Best Document Viewers](/blog/best-document-viewers.md)
- [The CTO’s AI playbook: Why accountability architecture beats orchestration](/blog/cto-ai-playbook-accountability-architecture.md)
- [Document Ai Vs Ocr](/blog/document-ai-vs-ocr.md)
- [Digital Signatures](/blog/digital-signatures.md)
- [Document Viewer](/blog/document-viewer.md)
- [Create Pdfs With React](/blog/create-pdfs-with-react.md)
- [Emerging threats: Your logging system may be an agentic threat vector](/blog/emerging-threats-your-logging-system.md)
- [or](/blog/how-to-build-a-javascript-pdf-viewer-with-pdfjs.md)
- [How To Build A Reactjs Viewer With Pdfjs](/blog/how-to-build-a-reactjs-viewer-with-pdfjs.md)
- [or](/blog/how-to-convert-html-to-pdf-using-wkhtmltopdf-and-python.md)
- [or](/blog/how-to-build-a-reactjs-pdf-viewer-with-react-pdf.md)
- [base_url tells WeasyPrint where to resolve relative asset paths](/blog/how-to-generate-pdf-reports-from-html-in-python.md)
- [Linearized Pdf](/blog/linearized-pdf.md)
- [Open Pdf In Your Web App](/blog/open-pdf-in-your-web-app.md)
- [Nutrient Vs Conga Composer](/blog/nutrient-vs-conga-composer.md)
- [Pdf Page Labels](/blog/pdf-page-labels.md)
- [Online Document Viewer](/blog/online-document-viewer.md)
- [Pdf Sdk Performance Benchmark](/blog/pdf-sdk-performance-benchmark.md)
- [Pdf Sdk Compliance Security Checklist](/blog/pdf-sdk-compliance-security-checklist.md)
- [Pdfjs Eventbus Guide](/blog/pdfjs-eventbus-guide.md)
- [Pdf Ua Compliance Guide](/blog/pdf-ua-compliance-guide.md)
- [Pdfjs React Viewer Setup](/blog/pdfjs-react-viewer-setup.md)
- [Pdfjs Limitations Commercial Upgrade](/blog/pdfjs-limitations-commercial-upgrade.md)
- [Pdfjs Text Search Pdffindcontroller](/blog/pdfjs-text-search-pdffindcontroller.md)
- [Process Flows](/blog/process-flows.md)
- [Convert an HTML file to PDF.](/blog/top-ten-ways-to-convert-html-to-pdf.md)
- [or](/blog/sample-blog-updated.md)
- [Vector Pdf](/blog/vector-pdf.md)
- [Wcag2 Accessibility Requirements Documents](/blog/wcag2-accessibility-requirements-documents.md)
- [What Are Annotations](/blog/what-are-annotations.md)
- [Web Sdk Is Now Headless](/blog/web-sdk-is-now-headless.md)
- [What Is A Vpat](/blog/what-is-a-vpat.md)
- [Why Your Ai Agent Hallucinates Pdf Table Data](/blog/why-your-ai-agent-hallucinates-pdf-table-data.md)
- [What Is Pdf Ua](/blog/what-is-pdf-ua.md)