Forem: TateLyman

I Automated a Law Firm's Client Intake in 48 Hours — Here's How

TateLyman — Sun, 29 Mar 2026 22:46:41 +0000

A solo attorney was spending 10+ hours per week on client intake — screening calls, collecting documents, scheduling consultations. I built an AI system that handles all of it.

The Problem

Every new lead required:

Initial phone screening (15-20 min)
Conflict check
Collecting case details and documents
Scheduling a consultation
Sending engagement letter
Follow-up if they went cold

Multiply that by 15-20 leads per week = the attorney's entire Monday and Tuesday gone.

The Solution

I built a 3-part automation:

1. AI Intake Form

A smart form that asks case-specific questions based on practice area. Family law gets different questions than personal injury. The AI qualifies leads based on case type, jurisdiction, and urgency.

2. Automated Scheduling

Qualified leads get sent directly to a booking page. Unqualified leads get a polite "we can't help with this" email with referrals to appropriate attorneys.

3. Document Collection Bot

After booking, the system automatically requests relevant documents via email, sends reminders, and organizes everything in the case management system before the consultation.

Results

Intake time: From 10+ hrs/week to <1 hr/week
Response time: From 24-48 hours to instant
Conversion rate: Up 30% (faster response = higher close rate)
No-show rate: Down 40% (automated reminders)

The Tech Stack

Vanilla HTML/JS for the intake form
Webhooks for routing logic
Calendar API for scheduling
Email automation for document collection
Simple dashboard for the attorney to review leads

Total build time: 48 hours. Monthly maintenance: ~2 hours.

Want Something Similar?

I build custom AI automations for service businesses — law firms, medical practices, coaching businesses, agencies. Free working demo before you pay anything.

See what I build →

Try a live chatbot demo →

Email: lymantate2@gmail.com

The Freelancer Tax Stack: Tools I Use to Not Get Destroyed by the IRS

TateLyman — Sun, 29 Mar 2026 22:27:00 +0000

April 15 is coming fast. Here's the exact stack I use to handle freelance taxes without losing my mind.

The Problem

As a freelancer, nobody withholds taxes for you. If you don't track everything yourself, April hits like a truck. Self-employment tax alone is 15.3% on top of income tax.

My Stack

1. Quarterly Tax Estimates

I use a simple calculator to estimate what I owe each quarter. Plug in your income, it handles SE tax, QBI deduction, and income tax brackets. Takes 30 seconds.

2. Invoice Tracking

Every invoice goes through a free generator that keeps things consistent and professional. I export and track everything in a spreadsheet.

3. Rate Calculation

Most freelancers undercharge because they don't account for taxes, insurance, and non-billable hours. A rate calculator shows your TRUE hourly rate after all expenses.

4. Deduction Categories I Track

Home office (simplified: $5/sq ft up to $1,500)
Software subscriptions
Internet/phone (business %)
Health insurance premiums (100% deductible)
Professional development
Mileage (70 cents/mile for 2025)
Equipment under $2,500 (Section 179)

5. SEP-IRA

You can contribute up to 25% of net SE income to a SEP-IRA. This reduces your taxable income AND builds retirement. Contributions are due by the filing deadline (including extensions).

The Move for April 15

If you haven't filed yet:

Estimate what you owe → calculator
File Form 4868 for an extension (free, 5 minutes)
Pay your estimated amount by April 15 even with the extension
Organize deductions and file by October 15

The extension reduces your penalty from 5%/month to 0.5%/month. Always file it.

All tools linked above are free, no signup required. I built them because I got tired of doing this math by hand.

5 Smart Contract Vulnerability Patterns Every Solana Dev Should Know

TateLyman — Sun, 29 Mar 2026 21:01:56 +0000

I've spent time auditing DeFi protocols on Solana and Ethereum. Here are the patterns that keep showing up.

1. Oracle Manipulation

If your protocol uses a price oracle (Pyth, Chainlink, Switchboard), the #1 question is: can someone manipulate the price in the same transaction they exploit your contract?

The pattern:

Attacker flash loans a large amount
Manipulates a DEX pool price
Your oracle reads the manipulated price
Attacker borrows/withdraws at the wrong price
Repays flash loan, keeps profit

The fix: Use TWAP (time-weighted average prices), require price staleness checks, and use multiple oracle sources.

2. Missing Signer Checks

Solana programs must explicitly verify that the right accounts signed the transaction. Unlike Ethereum where msg.sender is implicit, Solana requires manual checks.

// BAD - no signer check
pub fn withdraw(ctx: Context<Withdraw>, amount: u64) -> Result<()> {
    // Anyone can call this!
    transfer(ctx.accounts.vault, ctx.accounts.destination, amount)
}

// GOOD - verify authority
pub fn withdraw(ctx: Context<Withdraw>, amount: u64) -> Result<()> {
    require!(ctx.accounts.authority.is_signer, ErrorCode::Unauthorized);
    transfer(ctx.accounts.vault, ctx.accounts.destination, amount)
}

3. Integer Overflow in Token Math

DeFi math involves lots of multiplication and division. Without checked math, values can silently overflow.

Common scenario: Calculating LP token shares, reward distributions, or fee percentages with large numbers that exceed u64 bounds.

The fix: Use checked_mul, checked_div, checked_add everywhere. Or use the uint crate for arbitrary precision.

4. Reentrancy via CPI

Solana's Cross-Program Invocations (CPI) can create reentrancy-like vulnerabilities. If your program calls another program that calls back into yours before state is updated, you're vulnerable.

The fix: Update state BEFORE making CPI calls (checks-effects-interactions pattern). Use reentrancy guards for critical functions.

5. Account Substitution

Solana programs receive accounts as a list. If you don't validate that each account is what you expect, an attacker can substitute a fake account.

Example: Passing a fake token mint, a different PDA, or an attacker-controlled program where your program expects a specific one.

The fix: Always validate account addresses against expected PDAs, check account owners, verify mint addresses.

If you're building on Solana and want a security review, feel free to reach out: lymantate2@gmail.com

I've audited oracle contracts, vault patterns, and DeFi protocols. Happy to do a quick review of your code.

I Built 6 Free Web Tools in a Weekend — Here They Are

TateLyman — Sun, 29 Mar 2026 20:58:28 +0000

I went on a building spree and created 6 free tools for freelancers and small businesses. All open, no signups, no ads.

