Build vs. buy guide

Build document features with AI, or buy them?

AI coding agents made the first version of a document feature fast. They didn’t change who owns it after launch. This guide shows what got cheaper, what didn’t, when building is the right call, and how to test both paths on your own files — whether you’re scoping something new or rethinking an SDK you already license.

Why

The case for buying used to be developer-months. AI agents made those cheaper, so the honest comparison moved to what comes after launch: maintenance, security, compliance, and proof.

What

A decision framework for document features: what to evaluate, what to test on both paths, and when building is genuinely the better call.

Who it’s for

Engineering and product leaders deciding whether to build, architects with an agent-built prototype, and teams that already license a document SDK and are asking whether to replace it.

01

The six paths

“Build vs. buy” is really a choice between six things. Most teams debate two of them without naming which.

Build in-house

Write the document layer yourself, from the format specification up. This is rare outside companies whose product is document technology. The PDF specification alone runs to hundreds of pages before extensions.

Assemble from open source

Stitch together PDF.js, PDFium, PDFBox, Tesseract, LibreOffice, and friends. This is what most “build” decisions actually mean, and what a coding agent will reach for by default.

“Build it with AI”

In practice, this is the open source path with the assembly time compressed. The agent writes the glue. The libraries underneath, and their licenses and security fixes, stay the same.

Buy a narrower tool

A hosted API or low-cost library for one job: HTML to PDF, eSignatures, or OCR. Often the right call for one narrow need. Read the limits first: page caps, revenue caps on “free” licenses, AGPL terms, and what happens when scope grows.

Buy a document SDK

License a maintained engine with the edge cases, security response, and standards conformance already handled. Not one SKU, but a ladder of hosting and control options.

The hybrid path

Buy the layer where being wrong is expensive — redaction, signing, conformance, extraction evidence — and build the parts that are your product. Let your coding agent write the glue and call the SDK for the hard part. The most durable answer for most teams.


02

What changed in 2026 — and what didn’t

The visible cost of a first draft fell. The cost of owning the result didn’t, and some of it grew.

What compressed
First working draft

An agent will wire up a viewer, a redaction script, or an OCR pipeline in an afternoon. This is real, and disputing it wastes everyone’s time.

Work with a clear test to aim at

When a strong test suite defines “correct,” agents now finish large jobs. One developer ported an HTML5 parser in just more than four hours for about $29, passing 9,200 conformance tests. Anthropic’s agents built a C compiler that compiles Linux.

Wiring documented APIs

Glue code between two well-specified interfaces is where agents are strongest, and the ceiling keeps rising. METR’s measure of how long a task agents can finish has been doubling every few months.

Prototype opportunity cost

A team that stands up a document viewer in two weeks instead of two months has genuinely given up less core-product focus. The 2025 version of this argument no longer holds.

What didn’t — or got worse
A test suite for your documents

The compiler write-up names the condition: The checker must be “nearly perfect, otherwise Claude will solve the wrong problem.” PDF rendering, Word layout, and signature validation have no shared public test suite. Your agent is only as good as the sample files you give it.

Review and merge quality

Passing tests isn’t the same as ready to merge. In a March 2026 METR study, maintainers of scikit-learn, Sphinx, and pytest wouldn’t merge about half of the AI-written pull requests that had passed the automated tests.

Delivery stability

Google’s 2025 DevOps Research and Assessment (DORA) report found that AI adoption still has “a negative relationship with software delivery stability.”

Security exposure

Across more than 100 AI models tested over four years, Veracode found generated code passed its security checks only 56 percent of the time, a rate that “hasn’t moved.” In a peer-reviewed 2026 study, 57 percent of agent solutions worked, but only 11.8 percent were secure.

Compliance conformance

PDF/A archival validity and PAdES long-term signature validation are checked by validators. PDF/UA accessibility is only partly machine-checkable: 47 of the 136 failure conditions in the official checklist usually need human judgment. A model that’s usually right is a different product from a pass.

Accountability

Faster assembly doesn’t change who is on call for a vulnerability. Since 11 September 2026, the EU Cyber Resilience Act requires companies that sell software in the EU to report actively exploited vulnerabilities in their products within 24 hours — including in the open source parts they ship.

Faster to write isn’t the same as ready to ship

In 2025, METR found that experienced developers took 19 percent longer with AI while believing they were 20 percent faster. Its February 2026 follow-up points to a modest speedup instead, but METR calls that data “only very weak evidence” for the size of the effect. The lesson that lasts isn’t a speed number. It’s that how fast a team feels and how good the shipped code is are different measures. Judge the second one with a reviewer, not only a test runner.

Developers know this. In Stack Overflow’s 2025 survey, 66 percent named “AI solutions that are almost right, but not quite” as their top frustration, 45 percent said debugging AI-generated code takes longer, and only 3 percent said they highly trust AI output.


03

Where the hard part sits, by document job

“Document features” isn’t one job. AI made some document jobs cheap to build and left others hard. Find your job in the table and read the row honestly. If your needs sit in the second column, building may well be the right call.

