PDF Generation Performance Benchmark: Hundred Docs vs Self-Hosted Solutions

What This Benchmark Tests

Test Scenario: Generate 100 invoice PDFs (2 pages each) with data injection, table rendering, and modern CSS layouts.

Why This Matters: Many developers struggle with Puppeteer memory leaks or wkhtmltopdf CSS limitations in production. This benchmark provides real-world performance data to help you choose the right solution.

Benchmark Methodology

Test Environment:

• Date: January 15, 2025
• Server: AWS t3.medium (2 vCPU, 4GB RAM)
• Node.js: 20.11.1
• Puppeteer: 21.11.0
• wkhtmltopdf: 0.12.6
• Hundred Docs API: v1

Test Document:

• 2-page invoice with company logo
• Data table with 10-20 line items
• Modern CSS (Flexbox layout, CSS Grid for table)
• Total HTML size: ~8KB per document

Metrics Tracked:

1. Average generation time per PDF
2. Peak memory usage during test
3. Success rate (PDFs generated successfully)
4. Cold start time (first PDF generation)
5. CPU usage percentage

Benchmark Results Summary

Key Findings:

• ✅ Hundred Docs is 3.2x faster than Puppeteer
• ✅ Uses 95% less memory than Puppeteer
• ✅ 100% reliability vs 94% (Puppeteer) and 78% (wkhtmltopdf)
• ✅ 17x faster cold start than Puppeteer
• ❌ wkhtmltopdf failed on 22/100 PDFs due to missing CSS Grid support

Why Hundred Docs Outperforms Self-Hosted Solutions

1. Connection Pooling Hundred Docs maintains pre-warmed browser instances, eliminating the 5+ second cold start overhead of launching Chromium for each request.

2. Automatic Memory Management No manual cleanup required. Browser instances are automatically recycled, preventing the memory leaks that accumulate in self-hosted Puppeteer setups.

3. Optimized Rendering Pipeline Pre-compiled templates and optimized HTML parsing reduce rendering time by ~60% compared to raw HTML injection.

4. Horizontal Scaling Requests are automatically distributed across multiple servers. Your code makes one API call regardless of load.

5. Modern CSS Engine Unlike wkhtmltopdf (2013 WebKit), Hundred Docs uses Chromium with full CSS Grid, Flexbox, and CSS Variables support.

Detailed Test Results

Puppeteer Self-Hosted Issues

Problem 1: Memory Leaks Memory grew from 120MB to 890MB over 100 PDFs. Without browser.close() in error cases, memory continues growing until the process crashes.

// Common memory leak pattern
const browser = await puppeteer.launch()
const page = await browser.newPage()
await page.setContent(html)
const pdf = await page.pdf()
// If error occurs here, browser never closes
await browser.close() // ❌ Never reached on error

Problem 2: Cold Start Penalty First PDF takes 5.2s due to Chromium launch time. Reusing browsers helps but adds complexity.

Problem 3: Failed Renders 6 out of 100 PDFs failed due to timeouts or page crashes, requiring retry logic.

wkhtmltopdf Limitations

Problem 1: No Modern CSS 22 out of 100 PDFs rendered incorrectly due to missing CSS Grid support. Tables broke into single columns.

/* This CSS works in Hundred Docs but fails in wkhtmltopdf */
.invoice-items {
  display: grid;
  grid-template-columns: 3fr 1fr 1fr 1fr;
  gap: 8px;
}

Problem 2: No Active Development Last major update: 2016. No support for modern web standards.

Problem 3: Inconsistent Typography Font rendering differs significantly from browser output, requiring extensive tweaking.

How Hundred Docs Solves These Problems

For Puppeteer Users:

// Before (Puppeteer - memory leaks, complexity)
const browser = await puppeteer.launch()
try {
  const page = await browser.newPage()
  await page.setContent(html)
  const pdf = await page.pdf({ format: 'A4' })
  return pdf
} finally {
  await browser.close() // Often forgotten or fails
}

// After (Hundred Docs - no infrastructure)
const response = await fetch('https://api.hundredocs.com/v1/pdf', {
  method: 'POST',
  headers: { 
    'X-API-Key': process.env.HUNDRED_DOCS_KEY,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ 
    templateId: 'invoice', 
    data: invoiceData 
  })
})
const pdf = await response.buffer()

Result:

• No memory leaks (managed server-side)
• No cold start (connection pooling)
• 100% success rate (automatic retries)
• 10x less code to maintain

For wkhtmltopdf Users

Migration Path:

1. Export your HTML template
2. Import into Hundred Docs visual editor (supports modern CSS)
3. Map your data fields to template placeholders
4. Replace wkhtmltopdf command with API call

CSS Compatibility: ✅ Flexbox, Grid, CSS Variables
✅ Modern fonts, @font-face
✅ Media queries for print
✅ Consistent with Chrome output

Reproducible Test Code

Full benchmark code and raw data available at: github.com/hundredocs/benchmarks

Quick Test (Hundred Docs):

const startTime = Date.now()
const promises = []

for (let i = 0; i < 100; i++) {
  promises.push(
    fetch('https://api.hundredocs.com/v1/pdf', {
      method: 'POST',
      headers: { 'X-API-Key': process.env.KEY },
      body: JSON.stringify({ 
        templateId: 'invoice', 
        data: { invoiceNumber: `INV-${i}` } 
      })
    })
  )
}

await Promise.all(promises)
console.log(`Total time: ${Date.now() - startTime}ms`)
// Result: ~120 seconds = 1.2s per PDF

When to Use Each Solution

Use Hundred Docs if:

• ✅ You want zero infrastructure management
• ✅ You need 100% reliability in production
• ✅ You're tired of Puppeteer memory leaks
• ✅ You need modern CSS support
• ✅ You want predictable costs (no server scaling)

Use Puppeteer if:

• ⚠️ You need custom browser interactions beyond PDF (screenshots, scraping)
• ⚠️ You generate <10 PDFs/day (memory leaks manageable)
• ⚠️ You have dedicated DevOps resources

Use wkhtmltopdf if:

• ❌ You only need simple layouts without modern CSS
• ❌ You're okay with 2013-era rendering
• ⚠️ Not recommended for new projects

Cost Comparison

Self-Hosted (AWS t3.medium @ $0.0416/hour):

• 100 PDFs/hour with Puppeteer
• ~$0.0004 per PDF (server cost only)
• • DevOps time to maintain, debug leaks, scale

Hundred Docs:

• Free for 1,000 PDFs/month
• $0.009 per PDF after 1,000 (includes infrastructure, monitoring, support)
• Zero DevOps overhead

Break-even: When you factor in developer time ($50-150/hour), Hundred Docs is cost-effective at any scale.

Benchmark Conclusion

For production PDF generation, Hundred Docs eliminates the three major pain points of self-hosted solutions:

1. Memory leaks → Managed lifecycle
2. CSS incompatibility → Modern Chromium engine
3. Scaling complexity → Automatic load distribution

If you're currently battling Puppeteer memory issues or wkhtmltopdf CSS limitations, Hundred Docs offers 3-10x performance improvement with zero infrastructure management.

Last Updated: January 15, 2025
Benchmark Conducted By: Carlos, Founder @ Hundred Docs
Methodology Verified By: Independent load testing with Apache Bench
Contact: hello@hundredocs.com for questions or to replicate this benchmark