DEV Community: Anurag Bhattarai

How I built 15 PDF tools that run entirely in the browser (no server, no uploads)

Anurag Bhattarai — Mon, 27 Apr 2026 10:45:49 +0000

When I started building Tooliest, I made one rule for myself: no file ever gets uploaded to a server. Every tool had to run entirely in the browser.

Most categories were straightforward. A JSON formatter is just:

JSON.stringify(JSON.parse(input), null, 2)

A regex tester is a few lines of JavaScript. A CSS gradient generator is sliders and template literals.

Then I got to PDF tools.

PDF is a notoriously complex format. It's a 700-page specification. Most "browser-based" PDF tools are actually just thin frontends that POST your file to a backend running LibreOffice or Ghostscript. The no-upload constraint meant I had to find a completely different approach.

Here's exactly how I built 15 PDF tools that genuinely run in the browser — the libraries I used, the architecture decisions, and the edge cases that bit me.

The core library: pdf-lib

pdf-lib is a pure JavaScript library for creating and modifying PDFs. No native dependencies, no WebAssembly binary to load, no backend. It runs in any modern browser.

Install:

npm install pdf-lib

Or via CDN:

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

The mental model is clean. You load a PDF into a PDFDocument object, manipulate pages and content, then call .save() to get raw bytes back:

import { PDFDocument, StandardFonts, rgb } from 'pdf-lib';

const pdfDoc = await PDFDocument.create();
const page = pdfDoc.addPage([595, 842]); // A4 dimensions in points
const font = await pdfDoc.embedFont(StandardFonts.Helvetica);

page.drawText('Hello from the browser', {
  x: 50,
  y: 750,
  size: 30,
  font,
  color: rgb(0, 0, 0),
});

const pdfBytes = await pdfDoc.save();

// Download it
const blob = new Blob([pdfBytes], { type: 'application/pdf' });
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = 'output.pdf';
a.click();

Everything happens in memory. Nothing touches a server. Let's build the actual tools.

1. PDF Merger

The most-used tool on the site. The logic is surprisingly clean:

import { PDFDocument } from 'pdf-lib';

async function mergePDFs(fileArray) {
  const mergedPdf = await PDFDocument.create();

  for (const file of fileArray) {
    const arrayBuffer = await file.arrayBuffer();
    const pdf = await PDFDocument.load(arrayBuffer);
    const pageIndices = pdf.getPageIndices();
    const copiedPages = await mergedPdf.copyPages(pdf, pageIndices);
    copiedPages.forEach(page => mergedPdf.addPage(page));
  }

  const mergedBytes = await mergedPdf.save();
  return mergedBytes;
}

copyPages is the key method here — it handles all internal reference resolution. Fonts, images, and annotations embedded in each source page all get carried across correctly into the new document. You don't have to think about the internal PDF object graph at all.

The UI layer uses drag-and-drop for file ordering, and PDF.js to render thumbnail previews of each page before the user commits to the merge. More on thumbnail rendering below.

2. PDF Splitter

Split a PDF by custom page ranges, extract specific pages, or divide into equal chunks:

async function splitPDF(file, ranges) {
  // ranges is an array of page index arrays
  // e.g. [[0, 1, 2], [3, 4], [5, 6, 7]] → three separate PDFs

  const arrayBuffer = await file.arrayBuffer();
  const sourcePdf = await PDFDocument.load(arrayBuffer);
  const outputFiles = [];

  for (const pageIndices of ranges) {
    const newPdf = await PDFDocument.create();
    const copiedPages = await newPdf.copyPages(sourcePdf, pageIndices);
    copiedPages.forEach(page => newPdf.addPage(page));
    const bytes = await newPdf.save();
    outputFiles.push(bytes);
  }

  return outputFiles;
}

For the UI, I parse a range string like "1-3, 5, 7-9" into index arrays:

function parsePageRanges(rangeString, totalPages) {
  const ranges = [];
  const parts = rangeString.split(',').map(s => s.trim());

  for (const part of parts) {
    if (part.includes('-')) {
      const [start, end] = part.split('-').map(n => parseInt(n) - 1);
      const indices = [];
      for (let i = start; i <= Math.min(end, totalPages - 1); i++) {
        indices.push(i);
      }
      ranges.push(indices);
    } else {
      const pageNum = parseInt(part) - 1;
      if (pageNum >= 0 && pageNum < totalPages) {
        ranges.push([pageNum]);
      }
    }
  }

  return ranges;
}