Build or buy, by document job

Based on public evidence as of October 2026.

Document job Building is usually enough when Buying usually wins when Test it with
Create and convert documents
You produce one or a few stable layouts from your own data, developers own the templates, and nothing goes to a regulator. Open source tools like Typst and WeasyPrint handle high volumes well.
Word files must convert without moving, users edit DOCX with tracked changes, users supply the content, templates belong to non-developers, or invoices must follow Germany’s e-invoicing rules, where the XML must match the PDF.
Your 20 hardest Word files. Compare page count, page size, fonts, and table headers with Word.
View, annotate, fill, sign, and collaborate
One internal viewer, simple markup, simple form filling, or simple eSignatures with a few signers in the US, where the ESIGN Act gives them legal effect.
Signatures must show as valid in Adobe Acrobat or meet EU eIDAS levels, many people sign one file, redaction must really delete content, apps must survive each new iOS and Android release, or several people edit at once.
Four signers on one file. Then validate in Acrobat. Redact. Then try to copy the hidden text.
Extract data (OCR, parsing, fields)
Clean digital PDFs, a few fields, moderate volume, cloud processing allowed, and nobody has to prove where a value came from.
Files are long, scanned, multilingual, or full of tables; reviewers must see where each value sits on the page; results must stay stable when models change; or documents must not leave your network.
Your longest scanned file, three runs in a row. Do you get the same answer, with a location for each value?
Archive, make accessible, and redact for compliance
You validate files you author yourself, your content is covered by the legal exceptions for older or archived documents, or you sit below legal thresholds.
You must fix third-party or legacy PDFs, produce accessible files on every release, keep audited records, or redact in a way that holds up in court.
Run veraPDF on a sample. Then have a person check the conditions a machine can’t judge.

The second column grows as tools improve. Open source parsers now match frontier AI models on clean pages, and Firefox’s free viewer now adds comments and image signatures. Revisit this table every year, and expect the hard part to move, not disappear.


04

The decision criteria that actually matter

Score your requirement against these before comparing costs. Most of them push the answer harder than price does.

Scope permanence

Will this genuinely stay narrow, or is “just viewing” the entry point? The single strongest predictor of whether a build works out. Be honest about the roadmap, not the ticket.

Cost of being wrong

A misrendered thumbnail is a bug. A redaction that didn’t remove the data is a disclosure incident. Grade each document operation by what a single silent failure costs you, not by how often it happens.

Compliance surface

Accessibility, archival, and signature standards decide whether a file is accepted, not whether it looks right. Validators check PDF/A and PAdES; PDF/UA also needs a person. Deadlines move but don’t disappear: The European Accessibility Act has applied since June 2025.

Adversarial input resilience

If users upload files, your code reads bytes an attacker chose: files built to fill memory or to fetch files from your server. OWASP publishes a checklist for this. In jsPDF, one flaw (CVE-2025-68428) let user input pull server files into a PDF.

Maintenance ownership

Name who will understand this code in 18 months, and who retests it after every browser, operating system, and AI model change. If an agent wrote the first draft, nobody holds the mental model by default.

Where documents are allowed to go

Offline only, no data sent to vendors, documents kept in one country: These rules surface late and remove options on both paths. Cloud AI isn’t automatically out. OpenAI now offers EU data residency and HIPAA agreements, with conditions.

Extraction you can check

If documents feed agents or RAG, structure lost at extraction is gone for good. A value nobody can trace to the page can’t be reviewed, and a July 2026 benchmark found general vision models and coding agents “do not return evidence by default.”

Platform spread

Web, iOS, Android, and server each need their own engine, data model, and security fixes, and all must render the same file identically. Free OS tools shift too: Developers reported PDFKit regressions after iOS 26.

Audit trail and provenance

Can you show a regulator how an output was made, months later? “An agent did it” won’t do; citations and replayable runs will. In one 2025 test, the same prompt, with randomness turned off, gave 80 different answers in 1,000 runs.

Agent readiness of the alternative

If you buy, your agent still does the integration. Machine-readable documentation, typed SDKs, and a callable tool layer decide whether it generates working code or plausible fiction you debug by hand.

Three-year cost, not year one

Build costs front-load visibly and compound invisibly. Compare cumulative cost over three years against your own licensing options at 10 times current volume.


05

What’s under the hood if you build

No single open source library covers the document lifecycle. “Just use PDF.js and PDFBox” already means four or more independently versioned projects, with different licenses and different maintainers, that you now integrate and own.


PDF.js

Browser rendering

Strength

Mature, actively released, and the viewer built into Firefox, which now adds text, drawings, highlights, comments, simple form filling, and page reordering. Genuinely good at what it was built for.

What you inherit

Its added signatures are images: Mozilla’s own help page says they “are not legally binding e-signatures,” and it doesn’t create certificate-based (PAdES) signatures. Whoever ships it owns its patches — it had arbitrary-code bugs in 2024 (CVE-2024-4367) and 2026 (CVE-2026-16633). Built for display, not for recovering table structure.


PDFium

