DEV Community: Maaz Sohail

PDF Signing Became a Daily Habit (2026 Reality Check + How I Fixed It Fast)

Maaz Sohail — Wed, 18 Feb 2026 14:41:14 +0000

In 2026, signing documents isn’t a “special event” anymore.

It’s a weekly — sometimes daily — thing.

Contracts. Freelance agreements. Offer letters. NDAs. Client approvals. Rental forms. School documents. Government paperwork. Bank forms. Vendor onboarding.

And the weird part?

Most of these documents are still PDFs.

So if you work with PDFs (even a little), you’ve probably hit this moment:

You get a PDF. Someone says, “Sign it and send it back today.”

You open it… and suddenly you’re stuck.

Because signing PDFs sounds easy… until it isn’t.

The problem: PDF signing is simple… until you care about privacy and speed

Here’s what used to happen to me:

I’d receive a PDF to sign.
I’d try to “print and sign” (waste of time).
Or I’d use a random tool… and feel unsure about uploading sensitive documents.
Or I’d end up installing something heavy on my laptop.

The “sign a PDF” workflow became frustrating because it’s always urgent.

And in 2026, urgent wins.

So I built a simple workflow I can trust.

Why “Sign PDF” became a necessity for everyone in 2026

Let’s be real — signing PDFs isn’t optional anymore. It’s now part of normal work.

Here’s why it exploded:

Remote work is default: people aren’t sitting near printers. They’re signing from laptops and phones.
Speed expectations are higher: nobody says “send it next week.” They say “please sign today.”
Documents move faster than people: paperwork moves at the speed of Slack messages.
Everyone is onboarding something: clients, tools, vendors, hiring — signatures everywhere.
Privacy matters more: more people are cautious about uploading sensitive documents to random websites.

So the real need isn’t just “sign a PDF.”

The real need is:

Sign it fast. Keep it private. Don’t install anything. Don’t ruin the document.

The moment I realized my signing process was broken

A client sent me a contract. Standard PDF.

They wanted it signed and returned the same day.

I was busy. I didn’t want to print. I didn’t want to scan. I didn’t want to email a half-broken screenshot-signature back.

And I definitely didn’t want to upload a sensitive document somewhere sketchy.

So I tested what “good” looks like:

Upload PDF
Add signature
Download signed PDF
Done

No weird steps. No confusing UI. No forced accounts.

That was the goal.

The fix: a simple “Sign PDF” tool that actually feels normal

That’s why I started using this:

👉 Sign PDF online (free)

It’s built for the exact moment you’re in:

“I have a PDF. I need to sign it. I need it done right now.”

My 60-second signing workflow

Upload the PDF

Just drop it in.
Add your signature

Draw it, type it, or place it the way you need.
Position it properly

Put it exactly where the signature belongs.
Download the signed PDF

Send it back immediately.

That’s it.

No printing. No scanning. No “what file format is this?” chaos.

Why “private signing” became a big deal for me

Here’s the thing most people ignore:

A lot of documents you sign are not “public.”

They contain:

ID numbers
addresses
bank details
salary info
legal terms
company names
personal signatures

So if you’re signing anything sensitive, privacy becomes part of the workflow.

That’s why I also use this page when I’m signing something personal/confidential:

🔒 Sign PDF document privately

Not everyone cares about this… until they absolutely should.

Common PDF signing mistakes (and how to avoid them)

Signing with screenshots

Looks unprofessional and often gets rejected.
Printing + scanning

Slow, reduces quality, and creates huge file sizes.
Uploading to random tools

You don’t always know what happens to your file.
Putting the signature in the wrong place

Some documents require signature + date + initials in specific spots.

My simple rule: if you’re signing for a client, a job, or legal paperwork — do it clean.

2026 reality check: Signing is normal now

Signing PDFs used to feel like a “special task.”

Now it’s normal.

The best tools in 2026 are the ones that feel invisible:

fast
simple
no friction
no account wall
works on any device

If you need to sign a PDF quickly, here’s the tool I use:

✅ Sign PDF online