3. PDF Compressor

This is where things get more nuanced. pdf-lib doesn't natively resample images embedded inside PDFs — it just repacks the document structure.

Two-level compression strategy:

Level 1 — Structure compression (always applied):

const compressedBytes = await pdfDoc.save({
  useObjectStreams: true,  // Compresses internal stream objects
});

useObjectStreams: true compresses the internal object streams and typically reduces file size by 10–25% with zero quality loss. Always use this.

Level 2 — Image resampling (for aggressive compression):

For deeper compression, I render each page to a canvas via PDF.js at reduced scale, then re-embed the result:

import * as pdfjsLib from 'pdfjs-dist';

async function compressByRendering(arrayBuffer, scale = 0.8) {
  const pdf = await pdfjsLib.getDocument({ data: arrayBuffer }).promise;
  const newPdf = await PDFDocument.create();

  for (let i = 1; i <= pdf.numPages; i++) {
    const page = await pdf.getPage(i);
    const viewport = page.getViewport({ scale });

    const canvas = document.createElement('canvas');
    canvas.width = viewport.width;
    canvas.height = viewport.height;

    await page.render({
      canvasContext: canvas.getContext('2d'),
      viewport,
    }).promise;

    const imageData = canvas.toDataURL('image/jpeg', 0.75);
    const base64 = imageData.split(',')[1];
    const imageBytes = Uint8Array.from(atob(base64), c => c.charCodeAt(0));
    const jpegImage = await newPdf.embedJpg(imageBytes);

    const { width, height } = viewport;
    const newPage = newPdf.addPage([width, height]);
    newPage.drawImage(jpegImage, { x: 0, y: 0, width, height });
  }

  return await newPdf.save({ useObjectStreams: true });
}

⚠️ Trade-off: Level 2 compression converts vector text to rasterized JPEG, which looks fine on screen but loses text selectability and sharpness when printed at high DPI. I give users both options and label them clearly.

4. PDF Password Protection

pdf-lib has built-in encryption support:

async function protectPDF(file, userPassword, ownerPassword) {
  const arrayBuffer = await file.arrayBuffer();
  const pdfDoc = await PDFDocument.load(arrayBuffer);

  const pdfBytes = await pdfDoc.save({
    encrypted: true,
    userPassword: userPassword,
    ownerPassword: ownerPassword || userPassword,
    permissions: {
      printing: 'lowResolution',
      modifying: false,
      copying: false,
      annotating: false,
      fillingForms: true,
      contentAccessibility: true,
      documentAssembly: false,
    },
  });

  return pdfBytes;
}

This generates AES-128 encrypted output that Acrobat, Preview, Foxit, and every standard PDF reader respects. The permissions object lets you set fine-grained access — for example, allowing form filling but blocking copy-paste.

5. PDF Watermark

Text watermarks across every page, with rotation and opacity:

import { PDFDocument, StandardFonts, rgb, degrees } from 'pdf-lib';

async function addWatermark(file, text, options = {}) {
  const {
    opacity = 0.3,
    angle = 45,
    fontSize = 60,
    color = rgb(0.5, 0.5, 0.5),
  } = options;

  const arrayBuffer = await file.arrayBuffer();
  const pdfDoc = await PDFDocument.load(arrayBuffer);
  const font = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
  const pages = pdfDoc.getPages();

  for (const page of pages) {
    const { width, height } = page.getSize();
    const textWidth = font.widthOfTextAtSize(text, fontSize);

    page.drawText(text, {
      x: width / 2 - textWidth / 2,
      y: height / 2 - fontSize / 2,
      size: fontSize,
      font,
      color,
      opacity,
      rotate: degrees(angle),
    });
  }

  return await pdfDoc.save();
}

6. PDF Page Rotator

import { PDFDocument, degrees } from 'pdf-lib';

async function rotatePages(file, pageIndices, rotation) {
  // rotation: 90, 180, or 270
  const arrayBuffer = await file.arrayBuffer();
  const pdfDoc = await PDFDocument.load(arrayBuffer);
  const pages = pdfDoc.getPages();

  for (const index of pageIndices) {
    const page = pages[index];
    const currentRotation = page.getRotation().angle;
    page.setRotation(degrees((currentRotation + rotation) % 360));
  }

  return await pdfDoc.save();
}

7. PDF Page Numbers

import { PDFDocument, StandardFonts, rgb } from 'pdf-lib';

