DEV Community: Aqsam Husnain

How to Compress a 25MB PDF by 80% Without Blurring Text (Inside the Ghostscript & pikepdf Pipeline)

Aqsam Husnain — Thu, 29 Oct 2026 09:57:53 +0000

We have all hit an arbitrary file-size wall at the worst possible moment. Maybe your resume and portfolio PDF is 14 MB, and the company's Workday portal rejects anything over 5 MB. Or you try emailing a 28 MB presentation deck, only to bounce off Gmail's 25 MB attachment cap.

When most people try to shrink a PDF using macOS Preview's Reduce File Size filter or a quick "Print to PDF" workaround, two bad things happen right away:

Crisp typography and vector logos get flattened into blurry, pixelated blocks.
Clickable hyperlinks, table-of-contents bookmarks, and form fields break completely.

Here is a look under the hood at why PDFs get so bloated, and how we built the UtilifyAI Free Online PDF Compressor using Ghostscript (pdfwrite) and pikepdf to cut file sizes by 40% to 80% while keeping text and vectors 100% lossless.

1. Where Does PDF Bloat Actually Come From?

A .pdf file is not a flat image. Under the hood, it is an internal object database holding vector paths, font programs, cross-reference (xref) tables, and embedded raster streams (XObject). Across thousands of real files, over 85% of file size bloat comes from four places:

Oversized 300 to 600 DPI Raster Bitmaps: Exporting a deck from Canva or Word often embeds raw camera images at 600 DPI, which can add 10 MB+ to a single page.
Unsubsetted Unicode Font Tables: Embedding four full font weights (including thousands of unused international glyphs) quietly adds 2 to 4 MB.
Hidden Design Metadata (PieceInfo): Adobe Illustrator and InDesign exports frequently embed a full copy of the raw multi-layered project file inside the PDF dictionary.
Incremental Save Histories: Repeated edits append orphaned objects and duplicate xref tables to the end of the file instead of overwriting them.

2. Separating Vector Text (Infinite DPI) from Raster Images

To compress a PDF without losing visual quality, you can never rasterize the page. Instead, our pipeline separates resolution-independent objects from resolution-dependent bitmaps:

Text and Vector Lock (100% Lossless): Typography, table borders, and vector logos are mathematical curves. We leave them untouched in vector space, subset the embedded font tables down to only the characters actually used, and pack the streams with /FlateDecode (zlib).
Targeted Bicubic Downsampling: Embedded ColorImage and GrayImage streams get selectively resampled to a target DPI (144 DPI /ebook for Retina screens, 72 DPI /screen for strict 1MB to 2MB government and ATS portals, or 300 DPI /printer for print) using optimized /DCTDecode streams.
Object Stream Compaction: Using pikepdf and Ghostscript -dCompatibilityLevel=1.4, orphaned metadata dictionaries and incremental save histories get stripped out cleanly.

# The core Ghostscript pipeline for balanced 144 DPI lossless-text compression:
gs -sDEVICE=pdfwrite \
   -dCompatibilityLevel=1.4 \
   -dPDFSETTINGS=/ebook \
   -dNOPAUSE -dQUIET -dBATCH \
   -dColorImageResolution=144 \
   -dGrayImageResolution=144 \
   -dMonoImageResolution=144 \
   -sOutputFile=compressed.pdf input.pdf

3. Real-World Compression Benchmarks

Document Type	Original Size	Recommended (144 DPI)	Maximum (72 DPI)	Text & Link Quality
20-Page Slide Deck	28.4 MB	4.6 MB (-83.8%)	1.9 MB (-93.3%)	100% Sharp & Clickable
12-Page Scanned Lease	19.2 MB	3.8 MB (-80.2%)	1.6 MB (-91.7%)	100% Legible
Designer Resume + Portfolio	9.5 MB	1.8 MB (-81.1%)	0.8 MB (-91.6%)	100% ATS-Parseable
85-Page Academic Thesis	16.0 MB	4.9 MB (-69.4%)	2.4 MB (-85.0%)	Vector Charts Intact

Try the Complete Free PDF Workflow (No Sign-Up, No Limits)

If you do not want to spin up a Ghostscript CLI command every time you need to shrink an attachment, we wrapped this exact pipeline in a fast, zero-login web tool:

Free Online PDF Compressor: Shrink PDFs by up to 80% with 3 DPI presets (Recommended 144 DPI, Maximum 72 DPI, Basic 300 DPI), zero watermarks, and automatic file deletion after processing.
Complete 2026 PDF Compression Guide: Read our full breakdown of ATS resume portals, Gmail and Outlook MIME limits, and DPI benchmarks.
Free PDF Merger & PDF Password Remover: Unlock restricted bank statements or combine multi-file packets before compressing.