Rendering engine

Strength

The engine inside Chrome and Edge, hardened by exposure to adversarial input at browser scale. Excellent standards fidelity.

What you inherit

A strong low-level core with no ready-made viewer UI, collaboration model, or signing workflow. Google publishes no versioned releases for embedders, the most-used community build is volunteer-run, and serious bugs still appear (CVE-2026-11304, rated 8.8).


Apache PDFBox

Java read/write toolkit

Strength

Foundation-governed, a PDF Association partner project, and one of the few open source options with real digital signature support.

What you inherit

Multisigner files, form changes after signing, and large files need careful testing. Interactive forms that change as they’re filled in are effectively unsupported.


pdf-lib

JavaScript create/edit

Strength

A simple API for creating and editing PDFs in JavaScript, and a frequent coding-agent suggestion.

What you inherit

No release since November 2021 and 279 open issues as of October 2026. An unmaintained dependency means you’re now its maintainer.


pypdf

Python read/write

Strength

Pure Python, pip-installable, well-documented, and the default an agent will suggest for Python.

What you inherit

Like every parser of untrusted files, it has shipped fixes for broken or hostile files that make it hang or exhaust memory. Read its security advisories before you put it behind an upload button.


MuPDF, iText, Ghostscript

Rendering, toolkit, interpreter

Strength

Technically excellent and standards-correct. MuPDF in particular is among the fastest engines available.

What you inherit

All three are AGPL, each with one commercial licensing owner. Artifex says you can’t use its open source “as part of a server-based application or service, without disclosing your own application’s full source code.” iText’s AGPL terms also require you to keep its producer line in every PDF. “Free” is doing a lot of work here.


Tesseract

OCR

Strength

Free, mature, and deservedly the default OCR recommendation for clean, printed text.

What you inherit

Returns text and word positions, not headings or paragraphs. OCRmyPDF, its most common wrapper, states that it “is incapable of recognizing handwriting,” and its output isn’t tagged for accessibility.


LibreOffice, headless Chrome, wkhtmltopdf

Conversion and generation

Strength

LibreOffice converts many Office files well and is actively maintained. Headless Chrome, often through Puppeteer or Gotenberg, is the common route from HTML to PDF.

What you inherit

LibreOffice isn’t Microsoft Word: Fonts, page size, and page breaks can shift — one Gotenberg user’s A4 files came out as US Letter. Even Anthropic’s Word skill for Claude converts through LibreOffice and ships its own list of Word pitfalls. wkhtmltopdf is archived and no longer maintained.


Typst, WeasyPrint

Template-based generation

Strength

Fast and cheap for fixed layouts at volume. One broker produces more than 1.5 million PDFs in about 25 minutes with Typst. Typst 0.14 exports PDF/UA-1 and PDF/A.

What you inherit

Templates, page breaks, and repeated table headers are yours to maintain, and there’s no Word roundtrip. Typst’s own release notes warn that tags alone don’t make a file accessible.


Documenso, DocuSeal

Open source eSigning

Strength

Modern, self-hostable apps for sending documents for signature. Documenso says a self-signed certificate is “sufficient for most use cases where your industry has no special signing regulations.”

What you inherit

Self-signed signatures show a warning in Adobe Acrobat; a green check needs a certificate from Adobe’s trusted list. A 2026 Documenso issue shows long-term-validation sealing failing with a qualified certificate, and a 2024 DocuSeal report showed a fourth signer invalidating the first three in Acrobat. Both are AGPL.


Frontier and open AI models

Extraction

Strength

Read clean pages very well. Open models such as PaddleOCR-VL now match or beat frontier models on clean-page benchmarks like OmniDocBench.

What you inherit

They don’t return evidence of where a value came from by default. Accuracy can fall sharply on long files — one model dropped from 87.9 to 27.9 percent on documents of more than 50 pages (ExtractBench). Models retire on short notice, and every change means retesting.


Note that this table is a web and server story. On iOS and Android, the options thin out sharply: PDF.js is browser-only, PDFium has no official standalone build pipeline and needs platform-specific workarounds to compile, and Artifex sells separate paid “App Kit” SDKs for MuPDF precisely because the raw library requires real native build work on both platforms. A team shipping web and mobile isn’t integrating one stack — it’s integrating and maintaining a different one per platform, and then reconciling rendering and annotation data models between them. Apple’s PDFKit and Android’s Jetpack PDF library are free with the operating system, and they change with it: Developers reported PDFKit regressions on iOS 26, and Android’s library needs Android 15 for form editing.

None of this makes open source a bad choice — these are good projects, and several are excellent at the one job they were built for. The claim worth holding is narrower and more defensible: They’re incomplete for the full document lifecycle, and the integration surface between them is yours. For a deeper look at one of them, see the Nutrient vs. PDF.js comparison.


06

Six assumptions that break in production


“The agent already built it, so it’s done”

A working prototype and a production-safe implementation are different achievements. Agents close that gap when a test suite defines “correct.” For documents, that suite is the set of files you collected — and it rarely includes the broken scans, partly embedded fonts, and odd producers your users will send.