async function addPageNumbers(file, options = {}) {
  const {
    position = 'bottom-center',
    startNumber = 1,
    fontSize = 12,
    format = 'Page {n} of {total}',
  } = options;

  const arrayBuffer = await file.arrayBuffer();
  const pdfDoc = await PDFDocument.load(arrayBuffer);
  const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
  const pages = pdfDoc.getPages();
  const total = pages.length;

  pages.forEach((page, i) => {
    const { width, height } = page.getSize();
    const label = format
      .replace('{n}', i + startNumber)
      .replace('{total}', total + startNumber - 1);

    const textWidth = font.widthOfTextAtSize(label, fontSize);

    const positions = {
      'bottom-center': { x: width / 2 - textWidth / 2, y: 20 },
      'bottom-right': { x: width - textWidth - 20, y: 20 },
      'bottom-left': { x: 20, y: 20 },
      'top-center': { x: width / 2 - textWidth / 2, y: height - 30 },
    };

    const { x, y } = positions[position] || positions['bottom-center'];

    page.drawText(label, {
      x, y,
      size: fontSize,
      font,
      color: rgb(0, 0, 0),
    });
  });

  return await pdfDoc.save();
}

The Web Worker architecture (critical for large files)

Processing a 50MB PDF on the main thread freezes the browser tab. The fix is straightforward — move all pdf-lib work into a Web Worker and transfer ArrayBuffer ownership instead of copying it:

// main.js
const worker = new Worker('pdf-worker.js');

const fileBuffer = await file.arrayBuffer();

worker.postMessage(
  { action: 'merge', buffers: [fileBuffer] },
  [fileBuffer]   // Transfer ownership — avoids 50MB copy
);

worker.onmessage = (e) => {
  const { result } = e.data;
  downloadPDF(result);
};

worker.onerror = (e) => {
  console.error('Worker error:', e.message);
};

// pdf-worker.js
importScripts('https://unpkg.com/pdf-lib/dist/pdf-lib.min.js');

const { PDFDocument } = PDFLib;

self.onmessage = async (e) => {
  const { action, buffers } = e.data;

  try {
    let result;
    if (action === 'merge') result = await mergePDFs(buffers);
    if (action === 'split') result = await splitPDF(buffers[0], e.data.ranges);

    self.postMessage({ result }, [result.buffer]);
  } catch (err) {
    self.postMessage({ error: err.message });
  }
};

The [fileBuffer] in postMessage transfers ownership of the buffer to the worker thread — the main thread can no longer access it, but you avoid a full memory copy. For a 50MB file, this is the difference between 50MB and 100MB peak memory usage.

Page thumbnail previews with PDF.js

The merger, splitter, and page reorder tools all need visual page previews. That's PDF.js territory:

import * as pdfjsLib from 'pdfjs-dist';
pdfjsLib.GlobalWorkerOptions.workerSrc =
  'https://unpkg.com/pdfjs-dist/build/pdf.worker.min.js';

async function renderThumbnail(arrayBuffer, pageNumber, canvas, scale = 0.25) {
  const pdf = await pdfjsLib.getDocument({ data: new Uint8Array(arrayBuffer) }).promise;
  const page = await pdf.getPage(pageNumber); // 1-indexed
  const viewport = page.getViewport({ scale });

  canvas.width = viewport.width;
  canvas.height = viewport.height;

  await page.render({
    canvasContext: canvas.getContext('2d'),
    viewport,
  }).promise;
}

Render at scale: 0.25 for thumbnails — fast to generate and sufficient resolution for a visual preview. For the full-size preview modal, use scale: 1.0.

Handling encrypted PDFs

Some user PDFs are password-protected. pdf-lib throws when you try to load them without providing the password:

async function loadPDFSafely(arrayBuffer, password = '') {
  try {
    return await PDFDocument.load(arrayBuffer, {
      password,
      ignoreEncryption: false,
    });
  } catch (err) {
    if (err.message.includes('encrypted')) {
      throw new Error('This PDF is password protected. Please enter the password.');
    }
    throw err;
  }
}

Show a password input field in the UI when this error is caught, then retry with the user-provided password.

The complete PDF tool list

All 15 tools built with this stack:

Tool	Key technique
PDF Merger	`copyPages` across multiple documents
PDF Splitter	Range parsing + selective `copyPages`
PDF Compressor	`useObjectStreams` + optional canvas re-render
PDF Page Rotator	`page.setRotation(degrees(...))`
PDF Page Reorder	Drag-and-drop indices + selective `copyPages`
PDF Page Extractor	Single-range split
PDF Page Deleter	Inverted page selection
PDF Watermark	`page.drawText` with opacity + rotation
PDF Page Numbers	`page.drawText` with position calculation
PDF Password Protect	`save({ encrypted: true, ... })`
Online Signature Maker	Canvas drawing → PNG → `embedPng`
PDF to Images	PDF.js page render → canvas → download
Images to PDF	`embedJpg` / `embedPng` + `addPage`
Text to PDF	`drawText` with line-wrapping logic
PDF to Text	PDF.js `getTextContent()`

What I'd do differently

Use a SharedArrayBuffer for very large files. For PDFs above 100MB, even transferring ownership has overhead. SharedArrayBuffer lets both threads access the same memory without any transfer cost — though it requires Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy headers, which complicated my Netlify config.

Lazy-load pdf-lib. At 800KB minified, pdf-lib is not small. I now only import it when a user actually opens a PDF tool, not on initial page load. Shaved ~1.2 seconds off Time to Interactive for non-PDF pages.

Stream large output files. For PDFs above ~30MB output, calling URL.createObjectURL(blob) and triggering a download works fine. But showing progress during the save operation requires streaming, which pdf-lib doesn't natively support yet. Something to watch in future releases.

Try the tools

👉 tooliest.com/category/pdf — all 15 PDF tools, nothing uploaded.

If you hit a specific edge case I haven't covered — encrypted PDFs, unusual page sizes, corrupted source files — drop it in the comments. I've been through most of the weird cases at this point and happy to share what I found.

The full stack for Tooliest is static HTML/JS on Netlify free tier — $0 hosting, global CDN, zero backend. If you're building browser-based tools and want to compare notes on the architecture, find me in the comments.

The best free browser tools for developers in 2026 (no signup, no upload)

Anurag Bhattarai — Mon, 27 Apr 2026 10:43:10 +0000

Every developer has a collection of online tools they use weekly. The problem is most of them are either paywalled, require an account, or quietly upload your files to a server you've never heard of.

This is a list of the best free browser-based tools that require no signup and process everything locally — your data never leaves your device.

I'll be upfront: many of these are from Tooliest, which I built. But I'll also point to alternatives where they genuinely do something better.

JSON tools

What you need: A formatter that handles large files without lagging, validates syntax properly, and ideally shows a tree view.

🔗 Tooliest JSON Formatter — formats, validates, and shows a collapsible tree view. Also has a minifier and a JSON ↔ CSV converter in the same category.

Alternative worth knowing: jsonlint.com — older, simpler, but very fast for quick validation.

PDF tools

What you need: Merge, split, compress, rotate. Most "free" PDF tools online upload your file to their server, show you a download link, and delete it "after 24 hours." Maybe.

🔗 Tooliest PDF Suite — 15 PDF tools, all running via pdf-lib in the browser. The file genuinely never goes anywhere. Covers merge, split, compress, rotate, watermark, password protect, page reorder, extractor, and more.

This is the one category where the no-upload constraint matters most, especially for documents that contain sensitive information.

Regex testing

What you need: Live match highlighting, capture group display, flag toggles, and ideally the ability to test against multiple strings.

🔗 Tooliest Regex Tester — real-time matching with group highlighting as you type.

Alternative: regex101.com — the gold standard for regex testing. More powerful, particularly for complex patterns with full explanation panels. Use regex101 when you need the detailed breakdown; Tooliest when you want it fast in the same tab as your other tools.

Code screenshots

What you need: Syntax-highlighted, shareable code images for Twitter, documentation, or presentations.

🔗 Tooliest Code Screenshot Generator — 20+ themes, 20+ languages, customizable window chrome and gradient backgrounds. Downloads as PNG or SVG. Nothing leaves your browser.

Alternative: ray.so by Raycast — beautiful output, slightly more limited theme options.

CSS generators

Three that actually save time:

🔗 CSS Gradient Generator — linear and radial gradients, live preview, copy-ready CSS output.

🔗 Box Shadow Generator — adjust offset, blur, spread, color, inset. See it live, copy the CSS.

🔗 Flexbox Playground — toggle all flex properties visually. Useful when you forget which direction flex-direction: column goes for the hundredth time.

JWT decoding

