Build vs. buy guide
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
“Build vs. buy” is really a choice between six things. Most teams debate two of them without naming which.
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.
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.
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.
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.
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.
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
The visible cost of a first draft fell. The cost of owning the result didn’t, and some of it grew.
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.
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.
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.
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.
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.
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.
Google’s 2025 DevOps Research and Assessment (DORA) report found that AI adoption still has “a negative relationship with software delivery stability.”
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.
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.
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.
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
“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.
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
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.
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
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.
Browser rendering
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.
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.
Rendering engine
The engine inside Chrome and Edge, hardened by exposure to adversarial input at browser scale. Excellent standards fidelity.
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).
Java read/write toolkit
Foundation-governed, a PDF Association partner project, and one of the few open source options with real digital signature support.
Multisigner files, form changes after signing, and large files need careful testing. Interactive forms that change as they’re filled in are effectively unsupported.
JavaScript create/edit
A simple API for creating and editing PDFs in JavaScript, and a frequent coding-agent suggestion.
No release since November 2021 and 279 open issues as of October 2026. An unmaintained dependency means you’re now its maintainer.
Python read/write
Pure Python, pip-installable, well-documented, and the default an agent will suggest for Python.
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.
Rendering, toolkit, interpreter
Technically excellent and standards-correct. MuPDF in particular is among the fastest engines available.
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.
OCR
Free, mature, and deservedly the default OCR recommendation for clean, printed text.
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.
Conversion and generation
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.
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.
Template-based generation
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.
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.
Open source eSigning
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.”
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.
Extraction
Read clean pages very well. Open models such as PaddleOCR-VL now match or beat frontier models on clean-page benchmarks like OmniDocBench.
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
What teams assume
What actually happens
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.
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.
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.
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.
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 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
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.
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.
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.
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.
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.
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
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.
What you’d replace
What you’d take on
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.
Signatures that still show as valid in Adobe Acrobat and EU validators years from now — and every document already signed with your current setup.
Proof that removed content is really gone, in every file and every release, including thumbnails and embedded images.
Word fidelity (fonts, page size, page breaks), your template library, and — in Germany from 2027 — e-invoices whose XML matches the PDF.
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.
PDF/UA output that passes the machine checks and the human ones, and PDF/A records you can defend in an audit.
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.
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
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.
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. |
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
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
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
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
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
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
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
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.
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
Run both paths against the same corpus, in the same timebox, and measure the things that only show up later.
01
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
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
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
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
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.
| 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. |
| 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
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.
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.
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.
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 |
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.
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
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.
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.
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.
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.
An honest, capability-by-capability comparison against agentic coding and open source — including the rows where building it yourself is the better fit.
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.
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 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.
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.
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.
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.
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.
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.
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.
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.