“The agent will maintain it too”

Someone still has to understand it when one customer’s file breaks. Code that ships clean but that nobody deeply understands is a maintenance liability with a delayed fuse — and every new browser, operating system, and model release can light it.


“The model we tested is the model we’ll run”

Models change under a pipeline. Google gave one 2026 preview model about 12 weeks between release and shutdown. Newer models sometimes score lower than older ones on the same benchmark, and a provider’s content filter can block a customer’s own documents with “no way to bypass the behavior.” Each change means rerunning your test files.


“A black box over the text is redaction”

It isn’t, and the failure recurs at the highest levels. Manafort’s 2019 filing, Meta’s legal team in the 2025 FTC antitrust trial, and US Justice Department releases of the Epstein files in December 2025 and January 2026 all exposed text that was meant to be hidden. Tools that turn pages into images avoid the leak, but they also break search and screen readers.


“We’ll add compliance later”

PDF/UA tagging, PDF/A conformance, and PAdES long-term validation are architectural, not cosmetic. The US Justice Department moved its ADA Title II web deadlines to April 2027 and April 2028, and explained why: “Advanced technology, such as generative AI, does not yet reliably automate the remediation of inaccessible content at scale.” Federal website accessibility lawsuits in the US rose to 3,117 in 2025, and in June 2026, a French court gave Carrefour six months to make its site and app fully accessible.


“Control means owning the source”

Control is about owning outcomes. An agent-assembled stack doesn’t remove the vendor — it replaces one document SDK vendor with a set of open source dependencies whose maintainer you now are. If you sell software in the EU, the Cyber Resilience Act makes their vulnerabilities your reporting duty. Buying an SDK doesn’t remove that duty; it gives you a supplier with duties of its own.



07

Red flags in a build plan

The demo used clean files

Prototypes get tested on well-behaved documents. Production gets scanned forms from a printer nobody has heard of. Size the build against your worst file, not your best.

No named owner for security fixes

Ask who patches PDF.js, PDFium, or Ghostscript the week a vulnerability drops, and how fast. Ghostscript alone had 17 published vulnerabilities in 2024 and 10 in 2025. If the answer is “whoever’s free,” that’s the real cost line.

Scope is described as “just viewing”

Ask whether “just viewing” is the floor or the ceiling. If it’s truly the ceiling, building can be the right call — see chapter 10. If it’s the floor, plan for annotation, forms, signatures, and redaction, because that’s where these roadmaps usually go.

The estimate has one number in it

A build estimate that covers initial development but not maintenance, security patching, compliance validation, and review overhead is measuring the cheapest phase and calling it the total.

Nobody has read the licenses

AGPL obligations in MuPDF, Ghostscript, and iText surface during legal review, usually after the architecture is committed. “Free” commercial licenses have conditions too — Syncfusion’s community license, for example, has revenue, staff, and funding caps and excludes government bodies.

“The agent found a library that does this”

Agents suggest what they saw often in training, not what they checked this week. pdf-lib, a common JavaScript suggestion, hasn’t had a release since November 2021. Check the last release date and open security advisories for what actually got installed.


08

Already licensing an SDK? What replacing it really means

Many teams that license a document SDK use only part of it. If that’s you, rebuilding that part with open source and a coding agent can look cheap — and sometimes it is. A narrow, stable scope is a legitimate reason to switch. But replacing a live document layer is a migration, not a fresh build: The annotations, form data, and signed documents your users created must keep working.


The viewer

Patches for the engine you ship; a retest after every browser, iOS, and Android release; and every annotation your users have already created in the current format.


Digital signatures

Signatures that still show as valid in Adobe Acrobat and EU validators years from now — and every document already signed with your current setup.


Redaction

Proof that removed content is really gone, in every file and every release, including thumbnails and embedded images.


Conversion and generation

Word fidelity (fonts, page size, page breaks), your template library, and — in Germany from 2027 — e-invoices whose XML matches the PDF.


Data extraction

A location and a confidence level for each value, stable results when your AI model changes or retires, and the test files that prove both.


Accessibility and archiving

PDF/UA output that passes the machine checks and the human ones, and PDF/A records you can defend in an audit.


Security response

A named owner for every vulnerability in the stack. If you sell software in the EU, a 24-hour reporting duty for actively exploited ones.


Four questions before you switch

Who owns it when the person who built it leaves? What happens on the worst file from your last 12 months of support tickets? Will your signatures still validate in five years? Who answers the auditor?

Then test it. Run the replacement against the files behind your last year of support tickets, and against your oldest signed documents. If it passes, you have your answer. If it doesn’t, you know exactly what you’d be taking on.


09

The real total cost of ownership

Agents shrink the number you see in a demo and grow the one that shows up on a support queue, a security audit, or a compliance review 18 months later.

Which cost categories actually moved

Directional, not audited. Build your own version with your own salary and volume assumptions — the point is which rows move and which don’t.

