What is document generation? A developer’s guide to PDF generation

A developer integrates a document generation API, only to realize data is being sent to third-party servers — failing a security audit. Another builds a solution that works in the browser but can’t run offline. A third spends weeks building custom logic that an SDK would have provided out of the box.

These problems are avoidable. This guide explains document generation from a developer’s perspective — how it works under the hood, what to evaluate when choosing tools, and how to implement it with code examples you can actually use. You’ll see how Nutrient’s SDK handles generation across web, mobile, and server environments.

What is document generation?

Document generation is the automated process of creating documents by combining templates with data from business systems, databases, and APIs. Instead of manually copying information into Word documents or PDFs, document generation software pulls data directly from sources like CRMs, ERPs, and JSON files and produces finished, formatted documents in seconds.

It extends traditional mail merge, which handles simple name-and-address substitutions. Modern document generation supports complex logic, dynamic tables, conditional sections, images, and multiple output formats — all without manual intervention.

Document generation vs. related terms

Core components

Every document generation system relies on three elements:

• Templates — Predesigned documents with placeholders for dynamic content (DOCX, PDF, and HTML)
• Data sources — Information that populates the template (JSON, XML, databases, APIs, and CRMs)
• Output engine — The software that merges data with templates and produces final documents (PDF, DOCX, and HTML)

Modern solutions add a fourth component: logic and rules that determine which content appears based on conditions, enabling a single template to generate thousands of personalized document variations.

How document generation works

Automated document generation follows a straightforward process, whether you’re generating one contract or 10,000 invoices.

The document generation process

Step 1 — Template creation

Design a document template with placeholders (also called merge fields or tags) where dynamic content will appear. For example: {{customer_name}}, {{invoice_total}}, {{contract_date}}.

Step 2 — Data connection

Connect your data source — this could be a JSON file, REST API, SQL database, or CRM like Salesforce. The data contains the values that will replace each placeholder.

Step 3 — Processing and logic

The generation engine processes the template, applying any conditional logic. For example: “If the contract value exceeds $50,000, include the executive approval section.” Dynamic tables expand based on line items in the data.

Step 4 — Output generation

The engine produces the final document in your desired format — PDF for distribution, DOCX for further editing, or HTML for web display.

Step 5 — Delivery or storage

The generated document is delivered via email, saved to cloud storage, sent through an API response, or passed to the next step in your workflow (like eSignature).

Generation approaches

Most enterprise solutions combine template-based generation with programmatic control for maximum flexibility.

Document generation use cases

Document generation transforms workflows across every industry. Here’s where it delivers the most value.

By industry

Legal

Law firms using document generation report a 70–80 percent reduction in contract creation time, with fewer errors requiring revision.

• Contracts and agreements
• NDAs and confidentiality agreements
• Court filings and legal briefs
• Client engagement letters

Financial services

Banks generate millions of statements monthly — manual creation would be impossible without automation.

• Account statements and reports
• Loan documents and disclosures
• Investment proposals
• Compliance documentation

Healthcare

Healthcare organizations use generation to ensure every document meets strict regulatory requirements while reducing administrative burden on clinical staff.

• Patient intake forms
• Discharge summaries
• Insurance claims
• Compliance reports (HIPAA)

Sales and marketing

Sales teams using automated proposal generation close deals faster by responding to RFPs in hours instead of days.

• Proposals and quotes
• Statements of work (SOWs)
• Sales contracts
• Personalized marketing materials

Human resources

HR departments generate thousands of personalized documents annually — from offer letters to benefits enrollment forms.

• Offer letters
• Employment contracts
• Onboarding packets
• Policy acknowledgments

Insurance

Insurance carriers must generate accurate, compliant policy documents at scale while personalizing coverage details for each customer.

• Policy documents
• Claims forms
• Renewal notices
• Compliance certificates

By document type

Benefits of document generation

Organizations implementing document generation see measurable improvements across operations.

Time savings — Documents that took hours to prepare manually now generate in seconds. A sales team creating 50 proposals per month might save 100+ hours monthly — time redirected to selling instead of formatting.

Elimination of errors — Manual data entry introduces errors. Copying a client name incorrectly or using outdated pricing can cost deals or create legal exposure. Document generation pulls data directly from source systems, eliminating transcription errors.

Brand consistency — Every generated document follows the same template, ensuring consistent formatting, logos, fonts, and messaging. No more documents with outdated letterheads or inconsistent styling.

Compliance enforcement — Templates can enforce required language, disclosures, and approval workflows. Legal teams maintain control over contract terms while enabling sales to generate agreements independently.

Scalability — Generate one document or one million documents — the effort is nearly identical. Organizations processing high document volumes (banks, insurers, and utilities) couldn’t operate without automated generation.

Faster revenue cycles — Faster document creation means faster deal closure. When a prospect requests a proposal, responding in hours instead of days keeps momentum and improves win rates.

Security and data privacy — Cloud-based document generation services require sending your data to third-party servers. For organizations handling sensitive information — financial data, healthcare records, and legal documents — this creates compliance risk. On-premises and client-side SDKs keep data within your infrastructure, simplifying audits and meeting requirements like HIPAA, SOC 2, and GDPR.

ROI snapshot

How Nutrient handles document generation

Nutrient provides a document generation SDK that gives developers full control over the generation pipeline. Self-hosted and on-device SDKs run in your infrastructure — whether that’s a browser, mobile app, or server — so document data stays within your environment. Nutrient also offers a cloud API for teams that prefer a hosted solution.

Nutrient document generation capabilities

PDF generation and manipulation

Nutrient creates PDFs programmatically from templates, form data, images, or scratch. You can populate form fields, overlay annotations, insert images, and merge documents — all through code.