1. Freelancer Tax Calculator

Estimates income tax, self-employment tax, and the QBI deduction. Plug in your freelance income and it breaks down what you owe.

Try it

2. Invoice Generator

Clean, professional invoices in seconds. Fill in client info, line items, and download. No account needed.

Try it

3. Freelance Rate Calculator

Figures out your TRUE hourly rate after taxes, expenses, and non-billable hours. Most freelancers are shocked by the result.

Try it

4. AI Prompt Generator

Generates customized prompts for ChatGPT/Claude based on your use case. Good for marketing, coding, writing, analysis.

Try it

5. Website Audit Tool

Quick SEO and performance check for any URL. Checks meta tags, load speed indicators, mobile responsiveness.

Try it

6. Resume Reviewer

Paste your resume and get instant feedback on formatting, keywords, and ATS compatibility.

Try it

All built with vanilla HTML/CSS/JS, hosted on Vercel. No frameworks, no build tools, loads instantly.

Feedback welcome. What other tools would be useful?

Last-Minute Tax Tips for Freelancers (2026) — 17 Days Left

TateLyman — Sun, 29 Mar 2026 18:56:14 +0000

April 15 is 17 days away. If you're a freelancer who hasn't filed yet, here's what to do right now.

1. File an Extension if You Need More Time

File Form 4868 — it's free, takes 5 minutes, gives you until October 15. But you still need to estimate and pay what you owe by April 15.

An extension reduces your penalty from 5%/month (failure to file) to 0.5%/month (failure to pay). Always file it.

2. The QBI Deduction

The Qualified Business Income deduction lets you deduct up to 20% of your net business income. If you made $80K freelancing, that's potentially $16,000 off your taxable income.

Most freelancers qualify automatically if taxable income is under $191,950 (single).

3. Home Office Deduction

Simplified method: $5 per square foot, up to 300 sq ft = $1,500. Zero record-keeping needed. You just need a space used regularly and exclusively for business.

4. Commonly Missed Deductions

Internet and phone bills (business-use percentage)
Software subscriptions (Adobe, Canva, Slack, etc.)
Health insurance premiums (100% deductible if self-employed)
Retirement contributions (SEP-IRA deductible until filing deadline)
Bad debts (client ghosted you after invoicing? Write it off)
Mileage: 70 cents/mile for 2025

5. Self-Employment Tax

If you earned $400+ freelancing, you owe 15.3% SE tax on top of income tax. Quick estimate: net income × 0.9235 × 0.153.

A freelancer earning $60K owes ~$8,478 in SE tax alone.

Free Tax Calculator

I built a quick calculator that handles income tax, SE tax, and the QBI deduction for freelancers:

Free Freelancer Tax Calculator

Estimate your taxes in 60 seconds.

Not tax advice. Consult a qualified tax professional for your specific situation.

Every PDF Tool You Need, Running 100% in Your Browser

TateLyman — Sat, 28 Mar 2026 01:11:27 +0000

I got sick of PDF tools that require accounts, plaster watermarks on everything, or silently upload your files to some server in who-knows-where. So I built a full suite of PDF tools that run entirely client-side. No uploads. No accounts. No watermarks. Your files never leave your browser tab.

Here's what's in the toolkit and how each one works.

Merge PDFs

The most common thing people need. Drop in multiple PDFs, reorder them if you want, hit merge, get one file back.

Under the hood this uses pdf-lib to copy pages from each source document into a new one:

import { PDFDocument } from 'pdf-lib';

async function mergePDFs(files) {
  const merged = await PDFDocument.create();

  for (const file of files) {
    const bytes = await file.arrayBuffer();
    const doc = await PDFDocument.load(bytes);
    const pages = await merged.copyPages(doc, doc.getPageIndices());
    pages.forEach(page => merged.addPage(page));
  }

  return await merged.save();
}

The copyPages method is the key — it brings over not just the page content but also fonts, images, and annotations embedded in those pages. The output is a proper PDF, not some stitched-together hack.

I use this weekly to combine invoices into single files for accounting. Handles 50+ files without breaking a sweat.

Try it: devtools-site-delta.vercel.app/merge-pdf

Split PDF

The reverse operation. Got a 200-page PDF and only need pages 15-30? Or want to extract every page as its own file?

You pick the page ranges and it pulls them out:

async function splitPDF(file, ranges) {
  const bytes = await file.arrayBuffer();
  const source = await PDFDocument.load(bytes);
  const results = [];

  for (const range of ranges) {
    const newDoc = await PDFDocument.create();
    const indices = [];
    for (let i = range.start - 1; i < range.end; i++) {
      indices.push(i);
    }
    const pages = await newDoc.copyPages(source, indices);
    pages.forEach(page => newDoc.addPage(page));
    results.push(await newDoc.save());
  }

  return results;
}

It supports overlapping ranges too, so you can pull pages 1-10 and pages 5-15 as separate files in one go.

Try it: devtools-site-delta.vercel.app/split-pdf

Compress PDF

PDF compression in the browser is tricky. You can't do the same aggressive recompression that server-side tools like Ghostscript pull off. But there's still a lot of low-hanging fruit.

The approach: load the PDF, re-save it with pdf-lib's built-in optimization. This strips out redundant objects, deduplicates resources, and cleans up the cross-reference table. For PDFs exported from tools like Word or Google Docs that leave a lot of garbage in the file, this alone can cut size by 20-40%.

For image-heavy PDFs, the tool optionally renders pages to Canvas and rebuilds the PDF with compressed JPEG images. Lossy, sure, but when you're trying to get a 50MB scan under an email attachment limit, it does the job.

Try it: devtools-site-delta.vercel.app/compress-pdf

PDF to Images

Need to turn PDF pages into PNGs? This one uses pdf.js (Mozilla's PDF renderer) to render each page onto a Canvas, then exports as PNG or JPEG:

import * as pdfjsLib from 'pdfjs-dist';

async function pdfToImages(file, format = 'png', scale = 2) {
  const bytes = await file.arrayBuffer();
  const pdf = await pdfjsLib.getDocument({ data: bytes }).promise;
  const images = [];

  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 blob = await new Promise(resolve =>
      canvas.toBlob(resolve, `image/${format}`, 0.92)
    );
    images.push(blob);
  }

  return images;
}