Cost category Direction under AI Why
Initial development
Compressed, meaningfully
First-draft and glue-code work is where agents are strongest. This is the row that broke the 2025 argument, and it broke for real.
Cross-platform integration
Compressed, less
Per-platform engine differences, native build systems, and annotation data models stay largely manual.
Ongoing maintenance
Flat to worse
Every library upgrade and every browser, operating system, and AI model release needs a retest. More code shipped per hour is more code to understand when one file breaks.
Code review and QA
Worse
In a 2026 METR study, maintainers wouldn’t merge about half of the AI pull requests that had passed automated tests. Review is where that gap gets paid.
Security patching
Worse
The vulnerability cadence of the underlying libraries is unchanged, now in code the team understands less well. In the EU, actively exploited vulnerabilities must be reported within 24 hours.
Compliance conformance
Unchanged
A validator decides whether a file passes, and some accessibility checks still need a person. Generation speed changes neither.
Model and platform changes
New, recurring
AI models retire on short notice, newer ones can score lower, and operating systems change their PDF frameworks. Each change means rerunning your test files.
Opportunity cost
Flat
Specialist judgment about document edge cases doesn’t compress just because drafting did. Someone still has to build and hold it.

Model it with your own numbers

Start from your inputs, not ours. Estimate the hours to fix one edge case, times the edge cases you expect each year. Add the hours to ship each security fix in the libraries you use, the retest hours per browser, operating system, and AI model change, and the compliance checks per release. Then price those hours: The US median wage for software developers was $135,980 in May 2025, before benefits.

Do the same for the buy path: license cost at 10 times your current volume, integration time, and the time your team still spends on what you build around the SDK. The honest answer is whichever total is lower for your scope — and for some narrow scopes, that’s the build.


10

When building it yourself is the right call

We sell an SDK, so treat this chapter with appropriate suspicion — and then check it against your own situation. These are real signals, not a setup for a rebuttal.


01

The scope is permanently narrow, and you mean it

Slack added inline PDF viewing in 2016 on PDF.js, scoped to display and text selection for small files — small enough to be a new engineer’s onboarding project. Years later, it still had no annotations, forms, or signing, because that was the plan. A narrow build works indefinitely if the team accepts a hard, permanent ceiling.


02

Document processing is your actual differentiator

Dropbox bought commercial OCR first to validate demand. Then it replaced it in-house once demand was proven — an eight-month program with a custom labeling platform, a from-scratch neural architecture, and millions of synthetic training words. That’s the bar. If you have that team and that runway, build.


03

You’re pre-PMF with unstable requirements

If a six-figure annual license is a meaningful fraction of runway and the requirements will change substantially within two quarters, the cheapest thing that unblocks the next milestone is a legitimate, capital-efficient choice — even knowing it may need replacing.


04

The real constraint is commercial, not technical

If what you need is self-serve, metered access with no sales call, that’s a packaging question, not an architecture one. Start on a usage-priced API and step up only when isolation or volume requires it.


05

Your documents are fixed layouts generated from your own data

Statements, labels, and invoices built from structured data suit open source tools well. Zerodha, an Indian broker, produces more than 1.5 million PDFs in about 25 minutes with Typst, at a cost its team calls “negligible.” If nobody edits Word files and no regulator checks the output, this can stay cheap.


06

You need simple eSignatures, not trusted digital ones

In the US, the ESIGN Act gives electronic signatures legal effect, and open source eSigning apps handle this well for a few signers and no special regulations. The math changes when signatures must show as valid in Adobe Acrobat, meet EU eIDAS levels, or stay verifiable for years.


What successful builds had in common

In the public write-ups we found, document builds that worked started from a mature third-party engine, not a blank file. Dropbox’s QuickPDF — which halved 75th-percentile time to interactive — was a custom C++ binary wrapped around a modified PDFium, arrived at only after two earlier approaches were outgrown. LinkedIn Learning’s accessible viewer was a heavily modified fork of PDF.js, because PDF.js doesn’t carry tagged markup through to the DOM; it took roughly 50 people across a dozen teams more than six months and required engineers to work directly from the PDF specification.

None of those three conditions — sustained senior investment, an honestly narrow scope, and a mature engine underneath — is changed by a coding agent typing faster. If your plan is missing one of them, the plan is the problem, not the tooling. Coding agents add a fourth condition rather than removing one: a large, ugly set of test files, so someone can tell when the result is right.


11

How to run a bake-off that settles it

Run both paths against the same corpus, in the same timebox, and measure the things that only show up later.


01

Assemble the worst corpus you have

Use 1,000 real files, weighted toward the ugly ones — bad scans, rotated pages, Chinese or Japanese text with only part of the font embedded, generated by whatever produced your actual production traffic. Both paths get the same set. Keep this set after the decision. It’s the asset that tells you whether any build — or any vendor — still works next year.


02

Timebox both paths identically

Same engineers, same agent, same week. If the build path gets a month and the trial gets an afternoon, you’ve measured effort allocation, not capability.


03

Validate compliance independently