• Generate PDFs from PDF templates with form fields
• Generate PDFs from images (JPG, PNG, and TIFF)
• Generate PDFs from Word templates (DOCX)
• Populate and flatten form fields programmatically
• Overlay text annotations at specific coordinates
• Merge, split, and manipulate PDF pages
• Client-side generation without server dependencies

Multiplatform SDK

Nutrient offers SDKs for web browsers, mobile apps, desktop applications, and server-side processing:

Form-based generation

The most common document generation pattern uses PDF forms as templates. Nutrient loads a template PDF with form fields, populates the fields with your data, and then flattens the result into a final document.

// Load template, populate fields, export final PDF.
const instance = await NutrientViewer.load({
  document: "template.pdf",
  headless: true,
});
await instance.setFormFieldValues({
  clientName: "Acme Corp",
  contractDate: "January 28, 2026",
  amount: "$50,000",
});
const finalPdf = await instance.exportPDF({ flatten: true });

Office document conversion

Generate documents from Word templates (DOCX) and convert to PDF or PDF/A for distribution.

Batch processing

Server-side SDKs and the Document Engine handle high-volume document processing without user interaction. Generate monthly statements, bulk contracts, or personalized communications at scale.

Why developers choose Nutrient

• Data stays local — Self-hosted and on-device SDKs process documents in your infrastructure, with no data sent to third-party servers.
• Offline capable — Client-side generation works without an internet connection.
• Full control — Access to fine-grained APIs for custom document workflows.
• Multiplatform — Consistent capabilities across web, mobile, and server deployments.

Implementing document generation with Nutrient

The following examples show how to generate documents using Nutrient’s SDK.

Prerequisites

Before implementing document generation with Nutrient, you need:

• A Nutrient SDK license (start a free trial)
• The latest stable version of Node.js(opens in a new tab) (for JavaScript) or .NET 8+(opens in a new tab) (for C#)
• Basic familiarity with your chosen programming language

JavaScript and TypeScript example

Generate a PDF invoice from a template:

import "./assets/pspdfkit.js";

const baseUrl = `${window.location.protocol}//${window.location.host}/assets/`;

async function generateInvoice(templatePath, invoiceData) {
  try {
    // Load the invoice template in headless mode (no UI).
    const instance = await NutrientViewer.load({
      baseUrl,
      document: templatePath,
      headless: true,
    });

    // Populate form fields with invoice data.
    await instance.setFormFieldValues({
      customerName: invoiceData.customerName,
      customerAddress: invoiceData.customerAddress,
      invoiceNumber: invoiceData.invoiceNumber,
      invoiceDate: invoiceData.invoiceDate,
      subtotal: invoiceData.subtotal,
      tax: invoiceData.tax,
      total: invoiceData.total,
    });

    // Export the final PDF with flattened form fields.
    const pdfArrayBuffer = await instance.exportPDF({ flatten: true });
    return pdfArrayBuffer;
  } catch (error) {
    console.error("Failed to generate invoice:", error.message);
    throw error;
  }
}

// Usage.
const invoiceData = {
  customerName: "Acme Corporation",
  customerAddress: "123 Business Ave, Suite 100",
  invoiceNumber: "INV-2026-0042",
  invoiceDate: "January 28, 2026",
  subtotal: "$8,500.00",
  tax: "$680.00",
  total: "$9,180.00",
};

const pdfBytes = await generateInvoice("/invoice-template.pdf", invoiceData);

C#/.NET example

Generate a contract document server-side using the Nutrient .NET SDK:

using GdPicturePDF gdpicturePDF = new GdPicturePDF();

// Load the contract template.
gdpicturePDF.LoadFromFile(@"C:\templates\contract-template.pdf");

// Prepare the contract data.
var contractData = new Dictionary<string, string>
{
    { "ClientName", "Acme Corporation" },
    { "ClientAddress", "123 Business Ave, Suite 100" },
    { "ContractDate", DateTime.Now.ToString("MMMM dd, yyyy") },
    { "ContractValue", "$50,000" },
    { "PaymentTerms", "Net 30" },
    { "ServiceDescription", "Enterprise software implementation" }
};

// Loop through form fields and populate with data.
int formFieldCount = gdpicturePDF.GetFormFieldsCount();
for (int i = 0; i < formFieldCount; i++)
{
    int formFieldId = gdpicturePDF.GetFormFieldId(i);
    string formFieldTitle = gdpicturePDF.GetFormFieldTitle(formFieldId);

    // Set value if field matches our data.
    if (contractData.TryGetValue(formFieldTitle, out string value))
    {
        gdpicturePDF.SetFormFieldValue(formFieldId, value);
    }
}

// Flatten form fields to make them non-editable.
gdpicturePDF.FlattenFormFields();

// Save the generated contract.
gdpicturePDF.SaveToFile(@"C:\output\generated-contract.pdf");

Getting started

• Sign up for a free Nutrient trial
• Install the SDK for your platform
• Create a template with placeholder fields
• Connect your data source
• Generate documents programmatically

FAQ

Start generating documents with Nutrient

Document generation replaces manual document creation, reduces errors, and scales without additional effort — whether you’re producing 10 contracts or 10,000 invoices.

For developers and technical teams, Nutrient provides the control and flexibility that SaaS platforms can’t match:

• Multiplatform SDK — Web, iOS, Android, Windows, and server.
• Full programmatic control — Generate exactly the documents you need.
• Predictable pricing — No per-document fees eating into margins.
• Data stays local — Self-hosted and on-device SDKs keep your data within your infrastructure.
• Production-ready — Battle-tested across web, mobile, and server deployments.