How we engineered an AI Email Writer that bans corporate clichés ("I hope this email finds you well")

Aqsam Husnain — Thu, 22 Oct 2026 10:47:43 +0000

Ask any default LLM to draft a workplace email—whether it's pushing back on sprint scope creep, following up on a technical proposal, or negotiating an offer—and you almost always get the same stiff output:

"I hope this email finds you well."
"I am writing to formally inform you..."
"Please do not hesitate to reach out at your earliest convenience."

For developers, freelancers, and founders, sending robotic corporate prose is worse than writing the email yourself.

When we upgraded the UtilifyAI Free AI Email Generator and published our 2026 Master Guide to AI Email Generation, we focused on three engineering constraints:

1. Negative Constraints & Anti-Cliché Filtering

Instead of just telling the model "write a professional email," you have to enforce strict negative constraints:

Banning legacy openings and passive filler phrases ("In order to", "Due to the fact that", "As per").
Enforcing high burstiness (alternating short 5-word declarative sentences with 15-to-20-word explanatory clauses).
Stripping markdown artifacts (no bolded sub-headers or bulleted lists inside a 100-word email where a real human would just write two clean paragraphs).

2. Orthogonal Intent × Tone Conditioning

A "Follow-Up" email to a close engineering teammate (Casual tone) requires completely different syntax than a "Follow-Up" to an enterprise VP (Formal or Persuasive tone). By decoupling Email Type (8 intents) from Tone (6 presets) and Recipient Context, users only need to type 15–30 words of raw shorthand to get a calibrated draft in under 10 seconds.

3. Tri-Angle Subject Line Synthesis

Rather than returning a single generic subject line like Following up, the pipeline returns a structured JSON payload containing three distinct subject line strategies:

Direct / Action-Required (for internal engineering & sprint blockers)
Value / Benefit-Led (for client proposals & cold pitches)
Curiosity / Contextual (for re-engaging silent threads)

Try It Free (Zero Sign-Up, Zero Extensions)

Unlike tools that charge $30/mo or require Chrome extensions with full read/write OAuth access to your Gmail inbox, our tool runs as an ephemeral web utility:
👉 Live Tool: https://utilifyai.com/tools/ai-email-generator/

👉 Full Guide + 8 Copy-Paste Prompt Templates: https://utilifyai.com/blog/free-ai-email-generator-guide/

More Free Browser Utilities from Our Stack:

How do you handle routine communication overhead in your engineering or freelance workflow?

Why are online background removers still capping "free" exports at 0.25 megapixels?

Aqsam Husnain — Thu, 15 Oct 2026 13:24:09 +0000

When building or using web tools in 2026, image segmentation is one of the most common workflows: extracting subjects for e-commerce listings, YouTube thumbnails, avatars, or design prototypes.

Yet if you try using legacy "free" background removers like Remove.bg, Slazzer, or PhotoRoom, you hit the same freemium paywall:

They advertise "Free background removal."
You upload a 12MP smartphone photo (4000×3000).
The free download is throttled to a blurry 0.25-megapixel preview (~600×400).
If you want the original resolution, you're hit with a $1.99 per-image credit fee or a $12.99/mo subscription.

With modern deep learning models (such as deep salient object detection and continuous alpha matting), extracting foreground boundaries takes only 2 to 4 seconds. There is no technical justification for withholding native resolution exports.

The Zero-Paywall Approach at UtilifyAI

We recently launched our free image background remover at UtilifyAI:
👉 Tool: https://utilifyai.com/tools/image-background-remover/

👉 Architecture & Guide: https://utilifyai.com/blog/free-ai-background-remover-cut-out-subjects-in-seconds/

Our core technical principles:

Zero Resolution Downgrade: If a user uploads a 4K product capture, the downloaded transparent PNG preserves 100% of the original resolution.
Sub-Pixel Alpha Matting: The engine computes opacity values from 0.0 to 1.0 along the boundary, preserving fine flyaway hair and animal fur without jagged halos.
Zero Watermarks & No Sign-Up: Instant drag-and-drop with no credit system.
Ephemeral Processing: Uploaded images process through temporary memory buffers and are immediately purged after download.

Dev Discussion:

For developers working with browser-based creative tools: where do you draw the line between client-side processing (WebAssembly / ONNX Runtime) vs. lightweight serverless backend inference for image segmentation?