Run the output through veraPDF — the free, industry-standard conformance checker — yourself. For PDF/UA, it runs “only machine verifiable checks,” so also have a person review a sample: The official checklist lists 47 conditions that usually need human judgment. Don’t accept a “success” rate from either path.


04

Test the maintenance question, not just the build question

Inject a realistic edge case a week after the build is “done” — a font that renders one character off, a form field that won’t flatten — and time the fix. That number, not the build time, is what you pay for three years.


05

Have someone who didn’t build it review it

The developer who prompted the build is the worst judge of whether it’s production-safe — that’s the perception gap in chapter 02, applied to your own team. Get a second engineer to try to break it.


What to measure

Correctness and resilience

Metric What to measure Why it matters
Critical failures at volume
1,000+ files in one batch: count crashes, hangs, and unrecoverable errors
Zero is the baseline. One crash per 1,000 is a daily incident at production scale.
Redaction permanence
Extract text from your own redacted output; check embedded thumbnails and image streams too, and whether the page lost its text layer
Many tools draw a box without removing the text underneath. This 10-minute test would have caught the redaction failures at Meta and the US Justice Department.
Table structure recovery
Extract a document with nested tables and compare cell boundaries against ground truth
General-purpose parsers often lose table structure. If documents feed an agent, this is the number that decides whether it answers correctly.
Evidence and repeatability
Extract the same file three times. Check that each value has a page and position, and that the answers match
A value you can’t trace can’t be reviewed, and an answer that changes between runs can’t be audited.
Signature longevity
Sign with several signers. Then validate in Adobe Acrobat and the EU DSS validator, and offline after the signing certificate would have expired
Without PAdES B-LT, a signature that validates today reads as “validity unknown” to an auditor in five years.
PDF/UA and PDF/A conformance
Convert. Then validate with veraPDF
Legally consequential. For PDF/UA, a validator pass is the minimum, not the finish line — some conditions need a person.
Word fidelity
If you convert or generate Office files: Convert your 20 hardest DOCX files and compare page count, page size, fonts, and table breaks with Word
Averages hide the files that fail. One substituted font can move every page break after it.
Handling of broken files
Feed it deliberately corrupted files, tiny files that expand to consume all memory, and files that cut off halfway through
If users upload documents, this is your attack surface. Resource exhaustion is the most common real-world failure.

Cost and operability

Metric What to measure Why it matters
Time to fix an edge case
Hours from a reported rendering or extraction defect to a deployed fix
The single best proxy for three-year maintenance cost. Measure it on both paths.
Concurrent throughput
N simultaneous server-side jobs: per-job latency and total throughput
Single-document benchmarks tell you nothing. Several OSS conversion tools aren’t concurrency-safe at all.
License audit
Full dependency tree, with every license resolved and reviewed
Run this before the architecture is committed. AGPL obligations found during legal review are the expensive kind.
Agent integration quality
Point your coding assistant at the documentation and have it build a real integration; count the corrections.
Most integration work now runs through an agent. If it needs constant correction, that cost is yours every sprint.
Model and platform changes
Rerun the corpus after an AI model upgrade or an operating system release, and count what changed
This bill arrives every few months, on both paths.

12

Why teams choose Nutrient

We build with coding agents too

This isn’t an argument against agentic coding. Our own engineers ship with Claude Code and Codex daily, and Nutrient is built to be driven by agents: Nutrient MCP, typed SDKs for TypeScript and Python, llms.txt published across every major SDK, the TypeScript client indexed on Context7, and a one-command install that drops complete SDK documentation into your assistant’s rule set — Claude Code, Cursor, GitHub Copilot, and JetBrains Junie among them. We also open sourced agentic usability, a tool that runs coding agents against an SDK in isolated sandboxes to measure how well they can actually use it — including against our own APIs, to find where they get confused. The question was never whether to use an agent. It’s what you point it at.

Extraction accuracy we publish, including where we don’t lead

Vendor accuracy claims are worth what you can reproduce. opendataloader-bench is a community-maintained corpus of 200 real-world PDFs with hand-annotated ground truth, Apache 2.0, with an open source evaluation harness and a public leaderboard. We run the full corpus every release with competitor libraries pinned to their latest published versions, and we commit our predictions publicly.

Nutrient’s vision tier scores 0.93 overall and tops every metric — 0.96 on reading order, 0.94 on table structure, 0.87 on heading hierarchy. Standard Nutrient scores 0.889, statistically tied with Docling’s 0.892 while running roughly 134 times faster (0.004 seconds per page against 0.549). By comparison, pypdf and liteparse each score 0.000 on both table structure and heading detection, and PDF.js scores 0.000 on table structure recovery — fine for rendering, disqualifying for an AI pipeline.

Two caveats we publish alongside the wins, because leaving them out is what makes benchmark claims worthless: The 0.93 figure is the vision tier, which requires a license key and is therefore run internally rather than on the public leaderboard; and the OpenDataLoader hybrid configuration beats standard Nutrient overall (0.907 against 0.889), with Docling ahead on table structure among non-vision tools. Download the corpus and run it against your own documents.