Quick question (for real people, not bots)

What do you sign most often?

contracts
freelance agreements
job offer letters
school docs
government forms
client approvals

Drop your most common one — I’m collecting real workflows to improve the signing experience.

Why I Built a Privacy-First Image Converter (PNG, JPG, WebP, HEIC, AVIF) That Processes Files in the Browser

Maaz Sohail — Tue, 17 Feb 2026 13:23:57 +0000

The Problem With Most “Free” Image Converters

If you have ever searched for:

convert WebP to PNG

resize image to 300x300

compress image for website

convert HEIC to JPG

You already know the experience.

You upload your image.
The tool sends it to a remote server.
You wait.
Then you download it back.

Most free image tools rely on cloud processing. That means your images are uploaded to a third-party server before conversion happens. For personal images this might not matter. For work files, client assets, or sensitive screenshots, it can.

On top of that:

Bulk conversion is often restricted

Zip downloads are locked behind paywalls

Watermarks get added

Ads overwhelm the interface

I wanted something simpler.

Why Local Browser Processing Matters

Modern browsers are powerful enough to handle image processing directly.

When images are processed locally in the browser:

Files do not need to be uploaded for processing

Conversion is often faster

There is less reliance on external servers

The workflow feels lighter and more direct

This approach is especially useful for:

Developers handling many assets

Designers exporting multiple formats

Ecommerce sellers resizing product images

Content creators preparing social media uploads

Features That Actually Matter in an Image Converter

After studying how people search and use these tools, I focused on a few high-intent features:

Format Conversion

Support for common and modern formats:

PNG to JPG

JPG to WebP

WebP to PNG

HEIC to JPG

AVIF conversion

GIF, BMP, TIFF support

Bulk Image Conversion

Many free tools limit batch uploads. Supporting multiple images at once makes a huge difference for real workflows.

Zip Downloads

If you upload 20 images, you should not have to download them one by one.

Resize by Pixels or Percentage

Use cases like:

resize image to 300x300

resize image to fit within 1080px

resize image by 50 percent

Image Compression

Reducing file size for:

website performance

faster page loads

SEO optimization

Why I Built creatoryn

Creatoryn started as a simple browser-based image tool focused on:

format conversion

resizing

compression

cropping

bulk processing

no signup

The core idea was simple:

Process images locally in the browser and remove friction.

No accounts.
No unnecessary dashboards.
No forced upgrades for basic features.

It is designed for high-intent users who search for specific actions like “convert WebP to PNG online” or “compress image under 100kb.”

Who Should Use a Browser-Based Image Tool?

You will likely benefit from this approach if you:

Regularly convert between PNG, JPG, WebP, AVIF, or HEIC

Need to resize images for Instagram, YouTube thumbnails, or LinkedIn

Optimize images for websites

Work with bulk image files

Prefer not to upload files to external servers for processing

Final Thoughts

The internet does not need more complex SaaS dashboards.

It needs reliable utilities that solve narrow problems extremely well.

If you are building tools, consider this:

Sometimes the most valuable products are the ones that remove friction quietly.

And if you are searching for a free image converter, look beyond “free” and ask:

Is it fast?
Does it support bulk?
Does it process locally?
Does it keep the workflow simple?

Those questions matter more than flashy branding.

I was tired of “free” PDF editors that upload files and add watermarks — so I built a client-side one

Maaz Sohail — Thu, 16 Oct 2025 21:30:55 +0000

Most “free” PDF editors aren’t really free. You upload a file, fix a typo, hit download… and get a watermark or a paywall. Worse, your document lives on someone else’s server now.

I’m a builder and I needed a tool I could trust. So I made one: a 100% client-side PDF editor. No signup. No watermark. Your file never leaves your device. This post is the story — what we tried, what broke, and what finally worked.

The problem we kept hitting:

Bait-and-switch UX: “Free” until the last click.
Privacy risk: Uploading IDs/contracts to unknown servers isn’t acceptable for many people or companies.
Latency and cost: Upload → process → download is slow, and server costs scale as you grow.