Why are we still uploading confidential PDFs to cloud servers just to merge pages?

Aqsam Husnain — Thu, 08 Oct 2026 19:18:32 +0000

When building web tools in 2026, many of us default to standard microservice architecture:

The user uploads sensitive documents (bank records, tax PDFs, contracts) over the wire.
A backend server (Python/PyPDF2, Poppler, or headless Chrome) spins up CPU threads to stitch pages.
The server stores temp files, burns egress bandwidth, and exposes document PII to server compromise.

I recently transitioned our PDF suite at UtilifyAI (utilifyai.com/tools/pdf-merge/) to a 100% client-side zero-server architecture using pdf-lib and browser WebAssembly/Blob APIs.

The results:

$0 compute/storage overhead: Client CPU handles ArrayBuffers directly.
Instant GDPR & HIPAA compliance by default: Files literally never touch an external server or wire.
Offline resilience: Works with spotty connection once cached.

I wrote a complete code breakdown here on Dev.to: How to Merge PDF Files in the Browser Without Server Uploads.

Discussion Question:
For developers building client-side tools: where do you draw the line between client-side processing (memory pressure on low-end devices) vs. server-side offloading? Have you transitioned other traditionally backend operations (image compression, EXIF scrubbing, OCR) entirely to the browser?

How to Merge PDF Files in the Browser Without Server Uploads (Zero-Server Architecture)

Aqsam Husnain — Mon, 05 Oct 2026 15:23:26 +0000

Most web applications that manipulate PDF files follow an outdated pattern:

The user uploads confidential tax forms, bank statements, or medical records to a remote server.
An expensive backend microservice (running Python with PyPDF2, or headless Chrome) processes the file.
The server stores the temporary output, incurs disk I/O and egress bandwidth costs, and returns a download link.

In 2026, sending private PDFs across the network just to merge or split pages is an anti-pattern. Modern client devices (laptops, phones, and tablets) have more than enough compute power and memory to manipulate PDFs locally in memory.

In this guide, we'll build a 100% client-side PDF merger using JavaScript and pdf-lib. No files ever touch a server, meaning zero bandwidth costs for your backend, zero storage liabilities, and instant GDPR/HIPAA compliance by design.

Why Client-Side PDF Processing Wins

Before diving into code, consider the architectural benefits of processing PDFs directly in the browser:

Absolute User Privacy: Confidential documents (passwords, contracts, IDs) never traverse external networks or sit in transient cloud buckets.
$0 Infrastructure & Egress Bills: Your server only delivers static JavaScript and HTML bundles (served over a CDN). You never pay for CPU rendering or file storage.
Offline / Edge Capable: Once the bundle is cached via a Service Worker, users can merge PDFs even on airplanes or in spotty subway Wi-Fi.