Every value the Data Extraction API returns comes with a citation and a match label — id_match, id_match_multiblock, id_match_partial, fuzzy_match, or not_found — so you can see where it came from and send fuzzy_match and not_found fields to a person. See citations and confidence.

Bounded, scored, and governed — the part that has to be provable

We use AI, and we’re precise about where. Recognition against a known data model — key-value pairs, machine-readable zone (MRZ) lines on a passport, magnetic ink character recognition (MICR) on a check, optical mark recognition (OMR) on a form, layout elements from the intelligent character recognition (ICR) engine — is AI- and ML-powered, but bounded: It returns typed output against a schema, with per-element confidence scores. The key-value engine’s confidence score is computed from OCR character-level confidence, word-level confidence, and the known difficulty of the data type, so a date or an IBAN scores more reliably than a freeform address. Generating and converting documents, executing a redaction, signing and validating signatures, and validating PDF/A and PDF/UA involve no model inference at all — they’re deterministic and validator-checkable. Where AI helps decide what to redact or how to tag a file for accessibility, the result is a first pass a person can review.

Where reasoning is genuinely open-ended — chart and image description, cursive handwriting on degraded scans, the AI Assistant’s editing agent — we don’t call it deterministic. Our own guides say plainly that an ambiguous word can be recognized confidently and still be wrong. That layer is wrapped in citations, per-element confidence scores, and a per-tool approval policy where every operation resolves to allow, ask, or deny — so destructive actions can be gated behind a human, or refused outright, rather than assumed safe. That distinction is the product, not a disclaimer on it.

“Buy” isn’t one decision

A team weighing a hand-rolled viewer is deciding against a different product than a team weighing a redaction pipeline. Client-side viewing, annotation, form filling, eSigning, and redaction run with no backend at all — in the browser on the web, and fully on device on iOS and Android. That often satisfies “documents never leave our control” without any infrastructure at all. Step up only when isolation, volume, or collaboration requires it.

By document job: Document Authoring, the server SDKs, and the DWS Processor API create and convert documents. The Web, iOS, Android, and cross-platform SDKs cover viewing, annotation, forms, and signing, and add real-time collaboration when paired with Document Engine. The Data Extraction API and the data extraction SDK cover OCR and extraction, with a citation for every value. The Accessibility API, PDF/A and PDF/UA validation, and redaction cover archiving and compliance.

Mobile is a first-class native target, not a wrapped web view. The iOS and Android SDKs are native, with macOS covered by the iOS SDK through Mac Catalyst. React Native and Flutter wrap those native engines; .NET MAUI takes a different route, exposing the Web SDK’s APIs through a JavaScript bridge, so treat it as a web-engine product rather than a native mobile one. One caveat worth knowing before it costs a sprint: Certificate-based digital signing isn’t bridged in the React Native or Flutter APIs — those surface electronic and handwritten signatures, and PAdES digital signatures have to be reached through the underlying platform SDK (iOS, Android, or Web).

Web SDK, Standalone mode
Native mobile SDKs
Server SDKs
Document Engine
DWS APIs
Where it runs
In the browser, no backend
On device — native iOS and Android, macOS via Mac Catalyst
Inside your own application on your server, with no network call
Your own servers, or a dedicated instance Nutrient runs for you
Nutrient-hosted, on infrastructure shared with other customers
Where documents go
None — documents never leave the client
None — fully on device, works offline with no connectivity
None — fully embedded, air-gap capable
None when self-hosted; region-pinned when Nutrient-managed
Processed by Nutrient; on plans without data retention enabled, input files aren’t persistently stored
Best for
Viewing, annotation, forms, eSigning, redaction with no infrastructure
Field and offline work: viewing, annotation, forms, and signing on a phone or tablet with no connection
Backend processing, local extraction and OCR, strict requirements that documents never leave your network
Real-time collaboration, high-volume processing, tenant isolation
Fastest start, usage-priced, no infrastructure to run

Compliance and regulated deployment aren’t afterthoughts

The requirements that surface late in an evaluation — air-gapped deployment, zero telemetry, data residency — are documented deployment paths here, not custom engagements. Nutrient is SOC 2 Type 2 audited, with PDF/A archival, PDF/UA auto-tagging, and PAdES digital signatures as first-class capabilities rather than roadmap items. Auto-tagging gives you a strong first pass; a person still checks the conditions that need judgment. Encryption-in-transit and at-rest specifics vary by product and deployment — confirm them against the security guide for the product you’re deploying.

The work already done

Nutrient is the accumulated engineering of five formerly independent document companies, built on PDFium — the same engine behind Chrome and Edge — and running across Web, iOS, Android, .NET, Java, Node.js, Python, React Native, Flutter, and MAUI with one data format and one support relationship. More than 3,000 organizations use it, including roughly 15 percent of the Global 500, across more than a billion document interactions a year. That’s the thing a build has to replace, and it isn’t a viewer.


13

Next steps


Run the bake-off

Get a trial key scoped to your use case and timebox it against your build path on the same corpus. Everything you build during the trial carries over to production — no rework.

Get Started