What you need: Paste a JWT, see the header and payload decoded, verify the structure.

🔗 Tooliest JWT Decoder — decodes header, payload, and shows the signature section. Entirely client-side — your token never gets sent anywhere, which matters since JWTs often contain auth data.

Alternative: jwt.io — the standard, built by Auth0. More features for signature verification.

Diff checking

What you need: Paste two versions of text or code, see exactly what changed.

🔗 Tooliest Diff Checker — side-by-side comparison with additions and deletions highlighted inline.

Alternative: diffchecker.com — more robust for large files, though the free version now has some limitations.

Image compression

What you need: Drop in a PNG or JPG, get a smaller file without visible quality loss.

🔗 Tooliest Image Compressor — handles JPG, PNG, WebP, AVIF. Canvas-based compression runs locally, nothing uploaded.

Alternative: squoosh.app by Google — the benchmark for browser-based image compression. More codec options, more control. Use Squoosh when quality precision matters; Tooliest when you want fast and frictionless.

Invoice generation

What you need: A professional invoice with your logo, line items, tax calculation, and PDF export — without paying for FreshBooks or Wave.

🔗 Tooliest Invoice Generator — add your logo, line items, tax rates, discounts, and custom notes. Downloads as PDF instantly. Browser-side, no account, works offline.

Cron expression parsing

What you need: You wrote 0 */6 * * 1-5 and now you need to know what that actually runs.

🔗 Tooliest Cron Parser — paste any cron expression, get a plain English description plus next scheduled run times.

Alternative: crontab.guru — the definitive cron tool. More detailed than what I built. Use crontab.guru for cron work specifically.

Chmod calculator

What you need: Convert between symbolic permissions (rwxr-xr--) and octal (754) without doing it in your head at 2 AM.

🔗 Tooliest Chmod Calculator — click the permission checkboxes, get the octal. Or type the octal, get the symbolic. Exactly as simple as it should be.

SQL formatting

What you need: Paste a query that's one long line, get it back indented and readable.

🔗 Tooliest SQL Formatter — keyword highlighting and clean indentation. Handles most standard SQL dialects.

Hash generation

What you need: Generate MD5, SHA-1, SHA-256, or SHA-512 hashes from text or to verify file integrity.

🔗 Tooliest Hash Generator — all four hash types, client-side. Your input never leaves the browser.

Encoding / decoding

Three you'll use constantly:

🔗 Base64 Encoder/Decoder

🔗 URL Encoder/Decoder

🔗 HTML Entity Encoder

All browser-side, all instant.

The honest summary

Use case	Best tool
JSON formatting	Tooliest or jsonlint.com
PDF merge / split / protect	Tooliest PDF suite — only no-upload option
Regex testing	regex101.com for complex patterns
Image compression	Squoosh for precision, Tooliest for speed
JWT decoding	jwt.io for signature verification
Code screenshots	Tooliest or ray.so
Cron parsing	crontab.guru
Everything else daily	Tooliest — one tab, no switching

For Regex and JWT work specifically, use the dedicated tools — they go deeper. For everything else in your daily workflow, having one tab that handles it without signup friction is worth more than marginally better features scattered across 12 different sites.

Bookmark this

👉 tooliest.com — 102 tools, one tab, nothing uploaded.

What tools did I miss that you reach for regularly? Drop them in the comments — I'm actively adding to the collection and the best suggestions have always come from other developers.

I replaced 12 bookmarked tool sites with one I built myself

Anurag Bhattarai — Mon, 27 Apr 2026 10:40:19 +0000

My browser bookmark bar had a folder called "Tools." Inside it:

A JSON formatter
A PDF merger (the sketchy one that definitely uploads your file somewhere)
An invoice generator that watermarks until you pay
A regex tester
A color picker
A CSS gradient generator
A Base64 encoder
Three different image compressors because none of them worked perfectly

I used this folder every single week. Sometimes every day. And every time I opened it, I was one mis-click away from losing the folder entirely, or opening a site that had pivoted to freemium since my last visit.

So I did what any reasonable developer does when annoyed enough.

I built the thing I actually wanted.

What I actually built

Tooliest is a collection of 102 free browser-based utility tools across 17 categories. The categories cover pretty much every workflow I kept switching tabs for:

PDF tools — 15 of them
Developer tools — JSON, Regex, JWT, Diff, Cron, SQL, Chmod
CSS tools — Gradient generator, Box shadow builder, Flexbox playground
Color tools — Picker, Palette generator, Contrast checker, Blindness simulator
Image tools — Compressor, Resizer, Cropper, Format converter
Finance tools — Invoice generator, Compound interest, Loan analyzer, SIP calculator
AI tools — Text summarizer, Paraphraser, Email writer
Text, Encoding, SEO, Social media, Privacy tools

But the tool count isn't actually the point.

The constraint that shaped everything

Early on I made a decision that ended up being the hardest technical part of the project: nothing would ever be uploaded to a server.

Every tool would run entirely in the browser. No backend. No file handling on my end. No "your file will be deleted in 24 hours." Your data goes in, gets processed locally, and comes back out — and I never see any of it.

This sounds simple until you try to build a PDF merger in the browser.

For the PDF tools, I ended up using pdf-lib — a pure JavaScript library that handles PDF creation and manipulation entirely client-side. Merging, splitting, compressing, rotating, watermarking, password protecting — all of it happens in a Web Worker so the main thread doesn't block.

For image compression, the browser's Canvas API does the heavy lifting. Feed it a PNG, draw it at reduced quality, export as WebP or JPEG. No upload needed.

The audio converter was the hardest. That one uses ffmpeg.wasm — a WebAssembly port of FFmpeg that runs fully in the browser. The initial load is heavy (~25MB for the WASM binary) but after that, MP3 to WAV to FLAC conversions happen locally with no server involved.

The AI tools are the one exception — they call the Anthropic API, so those requests do leave the browser. Everything else is genuinely local.

What I got wrong building this

I prioritized breadth over depth too early

My instinct was to ship as many tools as possible before launch. 100 tools sounds impressive. But from an SEO perspective, 10 deeply-optimized tool pages outperform 100 thin ones. Google cares about page depth, dwell time, and backlinks to individual pages — and I spread myself thin by trying to cover everything at once.

I'm now going back through the highest-potential pages and deepening them: better descriptions, richer FAQ sections, more detailed how-to content on each tool page. Boring work but it's what actually moves rankings.

I underestimated how long AdSense approval takes

The site is monetized through Google AdSense. The approval process took longer than expected and required a minimum content threshold I hadn't fully prepared for. If you're building something similar: apply the moment you have 15+ live, functional pages — not when you feel "ready."

The tool naming is inconsistent

Some tools have very clean URLs (/pdf-merger, /json-formatter) while others are more verbose than they need to be. URL consistency matters for SEO and for users sharing individual tools. Something I'd standardize from day one on the next project.

What actually works

The tools that get used most aren't the clever ones. They're the boring, high-frequency ones.

The Word Counter gets hit constantly. The JSON Formatter. The Image Compressor. The Password Generator. Not because they're technically impressive — they're not — but because people need them repeatedly and they bookmark the first one that works without annoying them.

That's the actual product insight: utility tools succeed by removing friction, not by adding features. The reason people return isn't because the tool is better than competitors. It's because the tool didn't make them sign up last time, so they remember it fondly.

The stack, if you're curious

Layer	Choice	Reason
Frontend	Static HTML / CSS / JS	No framework overhead, maximum speed
Hosting	Netlify free tier	$0/month, global CDN, instant deploys
PDF processing	pdf-lib	Pure JS, no server required
Audio conversion	ffmpeg.wasm	WebAssembly, runs entirely in browser
AI tools	Anthropic API (Claude)	Best-in-class summarization and writing
Offline support	PWA + Service Worker	Works without internet after first load
Monetization	Google AdSense	Passive, no payment infrastructure needed

No database. No authentication. No backend. The entire site is static files, which means it's fast, free to host, and there's no server to go down.

Where it goes from here

The plan is straightforward: go deeper on the tools that already get traffic, add the tools people actually request (a curl builder and HTTP header inspector are next), and let the SEO compound over time.

The passive income math only works if individual tool pages rank. A page ranking for "free pdf merger no upload" sends recurring, intent-driven traffic every single day without any ongoing effort. That's the model. It takes 3–6 months of patience but the unit economics make sense.

Try it

👉 tooliest.com

If there's a tool you reach for regularly that I haven't covered — drop it in the comments. I'm still actively building and the best feature ideas have consistently come from people who aren't me.

Built this as a side project while studying for an AI/ML certification. If you're building something similar and want to compare notes on the AdSense setup, Netlify config, or the browser-side PDF architecture — I'm happy to talk. Find me in the comments.