The scale parameter controls output resolution. Scale 1 gives you roughly 72 DPI (matches PDF points), scale 2 gives 144 DPI which is good for most uses, and scale 3 is high-res if you need print quality.

Try it: devtools-site-delta.vercel.app/pdf-to-image

Image to PDF

The reverse — throw a bunch of images in and get a PDF. Supports PNG, JPEG, WebP, and basically any format your browser can render. You pick the page size (A4, Letter, or auto-fit), set margins, and it handles the layout.

WebP doesn't work natively with pdf-lib, so the tool uses Canvas as a transcoding step — render the WebP to Canvas, export as PNG, then embed. The user never notices.

This one is great for converting photo sets into shareable documents, or turning a stack of scanned pages into a single file.

Try it: devtools-site-delta.vercel.app/image-to-pdf

Why 100% Client-Side Matters

Let me be blunt about this: most online PDF tools upload your files to their servers. Read their privacy policies (if they even have one). Your contracts, tax documents, medical records, and personal photos are sitting on someone else's infrastructure.

With client-side tools, the processing happens in your browser's JavaScript engine. The files exist as ArrayBuffer objects in memory. When you close the tab, they're gone. There's no network request carrying your data anywhere.

You can verify this yourself — open DevTools, go to the Network tab, and watch. Nothing gets sent out.

Performance Notes

Browser-based PDF processing is surprisingly fast. Merging 20 PDFs takes about 2 seconds on a modern machine. Splitting is nearly instant. PDF-to-image rendering depends on page complexity, but most documents convert in under a second per page.

The main limitation is memory. Browsers typically cap tab memory at 1-4 GB. For most workflows (documents under 100 pages, images under 10 MB each), you won't hit that ceiling. If you're trying to merge 500 high-res scanned documents, yeah, you might want a desktop tool.

For the other 99% of cases, these work great.

All the PDF Tools

Here's the full list in one place:

Merge PDF — Combine multiple PDFs
Split PDF — Extract page ranges
Compress PDF — Reduce file size
PDF to Image — Convert pages to PNG/JPEG
Image to PDF — Build PDFs from images

All free, no accounts, no watermarks. They're part of a larger collection of 200+ developer tools I maintain at devtools-site-delta.vercel.app. Everything runs in the browser.

If you find a bug or want a feature, I'm around.

I Made a Free Photo Editor, Meme Generator, and Background Remover — All Client-Side

TateLyman — Sat, 28 Mar 2026 01:09:16 +0000

I've been on a kick lately building browser-based tools that don't upload your stuff anywhere. After doing PDF tools and converters, I figured image editing was the obvious next target. So I built three things: a photo editor, a meme generator, and a background remover. All running on Canvas API, all client-side, all free.

Here's what I learned about pushing Canvas to its limits.

The Photo Editor: CSS Filters Meet Canvas

Browsers have CSS filters — brightness(), contrast(), saturate(), blur(), etc. They're great for previewing edits, but if you want to actually export an edited image, you need to apply those filters at the pixel level using Canvas.

The nice thing is that the Canvas 2D context supports the same filter property as CSS:

function applyFilters(sourceCanvas, filters) {
  const output = document.createElement('canvas');
  output.width = sourceCanvas.width;
  output.height = sourceCanvas.height;
  const ctx = output.getContext('2d');

  // Build the CSS filter string
  const filterStr = [
    `brightness(${filters.brightness}%)`,
    `contrast(${filters.contrast}%)`,
    `saturate(${filters.saturation}%)`,
    `hue-rotate(${filters.hueRotate}deg)`,
    `blur(${filters.blur}px)`,
    `sepia(${filters.sepia}%)`,
    `grayscale(${filters.grayscale}%)`
  ].join(' ');

  ctx.filter = filterStr;
  ctx.drawImage(sourceCanvas, 0, 0);

  return output;
}

This works great for standard adjustments. But for more advanced stuff — like selective color adjustments or vignettes — you need to go deeper with getImageData and manipulate pixels directly.

Here's a vignette effect that darkens the edges:

function applyVignette(canvas, intensity = 0.5) {
  const ctx = canvas.getContext('2d');
  const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
  const data = imageData.data;

  const cx = canvas.width / 2;
  const cy = canvas.height / 2;
  const maxDist = Math.sqrt(cx * cx + cy * cy);

  for (let y = 0; y < canvas.height; y++) {
    for (let x = 0; x < canvas.width; x++) {
      const i = (y * canvas.width + x) * 4;
      const dx = x - cx;
      const dy = y - cy;
      const dist = Math.sqrt(dx * dx + dy * dy) / maxDist;

      const darken = 1 - (dist * dist * intensity);
      data[i] *= darken;     // R
      data[i + 1] *= darken; // G
      data[i + 2] *= darken; // B
    }
  }

  ctx.putImageData(imageData, 0, 0);
}

The key insight: dist * dist gives you a smooth falloff from center to edge. Linear distance would look harsh. Squaring it makes the darkening ramp up gradually, which looks way more natural.

The Meme Generator: Text Rendering on Canvas

Meme generation sounds trivial — slap some text on an image, right? But getting the text to look like an actual meme took more work than I expected.

The classic meme font is Impact, white with black outline. The outline is the tricky part. Canvas has strokeText and fillText, and you need both:

function drawMemeText(ctx, text, x, y, maxWidth, fontSize) {
  ctx.font = `bold ${fontSize}px Impact, Arial Black, sans-serif`;
  ctx.textAlign = 'center';
  ctx.textBaseline = 'top';

  // Word wrap
  const lines = wrapText(ctx, text, maxWidth);
  const lineHeight = fontSize * 1.1;

  lines.forEach((line, i) => {
    const ly = y + i * lineHeight;

    // Black outline — draw it thick
    ctx.lineWidth = fontSize / 12;
    ctx.strokeStyle = '#000000';
    ctx.lineJoin = 'round';
    ctx.miterLimit = 2;
    ctx.strokeText(line, x, ly);

    // White fill on top
    ctx.fillStyle = '#FFFFFF';
    ctx.fillText(line, x, ly);
  });
}

function wrapText(ctx, text, maxWidth) {
  const words = text.split(' ');
  const lines = [];
  let current = '';

  words.forEach(word => {
    const test = current ? current + ' ' + word : word;
    if (ctx.measureText(test).width > maxWidth && current) {
      lines.push(current);
      current = word;
    } else {
      current = test;
    }
  });
  if (current) lines.push(current);
  return lines;
}