Pressure-test the decision with an engineer

Talk to a solutions engineer about where your requirements actually sit — whether you’re scoping something new or reconsidering an SDK you already license. If your scope is narrow enough that building is the better call, you’ll hear that.

Contact Sales

Review what you use today

Already a Nutrient customer and weighing a rebuild? Ask for a review of the features, platforms, and standards you actually rely on, so you can compare like with like before you decide.

Contact Sales

Point your coding agent at it

Connect Nutrient MCP, pull the typed SDKs, and let your agent integrate real document operations against your own files. Judge the result the way you’d judge its build.

Explore the MCP server

Compare the alternatives side by side

An honest, capability-by-capability comparison against agentic coding and open source — including the rows where building it yourself is the better fit.

See the comparison


Frequently asked questions

Can I just build document handling with Claude Code or Cursor?

For a prototype, or a viewer for files you control, yes — and that’s a good use of a coding agent. The gap opens after the demo. A working prototype and a production-safe implementation are different achievements, and the distance between them is made up of handling edge cases, surviving broken and hostile files, and meeting compliance standards — in a domain with a 20-year history of published security vulnerabilities. The honest question isn’t whether your agent can produce something that works. It’s whether you can certify it’s correct on the one badly formed contract, every time, with an audit trail.

Is it cheaper to build document features with AI in 2026?

Year one, often yes — first-draft development is genuinely faster. Over three years, it depends on what you own. The costs that compound — review, security fixes, retesting after model and platform changes, compliance checks — didn’t get cheaper. In a 2026 METR study, maintainers wouldn’t merge about half of the AI pull requests that had passed automated tests, and Google’s 2025 DORA report still links AI adoption to lower delivery stability. Build the three-year model, not the year-one one. Chapter 09 shows how.

When does building document features in-house actually make sense?

When the scope is permanently narrow and you mean it, when document processing is your actual product with a funded team behind it, when you’re pre-product-market fit (PMF) and runway matters more than engineering time, when your documents are fixed layouts generated from your own data, when you need simple US eSignatures rather than trusted digital ones, or when your real constraint is commercial rather than technical. Chapter 10 covers each with the evidence. We’d rather tell you that than oversell — and the agentic coding comparison names the specific capability rows where building it yourself is the better fit.

Is open source like PDF.js good enough?

For basic viewing of well-behaved files, PDF.js and PDFium are solid, widely used projects, and Firefox’s viewer now adds comments, simple form filling, and image signatures. The ceiling is the problem: no certificate-based (PAdES) signing, no permanent redaction in Mozilla’s own feature list, and security fixes you must ship yourself — PDF.js has had two arbitrary-code bugs since 2024. Several other common recommendations — MuPDF, Ghostscript, iText — are AGPL, so using them in a closed-source or SaaS product means disclosing your source or buying a license. See the full PDF.js comparison and why AI agents hallucinate PDF table data.

What’s the biggest hidden cost of building document handling?

Institutional memory. When a customer reports that one scanned invoice displays a single character wrong — because the page is rotated and the font is only partly embedded in the file — someone has to understand the code well enough to fix it safely. If an agent wrote the first draft, the old assumption that the author holds the mental model no longer holds. Every AI-generated feature in production needs a named human owner, and a test set that grows with every bug.

How do I compare a build path against an SDK fairly?

Same corpus, same timebox, same engineers, on both paths — then measure the things that surface later, not the things that surface in a demo. Critical failures across 1,000 real files, redaction permanence tested by extracting text from your own output, PDF/UA conformance validated independently with veraPDF, and time-to-fix on an edge case injected a week after the build looked done. Chapter 11 has the full measurement tables.

We already use a document SDK. Should we replace it with something we build?

Maybe — if you use a small, stable part of it and nobody depends on signatures, redaction, accessibility, or audit trails. List what you rely on today, what you’d take on, and what you’d have to migrate: annotations, form data, and signed documents created in the current format. Then run the replacement against the files behind your last 12 months of support tickets. Chapter 08 has the checklist.

Can we use an AI model for data extraction instead of an SDK?

For clean digital PDFs and a few fields, often yes — open models now match frontier models on clean pages. The gaps show up on long, scanned, table-heavy files, in showing where each value came from, and in keeping results stable when the model changes or retires. If a person must review or defend the values, test for evidence and repeatability, not only accuracy.

Does buying an SDK make us compliant?

No product makes you compliant on its own, and you should be wary of any vendor that says so. Under the EU Cyber Resilience Act, you stay responsible for the software you ship, including its parts, and accessibility laws ask for accessible documents, not a particular tool. What a maintained SDK gives you is a supplier with its own security duties, validated PDF/A and PDF/UA output, and standards-based signatures — so your team checks results instead of building the machinery.

Is there a buyer’s guide for choosing between SDK vendors?

Yes. Once you’ve decided to buy, the PDF SDK buyer’s guide covers vendor evaluation criteria, rendering engines, pricing models, and POC benchmarks. There’s also a DOCX editor SDK buyer’s guide for Word-document editing specifically.