The obvious answer: don’t upload at all. Do the work in the browser.
**
What “client-side PDF editing” really means**

PDFs are a weird mix of vector graphics, text glyphs, images, annotations, and page transforms. In practice we needed to solve five things:

Parse and render pages fast enough that mobile users don’t bounce.
Edit text without wrecking layout.
Place images/logos/stamps precisely.
Capture signatures smoothly (mouse/touch) and embed them reliably.
Export a clean PDF instantly, all offline.

We leaned on modern web APIs: WebAssembly, Canvas, OffscreenCanvas, Web Workers, and careful memory management. No servers required.

Text editing: “glyph runs” and white-out surgery

PDF text isn’t like a contenteditable div. It’s positioned glyph runs. Our approach:

Detect text runs on the page.
When the new text doesn’t match metrics exactly, place a subtle white-out rectangle behind the edited area to “erase” the old glyphs, then draw the new text on top (preserving alignment/flow).
Support common font choices; fall back gracefully when fonts aren’t embeddable.

This was the most fragile part. Early versions had hilarious bugs: a single emoji could push a line 2px and every subsequent line went crooked. Fix: normalize metrics and snap to baselines.

Images & logos: pixels meet PDF space

Placing a PNG/JPG/WebP on a PDF page sounds simple until you remember that PDF has its own coordinate space with transforms. We convert CSS pixels → PDF user units, apply rotation/scale, and clamp to page bounds. For logos with transparency, PNG with alpha is ideal.

Signatures: feel matters

We capture pointer events, smooth the path (Catmull–Rom → cubic Beziers), and embed the result as a vector or high-res bitmap. The two things that made it feel “real”:

Slight pressure simulation based on velocity (thicker when moving faster).
Immediate feedback at 60fps using a worker + offscreen canvas on supported browsers.
Performance: how we kept it snappy on a Moto G
Lazy page rendering: only draw the viewport + a small prefetch window.
Worker pool: parsing/rendering off the main thread to keep TBT ~0–30ms.
Chunked processing: stream large PDFs and free buffers aggressively.
No layout thrash: one write per frame; batch DOM updates; avoid sync measures.
Result: on mobile we see ~1.2s FCP and ~1.5s LCP for the landing UI, and edits feel instant.

Privacy & trust: rules we set for ourselves

Default: no network calls. The editor runs locally.
If you choose an optional cloud action later, it’s explicit and TLS-only.
No watermark, no usage caps, no “gotcha” step. We’d rather earn goodwill than convert via traps.
**
What we got wrong (so you don’t have to)**
Font chaos: even when you think you embedded a font, subsetting can bite you. We added thorough fallbacks and test PDFs with non-Latin scripts.
Mobile Safari limits: large canvases + memory spikes = crashes. Fix: tile rendering and lower peak memory.
Pointer jitter: naive smoothing feels sluggish. Velocity-aware smoothing felt right.
Export size: we shipped a build that ballooned file size after multiple edits. The culprit: duplicate image XObjects. We now dedupe assets on export.

Open problems we’re still chewing on

Full OCR for scanned PDFs (we’re evaluating on-device models).
True find & replace across pages.
Batch stamping (same logo on N pages in one step).
PDF/A export for archival workflows.

If you’re building something similar, these patterns helped

Workers everywhere. Even small parsing tasks benefit.
One source of truth for coordinates. Don’t mix CSS pixels, device pixels, and PDF units across modules.
Design for failure. Fonts missing? Fall back. Image corrupt? Render a placeholder and let the user continue.
Keep promises user-visible. “No watermark” is a commitment — put it in the UI, not just the blog.

Want to try it (no pressure)

If a truly free, client-side editor is useful, you can try it here: pdffreeeditor.com.
No signup, no watermark; edit, sign, merge/split, and add images right in the browser.

I’d love feedback on edge cases (weird fonts, giant scans, RTL text). If you’ve solved similar problems in canvas/WebAssembly, please share your tricks — I’ll happily credit and implement.

— Maaz