Two things that make this look right:

lineJoin = 'round' — Without this, the stroke corners on letters like W and M look spiky and weird.
Stroke before fill — If you fill first and stroke second, the outline covers the white text. Stroke first, then fill on top so the white sits cleanly inside the outline.

I also added auto-sizing. If the text is too long, the font size shrinks until it fits. Nobody wants to manually pick font sizes on a meme generator.

function autoSizeFont(ctx, text, maxWidth, startSize = 72, minSize = 24) {
  for (let size = startSize; size >= minSize; size -= 2) {
    ctx.font = `bold ${size}px Impact, Arial Black, sans-serif`;
    const lines = wrapText(ctx, text, maxWidth);
    if (lines.length <= 3) return size;
  }
  return minSize;
}

The Background Remover: Flood Fill + Edge Detection

This one was the most fun to build. Full-blown background removal like Photoshop uses ML models (and honestly, the best ones run server-side). But you can get surprisingly decent results with a tolerance-based flood fill.

The idea: user clicks the background color, and the algorithm floods outward from that point, removing any pixel within a color tolerance:

function floodFillRemove(imageData, startX, startY, tolerance = 30) {
  const { data, width, height } = imageData;
  const visited = new Uint8Array(width * height);
  const stack = [[startX, startY]];

  const idx = (startY * width + startX) * 4;
  const targetR = data[idx];
  const targetG = data[idx + 1];
  const targetB = data[idx + 2];

  while (stack.length > 0) {
    const [x, y] = stack.pop();
    if (x < 0 || x >= width || y < 0 || y >= height) continue;

    const pos = y * width + x;
    if (visited[pos]) continue;
    visited[pos] = 1;

    const i = pos * 4;
    const dr = data[i] - targetR;
    const dg = data[i + 1] - targetG;
    const db = data[i + 2] - targetB;
    const diff = Math.sqrt(dr * dr + dg * dg + db * db);

    if (diff <= tolerance) {
      data[i + 3] = 0; // Set alpha to 0 (transparent)
      stack.push([x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]);
    }
  }
}

This works well for solid-color backgrounds. A white wall, a green screen, a solid blue sky — the flood fill eats through those cleanly.

For gradients and complex backgrounds, I added an edge-aware mode that combines the flood fill with a Sobel edge detector. The edge detection finds boundaries in the image, and the flood fill stops at those boundaries:

function sobelEdges(imageData) {
  const { data, width, height } = imageData;
  const edges = new Float32Array(width * height);

  const gx = [-1, 0, 1, -2, 0, 2, -1, 0, 1];
  const gy = [-1, -2, -1, 0, 0, 0, 1, 2, 1];

  for (let y = 1; y < height - 1; y++) {
    for (let x = 1; x < width - 1; x++) {
      let sumX = 0, sumY = 0;
      let k = 0;

      for (let ky = -1; ky <= 1; ky++) {
        for (let kx = -1; kx <= 1; kx++) {
          const i = ((y + ky) * width + (x + kx)) * 4;
          const gray = (data[i] + data[i+1] + data[i+2]) / 3;
          sumX += gray * gx[k];
          sumY += gray * gy[k];
          k++;
        }
      }

      edges[y * width + x] = Math.sqrt(sumX * sumX + sumY * sumY);
    }
  }

  return edges;
}

The Sobel operator runs two 3x3 kernels across the image — one detecting horizontal edges, one detecting vertical. The magnitude at each pixel tells you how "edgy" that spot is. I use a threshold (usually around 40-60) to decide where the flood fill should stop.

It's not going to match Remove.bg on a photo of someone standing in a forest. But for product photos, logos, headshots with clean backgrounds — it works remarkably well for zero server cost.

Composite Operations: The Secret Weapon

Canvas has a feature called globalCompositeOperation that controls how new drawing operations blend with existing content. Most people only use the default (source-over), but there are 26 blend modes.

I use these heavily in the photo editor for layer effects:

// Color overlay
ctx.globalCompositeOperation = 'multiply';
ctx.fillStyle = '#ff6600';
ctx.fillRect(0, 0, canvas.width, canvas.height);

// Screen blend (lightens)
ctx.globalCompositeOperation = 'screen';
ctx.drawImage(overlayCanvas, 0, 0);

// Draw only where existing content is
ctx.globalCompositeOperation = 'source-atop';
ctx.drawImage(textureCanvas, 0, 0);

source-atop is particularly useful — it draws new content only where there's already opaque pixels. Great for applying textures or patterns to cut-out shapes without bleeding outside the edges.

Performance Notes

Pixel manipulation with getImageData is slow on large images. A 4000x3000 photo has 12 million pixels, and iterating through all of them in JavaScript takes real time.

Two things that helped:

Downsample for preview, full-res for export. While the user is adjusting sliders, I apply filters to a 800px-wide preview canvas. Only when they hit "Download" do I process the full resolution.
Typed arrays over regular arrays. ImageData.data is already a Uint8ClampedArray, so operations on it are fast. But if you're doing intermediate calculations, use Float32Array instead of regular arrays — the typed array operations get JIT-optimized way better.

Try Them

All three tools are live and free:

Photo Editor — brightness, contrast, saturation, filters, crop, rotate, vignette
Meme Generator — classic top/bottom text, custom fonts, auto-sizing
Background Remover — click-to-remove with tolerance control

No uploads, no accounts, no watermarks. Your images stay in your browser the entire time. If you're curious how any specific part works, the JavaScript is all right there in the page source.

The Privacy Problem with Online PDF Tools (and How I Fixed It)

TateLyman — Sat, 28 Mar 2026 01:08:22 +0000

Last year I needed to merge two PDFs before sending them to my landlord. I Googled "merge PDF online," clicked the first result, and uploaded my lease agreement and bank statement to some random website.

Then I thought about what I'd just done.

I'd handed a stranger my full legal name, address, bank account number, and monthly income. The site's privacy policy was 4,000 words of legalese that boiled down to "we can do whatever we want with your data."

That bugged me enough to build my own PDF tools. They run entirely in the browser. Your files never touch a server.

How Bad Is It, Really?

I tested the top 10 PDF tools from Google search results. Here's what I found:

8 out of 10 upload your file to their server for processing
3 store files for "up to 24 hours" (their words)
2 had privacy policies that allowed sharing data with "partners"
1 didn't even have HTTPS on the upload endpoint (yikes)

Think about the kinds of documents people put through PDF tools:

Legal: contracts, NDAs, court filings
Medical: lab results, insurance claims, prescriptions
Financial: tax returns, bank statements, pay stubs
Business: internal memos, hiring docs, IP filings

Every one of those is a goldmine for anyone who intercepts or scrapes them. And you're trusting that some free PDF tool with ads plastered everywhere is handling your data responsibly.

Client-Side PDF Processing Is Real

Here's the thing — you don't actually need a server for most PDF operations. The pdf-lib library lets you manipulate PDFs entirely in JavaScript, running in the browser.

Merging PDFs

Merging is probably the most common operation. With pdf-lib, it's straightforward:

import { PDFDocument } from 'pdf-lib';

async function mergePDFs(pdfFiles) {
  const merged = await PDFDocument.create();

  for (const file of pdfFiles) {
    const bytes = await file.arrayBuffer();
    const doc = await PDFDocument.load(bytes);
    const pages = await merged.copyPages(doc, doc.getPageIndices());
    pages.forEach(page => merged.addPage(page));
  }

  const mergedBytes = await merged.save();
  return new Blob([mergedBytes], { type: 'application/pdf' });
}

That's it. The file goes from <input type="file"> to arrayBuffer to pdf-lib, and back out as a downloadable blob. At no point does it leave the browser.

Splitting PDFs

Splitting works the same way — you're just copying specific pages instead of all of them:

async function splitPDF(pdfFile, pageRanges) {
  const bytes = await pdfFile.arrayBuffer();
  const source = await PDFDocument.load(bytes);
  const results = [];

  for (const range of pageRanges) {
    const newDoc = await PDFDocument.create();
    const indices = [];
    for (let i = range.start - 1; i < range.end; i++) {
      indices.push(i);
    }
    const pages = await newDoc.copyPages(source, indices);
    pages.forEach(page => newDoc.addPage(page));
    results.push(await newDoc.save());
  }

  return results;
}

Want pages 1-3 as one file and pages 4-10 as another? Pass [{start: 1, end: 3}, {start: 4, end: 10}] and you get two separate PDFs back.

Compressing PDFs

Compression is trickier because pdf-lib doesn't have a built-in "compress" function. But most PDF bloat comes from embedded images. The approach I took:

Parse the PDF and find all embedded images
Decode each image
Re-encode it at lower quality using Canvas + toBlob
Replace the original image data in the PDF

async function compressImage(imageBytes, quality = 0.7) {
  const blob = new Blob([imageBytes]);
  const bitmap = await createImageBitmap(blob);

  const canvas = document.createElement('canvas');
  canvas.width = bitmap.width;
  canvas.height = bitmap.height;
  const ctx = canvas.getContext('2d');
  ctx.drawImage(bitmap, 0, 0);

  return new Promise(resolve => {
    canvas.toBlob(resolve, 'image/jpeg', quality);
  });
}

This typically shrinks image-heavy PDFs by 40-60%. Text-only PDFs don't change much, but those are usually small anyway.

PDF to Image

