Building a Privacy-First PDF Merger That Runs 100% in Your Browser (No Uploads, No Servers)

The Problem With Most PDF Mergers
A few months ago, I needed to combine five PDFs — a contract, some scanned receipts, and a few signed documents — into a single file to send to a client. Simple task, right?

I opened the first "free" PDF merger on Google. It asked me to upload my files. I tried another. It had a 5-file limit unless I paid. A third one flattened my PDFs into low-resolution images, ruining the text quality and making the file size balloon from 2MB to 15MB.

But the real issue wasn't the limits or the quality. It was trust.

Every single tool required me to upload my documents to their servers. For a contract with confidential pricing, that was a hard no. I realized that most people — especially those in legal, finance, and healthcare — face the same dilemma. They need to merge PDFs, but they can't risk uploading sensitive documents to unknown servers.

So I decided to build something different: a PDF merger where your files never leave your device.

The Core Challenge: Merging PDFs Without a Server
Merging PDFs client-side sounds simple. But there's a catch.

Most online PDF tools work by uploading your files to a server, processing them there, and sending the result back. This approach is easy to implement because servers have plenty of memory and processing power.

Doing it entirely in the browser, however, comes with unique challenges:

Memory constraints — Browsers have limits on how much memory a tab can use. Merging multiple large PDFs can quickly hit those limits.

File size limits — The browser needs to hold all PDFs in memory simultaneously.

Performance — Processing large files on the main thread can freeze the UI.

Format preservation — Many "mergers" actually rasterize PDFs into images, destroying text quality and increasing file size.

The Tech Stack I Used
Here's what I used to overcome these challenges:

PDF-Lib — For loading, manipulating, and saving PDFs entirely on the client-side

PDF.js — For rendering thumbnails and previewing pages

Web Workers — For background processing so the UI stays responsive

WebAssembly — For heavy lifting and faster PDF encoding

Vue.js — For reactive UI and state management

How Client-Side Merging Actually Works
The core logic is surprisingly elegant. Here's a simplified version:

`import { PDFDocument } from 'pdf-lib'

async function mergePDFs(files) {
// Create a new, empty PDF document
const mergedPdf = await PDFDocument.create()

// Loop through each uploaded file
for (const file of files) {
    // Read the file as ArrayBuffer
    const bytes = await file.arrayBuffer()
    // Load it with pdf-lib
    const pdf = await PDFDocument.load(bytes)
    // Copy all pages from this PDF
    const pages = await mergedPdf.copyPages(pdf, pdf.getPageIndices())
    // Add each page to the merged document
    pages.forEach(page => mergedPdf.addPage(page))
}

// Save the merged PDF
const pdfBytes = await mergedPdf.save()
return pdfBytes

`}

This is the simplest possible merge. But a production-ready tool needs more:

Async thumbnail generation — PDF.js renders the first page of each uploaded PDF as a visual thumbnail, so users can see what they're merging

Drag-and-drop reordering — Users can rearrange files visually before merging

Background processing — Web Workers handle the heavy lifting so the UI stays responsive

The Privacy Advantage: Zero Uploads
Here's what makes this approach truly different:

No network calls — Open your browser's Network tab while using the tool. You'll see zero uploads. The only thing that loads is the page itself.

Works offline — After the initial page load, you can turn off your Wi-Fi and the tool still works perfectly

No tracking — No analytics, no cookies, no data collection

Verifiable — Any developer can inspect the code and confirm that nothing leaves your browser

The Honest Tradeoffs
This approach isn't magic. Because everything runs on your device:

Very large files (100+ pages each) depend on your machine's memory

Older devices may struggle with multiple large files

Browser memory limits apply (though pdf-lib handles files up to a reasonable size)

I designed around this by processing files sequentially and using Web Workers to keep memory usage in check.

What I Learned
Building this tool taught me a few things:

1. People care deeply about privacy. The "no upload" feature isn't a nice-to-have — it's the primary reason many users choose a tool. For professionals handling sensitive documents, it's non-negotiable.

2. Client-side PDF processing is more capable than most people think. Libraries like pdf-lib and PDF.js have come incredibly far. You can do real, production-grade PDF manipulation entirely in the browser.

3. Visual feedback matters. Showing thumbnails of each PDF before merging gives users confidence that they're merging the right files in the right order.

4. Simplicity wins. No sign-up, no limits, no watermarks. People are genuinely frustrated with tools that put up barriers.

Try It Yourself
I've made this tool available for free at instantconvert.online/merge-pdf-online-unlimited-free/.

No sign-up. No uploads to any server. No watermarks. No file limits. Just a tool that does one thing and does it well — with privacy as the default, not an afterthought.

I'd love feedback from other builders. What PDF operations do you find yourself doing most often? What would you build next? Let me know in the comments!