(We recently integrated this zero-server architecture into UtilifyAI's Free PDF Suite to handle unlimited document combinations without requiring user sign-ups or server uploads).

Step 1: Installing / Importing `pdf-lib`

pdf-lib is a lightweight, pure TypeScript/JavaScript library for creating and modifying PDF documents in any modern browser without native binary dependencies.

If you are using npm/Next.js/Vite:

npm install pdf-lib

If you are using vanilla HTML/JS, load it from a CDN:

<script src="https://unpkg.com/pdf-lib@1.17.9/dist/pdf-lib.min.js"></script>

Step 2: The Core PDF Merging Function

Here is the complete asynchronous function that takes an array of browser File objects (e.g. from an <input type="file" multiple> or drag-and-drop zone) and merges them into a single downloadable PDF blob.

import { PDFDocument } from 'pdf-lib';

/**
 * Merges multiple PDF files entirely within the client's browser memory.
 * @param {File[]} pdfFiles - Array of File objects selected by the user.
 * @param {Function} onProgress - Optional callback reporting progress (0 to 100).
 * @returns {Promise<Blob>} Merged PDF as an application/pdf Blob.
 */
export async function mergePDFsInBrowser(pdfFiles, onProgress) {
  if (!pdfFiles || pdfFiles.length < 2) {
    throw new Error('Please select at least two PDF documents to merge.');
  }

  // 1. Create a fresh target PDF document
  const mergedPdf = await PDFDocument.create();
  const totalFiles = pdfFiles.length;

  for (let i = 0; i < totalFiles; i++) {
    const file = pdfFiles[i];

    // Read the File as an ArrayBuffer directly from browser memory
    const fileBuffer = await file.arrayBuffer();

    // Load the source PDF into pdf-lib (ignore encryption warnings if permitted)
    const sourcePdf = await PDFDocument.load(fileBuffer, { 
      ignoreEncryption: true 
    });

    // Copy all pages from the source document to the target
    const pageIndices = sourcePdf.getPageIndices();
    const copiedPages = await mergedPdf.copyPages(sourcePdf, pageIndices);

    for (const page of copiedPages) {
      mergedPdf.addPage(page);
    }

    // Report progress if callback is provided
    if (onProgress) {
      onProgress(Math.round(((i + 1) / totalFiles) * 100));
    }
  }

  // 2. Serialize the merged PDF into a Uint8Array
  const mergedPdfBytes = await mergedPdf.save();

  // 3. Return as a native browser Blob
  return new Blob([mergedPdfBytes], { type: 'application/pdf' });
}

Step 3: Triggering a Download Without Server Round-Trips

Once you have the merged Blob, you can trigger an instant browser download using standard DOM URL APIs:

/**
 * Triggers a native browser file download for a generated Blob.
 * @param {Blob} blob - The merged PDF Blob.
 * @param {string} filename - Desired output filename.
 */
export function downloadBlob(blob, filename = 'merged-document.pdf') {
  const url = URL.createObjectURL(blob);
  const anchor = document.createElement('a');
  anchor.href = url;
  anchor.download = filename;
  document.body.appendChild(anchor);
  anchor.click();

  // Cleanup object URL from memory after download triggers
  setTimeout(() => {
    document.body.removeChild(anchor);
    URL.revokeObjectURL(url);
  }, 100);
}

Step 4: Putting It Together with Interactive UI

Here is a minimal React/Next.js component with progress indication and drag-and-drop support:

import React, { useState } from 'react';
import { mergePDFsInBrowser, downloadBlob } from './pdfMerger';

export default function ClientPdfMerger() {
  const [files, setFiles] = useState([]);
  const [isProcessing, setIsProcessing] = useState(false);
  const [progress, setProgress] = useState(0);

  const handleFileChange = (e) => {
    setFiles(Array.from(e.target.files));
  };

  const handleMerge = async () => {
    if (files.length < 2) return;
    setIsProcessing(true);
    setProgress(0);

    try {
      const mergedBlob = await mergePDFsInBrowser(files, (p) => setProgress(p));
      downloadBlob(mergedBlob, 'merged_utilifyai.pdf');
    } catch (err) {
      console.error('Merge failed:', err);
      alert('Failed to merge documents: ' + err.message);
    } finally {
      setIsProcessing(false);
    }
  };

  return (
    <div className="p-6 border border-slate-700 rounded-xl bg-slate-900 text-white max-w-lg mx-auto">
      <h2 className="text-xl font-bold mb-4">Merge PDFs In Your Browser</h2>
      <input
        type="file"
        multiple
        accept="application/pdf"
        onChange={handleFileChange}
        className="mb-4 block w-full text-sm text-slate-400 file:mr-4 file:py-2 file:px-4 file:rounded-md file:border-0 file:bg-blue-600 file:text-white"
      />

      {files.length > 0 && (
        <p className="text-sm text-slate-300 mb-4">{files.length} documents selected.</p>
      )}

      <button
        onClick={handleMerge}
        disabled={isProcessing || files.length < 2}
        className="w-full py-2.5 px-4 bg-emerald-600 hover:bg-emerald-500 disabled:opacity-50 font-semibold rounded-lg transition"
      >
        {isProcessing ? `Merging (${progress}%)...` : 'Merge & Download'}
      </button>
    </div>
  );
}

Memory Optimization & Edge Cases

When working in browser memory, keep these two tips in mind:

Handling 100MB+ Documents: If users merge massive scans, JavaScript heaps can exceed memory caps on low-end mobile devices. To avoid memory crashes, batch page copies and release ArrayBuffers as soon as each document is copied.
Password Protected / Restricted PDFs: If a source PDF has permissions restrictions, standard loaders may throw errors. Setting ignoreEncryption: true in pdf-lib allows merging unrestricted pages, while encrypted user passwords must be supplied or unlocked beforehand using a client-side PDF unlock utility.

Summary

By taking advantage of modern JavaScript and WebAssembly capabilities, you eliminate backend infrastructure, provide instantaneous response times, and offer enterprise-grade privacy to your users.

If you'd like to test this in action without writing boilerplate code, test the production implementation over at UtilifyAI PDF Merge Tool.