For rendering PDF pages as images, I use pdf.js (Mozilla's PDF renderer). It draws each page onto a Canvas element:

async function pdfPageToImage(pdfDoc, pageNum, scale = 2) {
  const page = await pdfDoc.getPage(pageNum);
  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;

  return canvas.toDataURL('image/png');
}

The scale factor matters a lot. Scale 1 gives you screen-resolution output. Scale 2 gives you print-quality. Scale 3 if you really need sharp text. Each jump doubles the pixel count, so don't go crazy with it.

The Verification Problem

Here's the hard part: how does a user actually verify their files aren't being uploaded? They shouldn't have to take my word for it.

A few things I did to make this transparent:

No network requests after page load. Open DevTools, go to the Network tab, and watch. After the initial page load, there's zero network activity when you process a file. You can even disconnect your WiFi and it still works.

Open source approach. All the processing logic is in the client-side JavaScript. View source and you can trace exactly what happens to your file. There's no minified blob hiding a sneaky fetch() call.

No analytics on file content. I track page views (everyone does), but I have zero visibility into what files users process. I literally couldn't access your data if I wanted to.

Why Don't More Tools Work This Way?

Money, mostly. Server-side processing means:

You can gate features behind paywalls more easily
You can collect data for advertising
You can impose artificial limits to push upgrades
You control the processing pipeline

Client-side tools give up all of that. The tradeoff is that users get better privacy and faster processing (no upload/download wait), but the developer has fewer monetization levers.

I'm fine with that tradeoff. The tools are free, they work offline, and your files stay yours.

Try Them Out

All the PDF tools are live:

Drop your files in, get your result out. Nothing uploaded, nothing stored, nothing tracked. If you want to verify, open DevTools and watch the Network tab — you'll see exactly zero outbound requests during processing.

How I Built a Client-Side Video to GIF Converter with Zero Dependencies

TateLyman — Sat, 28 Mar 2026 01:07:41 +0000

I spent a weekend building a video-to-GIF converter that runs entirely in the browser. No server, no uploads, no ffmpeg binary — just raw JavaScript turning video frames into an animated GIF. Here's how it actually works under the hood.

Why Bother?

Most online GIF makers upload your video to some server, process it, and send back the result. That's fine until you realize:

Your video sits on someone else's machine
It's slow because you're waiting on network round-trips
File size limits are usually tiny
It breaks when the service goes down

I wanted something that processes everything locally. The video never leaves your browser tab.

Extracting Frames from Video

The first step is pulling individual frames out of a video file. The <video> element + <canvas> combo makes this surprisingly doable:

async function extractFrames(videoFile, fps = 10) {
  const video = document.createElement('video');
  video.muted = true;
  video.src = URL.createObjectURL(videoFile);

  await new Promise(resolve => {
    video.onloadedmetadata = resolve;
  });

  const canvas = document.createElement('canvas');
  canvas.width = video.videoWidth;
  canvas.height = video.videoHeight;
  const ctx = canvas.getContext('2d');

  const frames = [];
  const interval = 1 / fps;

  for (let time = 0; time < video.duration; time += interval) {
    video.currentTime = time;
    await new Promise(resolve => {
      video.onseeked = resolve;
    });
    ctx.drawImage(video, 0, 0);
    frames.push(ctx.getImageData(0, 0, canvas.width, canvas.height));
  }

  URL.revokeObjectURL(video.src);
  return frames;
}

The trick here is video.onseeked. When you set currentTime, the browser doesn't jump to that frame instantly — it's async. You have to wait for the seeked event before drawing to the canvas, or you'll grab stale frames.

Performance Gotcha

Extracting frames from a 30-second video at 10fps gives you 300 frames. Each one is a full ImageData object sitting in memory. For a 1080p video, that's roughly 1920 * 1080 * 4 bytes = ~8MB per frame. 300 frames = 2.4GB of raw pixel data.

So you have to be smart about it. I scale the video down before extracting:

const maxWidth = 480;
const scale = Math.min(1, maxWidth / video.videoWidth);
canvas.width = video.videoWidth * scale;
canvas.height = video.videoHeight * scale;

480px wide is plenty for most GIFs, and it cuts memory usage by 75% compared to 1080p.

The GIF Encoder: LZW Compression from Scratch

This is where it gets interesting. The GIF format uses LZW (Lempel-Ziv-Welch) compression, and I implemented it without pulling in any library.

GIF files follow the GIF89a spec. The binary structure looks like this:

Header: GIF89a (6 bytes)
Logical Screen Descriptor: width, height, color table info (7 bytes)
Global Color Table: up to 256 RGB colors
Netscape Extension: for looping (19 bytes)
For each frame: Graphic Control Extension + Image Data
Trailer: 0x3B (1 byte)

The Netscape Application Extension is what makes the GIF loop. Without it, the animation plays once and stops:

function writeNetscapeExtension(buffer, offset) {
  buffer[offset++] = 0x21; // Extension introducer
  buffer[offset++] = 0xFF; // Application extension
  buffer[offset++] = 0x0B; // Block size
  // "NETSCAPE2.0"
  const id = 'NETSCAPE2.0';
  for (let i = 0; i < 11; i++) {
    buffer[offset++] = id.charCodeAt(i);
  }
  buffer[offset++] = 0x03; // Sub-block size
  buffer[offset++] = 0x01; // Loop indicator
  buffer[offset++] = 0x00; // Loop count (low byte) — 0 = infinite
  buffer[offset++] = 0x00; // Loop count (high byte)
  buffer[offset++] = 0x00; // Block terminator
  return offset;
}

The LZW compression itself works by building a dictionary of pixel patterns as it scans through the image:

function lzwEncode(pixels, colorDepth) {
  const minCodeSize = Math.max(2, colorDepth);
  const clearCode = 1 << minCodeSize;
  const eoiCode = clearCode + 1;

  let codeSize = minCodeSize + 1;
  let nextCode = eoiCode + 1;
  const table = new Map();

  // Initialize dictionary with single-character codes
  for (let i = 0; i < clearCode; i++) {
    table.set(String(i), i);
  }

  const output = [];
  output.push(clearCode);

  let current = String(pixels[0]);

  for (let i = 1; i < pixels.length; i++) {
    const next = String(pixels[i]);
    const combined = current + ',' + next;

    if (table.has(combined)) {
      current = combined;
    } else {
      output.push(table.get(current));
      if (nextCode < 4096) {
        table.set(combined, nextCode++);
        if (nextCode > (1 << codeSize) && codeSize < 12) {
          codeSize++;
        }
      } else {
        output.push(clearCode);
        table.clear();
        for (let j = 0; j < clearCode; j++) {
          table.set(String(j), j);
        }
        codeSize = minCodeSize + 1;
        nextCode = eoiCode + 1;
      }
      current = next;
    }
  }

  output.push(table.get(current));
  output.push(eoiCode);

  return { codes: output, minCodeSize };
}

The 4096 limit is baked into the GIF spec — codes are 12 bits max. When you hit the limit, you emit a clear code and reset the dictionary.

Color Quantization

GIF only supports 256 colors per frame. Video frames have millions. You need a quantization step to map the full RGB space down to a 256-color palette.

I went with median-cut quantization. It works by repeatedly splitting the RGB color space along whichever axis has the widest range:

function medianCut(pixels, maxColors) {
  let buckets = [{ colors: pixels }];

  while (buckets.length < maxColors) {
    // Find the bucket with the widest color range
    let widest = 0, widestRange = 0, widestChannel = 0;

    for (let i = 0; i < buckets.length; i++) {
      for (let ch = 0; ch < 3; ch++) {
        const vals = buckets[i].colors.map(c => c[ch]);
        const range = Math.max(...vals) - Math.min(...vals);
        if (range > widestRange) {
          widestRange = range;
          widest = i;
          widestChannel = ch;
        }
      }
    }

    const bucket = buckets.splice(widest, 1)[0];
    bucket.colors.sort((a, b) => a[widestChannel] - b[widestChannel]);
    const mid = Math.floor(bucket.colors.length / 2);
    buckets.push({ colors: bucket.colors.slice(0, mid) });
    buckets.push({ colors: bucket.colors.slice(mid) });
  }

  return buckets.map(b => {
    const avg = [0, 0, 0];
    b.colors.forEach(c => { avg[0] += c[0]; avg[1] += c[1]; avg[2] += c[2]; });
    return avg.map(v => Math.round(v / b.colors.length));
  });
}

This gives way better results than just picking the most frequent colors. The palette adapts to the actual color distribution in each frame.

Putting It All Together

The final pipeline: extract frames → quantize colors → encode each frame with LZW → pack into GIF binary.

I added a progress bar since encoding can take 5-10 seconds for longer videos. Users seeing a frozen screen is a guaranteed bounce.

The whole thing runs in the main thread, which isn't ideal. Moving the encoder into a Web Worker would keep the UI responsive during heavy encodes — that's on my list.

Try It

The converter is live at devtools-site-delta.vercel.app/video-to-gif. Drop a video file, pick your FPS and quality, and it spits out a GIF. Nothing gets uploaded anywhere.

If you're building something similar, the biggest lesson I learned: get the color quantization right first. Bad palettes make everything else look broken even if your encoder is perfect.

500+ Free Online Tools I Built — Here Are the Most Useful Ones

TateLyman — Sat, 28 Mar 2026 00:38:52 +0000

Over the past year, I've been building free browser-based tools at devtools-site-delta.vercel.app. What started as a JSON formatter I built for myself has turned into 500+ tools.

Most of them run entirely client-side — your data never leaves your browser. No accounts, no paywalls, no "5 free uses per day" nonsense.

Here are the 15 I use the most.

1. JSON Formatter & Validator

/json-formatter

Paste in ugly JSON, get it pretty-printed with syntax highlighting. Also catches errors and tells you exactly where the problem is (line and character). I use this multiple times a day when debugging API responses.

2. PDF Merge

/pdf-merge

Drag in multiple PDFs, reorder them, merge into one file. Runs entirely in your browser using pdf-lib. No upload, no server. I wrote a whole post about this one.

3. Image Compressor

/image-compress

Drop in an image, adjust the quality slider, download a smaller version. Uses the Canvas API. I compress every image before adding it to a blog post or README. Usually saves 60-80% file size.

4. Regex Tester

/regex

Write a regex pattern, paste in test text, see matches highlighted in real time. Shows capture groups, match indices, and flags. Way faster than tab-switching to regex101 when I'm already in the zone.

5. JWT Decoder

/jwt-decode

Paste a JWT token and instantly see the decoded header and payload. Shows expiration time in a human-readable format. Essential for auth debugging. Also has a JWT creator if you need to generate test tokens.

6. QR Code Generator

/qr

Type in a URL, text, or WiFi credentials and get a QR code you can download as PNG or SVG. The WiFi QR generator is great — print one out, stick it on the fridge, and guests can connect without asking for the password.

7. Color Picker & Palette Generator

/color-picker

Pick a color, get the HEX, RGB, HSL, and CSS values. The palette generator creates harmonious color schemes from a seed color. There's also a contrast checker for WCAG accessibility compliance.

8. Base64 Encoder/Decoder

/base64

Encode and decode Base64 strings. Also handles image-to-base64 conversion, which is useful for embedding small images directly in CSS or HTML.

9. Hash Generator

/hash-generator

Generate MD5, SHA-1, SHA-256, and SHA-512 hashes from any text input. Good for verifying file integrity or generating quick checksums. All computed locally using the Web Crypto API.

10. CSS Gradient Generator

/css-gradient-generator

Visual gradient builder with live preview. Supports linear, radial, and conic gradients. Pick your colors, adjust stops, copy the CSS. I use this instead of guessing gradient values and refreshing the browser 50 times.

11. Background Remover

/background-remover

Remove image backgrounds using an ML model that runs in the browser. Works great for product photos and headshots. No upload required — the model processes everything locally.

12. Markdown Preview

/markdown-preview

Split-pane editor with live rendering. I use this when writing READMEs or documentation. Also has Markdown to HTML conversion and an HTML to Markdown converter for going the other direction.

13. CSS Box Shadow Generator

/box-shadow

Visual editor for CSS box shadows with sliders for offset, blur, spread, and color. Supports multiple shadow layers. Copy the CSS when it looks right. Saves a ton of trial-and-error.

14. JSON to TypeScript

/json-to-typescript

Paste a JSON object and get TypeScript interfaces generated automatically. Handles nested objects, arrays, and optional fields. I use this constantly when working with API responses — paste the response, get the types, move on.

15. Image Resizer

/image-resize

Resize images to exact dimensions with aspect ratio lock. Great for making Open Graph images (1200x630), favicons, or thumbnails. Runs client-side via the Canvas API.

Honorable Mentions

A few more that didn't make the top 15 but I still reach for regularly:

Code Diff — compare two code snippets side by side
YAML to JSON — convert between YAML and JSON formats
HTML Beautify — format messy HTML
CSS Minify — minify CSS for production
Epoch Converter — convert Unix timestamps
Lorem Ipsum — placeholder text generator
UUID Generator — generate v4 UUIDs
Cron Parser — explain cron expressions in plain English

Why I Built This

I was spending way too much time on ad-covered, rate-limited tool sites. Need to format some JSON? Here's 3 pop-ups and a newsletter prompt. Need to merge two PDFs? Upload your sensitive documents to our server.

So I just started building. One tool turned into ten. Ten turned into a hundred. Now there are 500+.

Everything is free. Most tools run client-side. No accounts needed.

Bookmark devtools-site-delta.vercel.app and stop giving your data to random tool sites.

Full site: devtools-site-delta.vercel.app

Free Image Tools That Run Entirely in Your Browser (No Server Upload)

TateLyman — Sat, 28 Mar 2026 00:38:14 +0000

I have a thing about uploading files to random websites. Call it paranoia, call it good practice — either way, I built a bunch of image tools that work 100% in your browser. No server. No account. No "processing on our end."

Here's what's available and how they work under the hood.

Image Compressor

devtools-site-delta.vercel.app/image-compress

This one gets the most use from me personally. I compress screenshots and blog images before uploading them anywhere. The tool uses the Canvas API to re-encode images at a lower quality setting:

function compressImage(file, quality = 0.7) {
  return new Promise((resolve) => {
    const img = new Image();
    img.onload = () => {
      const canvas = document.createElement('canvas');
      canvas.width = img.width;
      canvas.height = img.height;

      const ctx = canvas.getContext('2d');
      ctx.drawImage(img, 0, 0);

      canvas.toBlob(resolve, 'image/jpeg', quality);
    };
    img.src = URL.createObjectURL(file);
  });
}

The quality parameter (0 to 1) controls the compression level. At 0.7, you usually get 60-80% file size reduction with barely visible quality loss. The tool gives you a slider so you can find the sweet spot for each image.

What I like about this approach: the Canvas API is built into every modern browser. No external libraries needed. Your image gets drawn onto a canvas element, then re-exported as a blob with your chosen quality.

Image Resizer

devtools-site-delta.vercel.app/image-resize

Same Canvas API approach, different use case. Need a 1200x630 image for an Open Graph tag? Need to scale down a 4000px photo for your blog? Punch in the dimensions, done.

The resizer preserves aspect ratio by default (you can unlock it if you want exact dimensions). It also shows you the original and new file sizes side by side so you know exactly what you're getting.

function resizeImage(file, maxWidth, maxHeight) {
  return new Promise((resolve) => {
    const img = new Image();
    img.onload = () => {
      let { width, height } = img;

      // Maintain aspect ratio
      if (width > maxWidth) {
        height = (height * maxWidth) / width;
        width = maxWidth;
      }
      if (height > maxHeight) {
        width = (width * maxHeight) / height;
        height = maxHeight;
      }

      const canvas = document.createElement('canvas');
      canvas.width = width;
      canvas.height = height;
      canvas.getContext('2d').drawImage(img, 0, 0, width, height);

      canvas.toBlob(resolve, file.type);
    };
    img.src = URL.createObjectURL(file);
  });
}

Image Converter

devtools-site-delta.vercel.app/image-converter

PNG to JPG. JPG to WebP. WebP to PNG. Whatever you need.

The trick here is that canvas.toBlob() accepts a MIME type as the second argument. Want WebP? Pass 'image/webp'. Want JPEG? 'image/jpeg'. The browser handles the encoding natively.

This is especially useful for converting to WebP. Most sites should be serving WebP images (they're typically 25-35% smaller than equivalent JPEGs), but a lot of design tools still export PNG or JPEG by default.

Background Remover

devtools-site-delta.vercel.app/background-remover

This is the flashiest one. Drop in a photo, get back the subject with a transparent background. It uses a pre-trained ML model that runs in the browser via ONNX Runtime or TensorFlow.js.

The model downloads once and then runs locally. Your images never leave your machine. It works surprisingly well for product photos, headshots, and simple compositions. Complex scenes with hair or translucent objects can be trickier, but for most everyday use cases, it gets the job done.

Image Cropper

devtools-site-delta.vercel.app/image-cropper

Visual cropping with preset aspect ratios (1:1 for Instagram, 16:9 for YouTube thumbnails, 4:3 for presentations) or freeform. Drag the crop area, preview the result, download. Nothing fancy, just works.

Extract Colors from Images

devtools-site-delta.vercel.app/image-colors

This one's handy for design work. Upload an image and it extracts the dominant color palette. I use it when I'm building a landing page and want colors that match a hero image. It reads pixel data from the canvas and clusters similar colors together.

Why Browser-Based?

Honestly? Three reasons.

1. Privacy. Your images might contain GPS metadata, sensitive content, or just stuff you don't want on someone's server. Client-side processing means the data stays on your device.

2. Speed. No upload time, no waiting for server processing, no download time. For a 5MB image, that can save 10-15 seconds compared to a server-based tool.

3. No limits. No file size caps, no "5 free conversions per day," no watermarks. Process as many images as your browser can handle.

Part of a Bigger Toolkit

These image tools are part of devtools-site-delta.vercel.app, where I've built 500+ free tools for developers and anyone who's tired of ad-heavy utility sites. PDF tools, JSON formatters, text utilities, color pickers, and a lot more.

Everything's free. No sign-ups. Bookmark whatever you use regularly.

Links:

I Built a Free Browser-Based PDF Merger That Never Uploads Your Files

TateLyman — Sat, 28 Mar 2026 00:37:39 +0000

Every time I need to merge PDFs, the same thing happens. I Google "merge PDF online," click the first result, and get hit with:

"Upload your files to our secure server"
"Free for files under 5MB"
"Sign up to download"

No thanks.

I deal with contracts, invoices, and project docs regularly. I don't want any of that sitting on someone else's server, even temporarily. So I built my own PDF merger that runs 100% in your browser. No uploads. No servers. No accounts.

How It Works

The tool lives at devtools-site-delta.vercel.app/pdf-merge and uses pdf-lib, a pure JavaScript library that can create and modify PDF documents entirely client-side.

Here's the core idea. When you drop files into the tool, it reads them as ArrayBuffers using the File API, then pdf-lib stitches them together:

import { PDFDocument } from 'pdf-lib';

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

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

  const mergedBytes = await mergedPdf.save();
  return new Blob([mergedBytes], { type: 'application/pdf' });
}

That's basically it. PDFDocument.create() makes a new empty PDF, then you loop through each input file, copy all its pages, and add them to the merged document. The whole operation happens in memory inside your browser tab.

Why Client-Side Matters

When I say "no upload," I mean it literally. Open your browser's Network tab while using the tool. You'll see zero outbound requests carrying your PDF data. The files never leave your machine.

This matters for:

Legal documents — NDAs, contracts, anything sensitive
Financial records — tax forms, bank statements
Medical files — HIPAA doesn't care about "secure servers"
Just... privacy — it's your data, keep it yours

Drag, Drop, Reorder, Download

The UX is dead simple. Drag your PDFs in, reorder them however you want, hit merge, and your browser downloads the result. The whole thing takes about 2 seconds for typical documents.

I also handle edge cases that trip up other tools:

PDFs with different page sizes
Encrypted PDFs (if you have the password)
Large files that would hit upload limits elsewhere

I Built a Splitter Too

Same idea in reverse. devtools-site-delta.vercel.app/pdf-split lets you extract specific pages from a PDF. Need pages 3-7 from a 50-page document? Done. Want to pull out just one page? Also done.

The splitting logic is even simpler:

async function splitPDF(file, pageNumbers) {
  const arrayBuffer = await file.arrayBuffer();
  const sourcePdf = await PDFDocument.load(arrayBuffer);
  const newPdf = await PDFDocument.create();

  // pageNumbers is zero-indexed
  const pages = await newPdf.copyPages(sourcePdf, pageNumbers);
  pages.forEach(page => newPdf.addPage(page));

  return await newPdf.save();
}

You select which pages you want, it copies just those pages into a new PDF, and you download the result. Again, nothing leaves your browser.

Word to PDF

I also built a Word to PDF converter that converts .docx files right in the browser. Same philosophy — your documents stay on your machine.

The Bigger Picture

These PDF tools are part of a larger collection I've been building at devtools-site-delta.vercel.app. There are 500+ tools now, all free, all running client-side where possible. JSON formatters, image compressors, regex testers, color pickers — the works.

I got tired of bouncing between sketchy ad-filled sites for basic tasks, so I just... built everything in one place.

If you're a developer who works with PDFs programmatically, pdf-lib is genuinely excellent. The docs are solid, it handles most PDF operations you'd need, and it runs in Node.js too if you need server-side processing.

Bookmark the merger if you deal with PDFs regularly. Your files stay yours.

Links: