QSign: Building a Desktop E-Signature Tool

Here’s a conversation that happened in our office: One of our team members was working with a client in logistics. They needed to sign 50+ PDFs a day — delivery confirmations, shipment authorizations, release forms. The client had tried DocuSign. Too expensive for their volume, and they hated uploading sensitive shipment data to the cloud.

Then the client asked: “Can I just… sign them locally? Like, on my computer?”

That question led to QSign.

Digital signatures shouldn’t be complicated. And they definitely shouldn’t require a cloud subscription just to sign a PDF on your own computer. Yet that’s where the market had landed — expensive SaaS tools with monthly fees, or weird plugins that barely work.

We decided to build something different: a lightweight desktop app that lives on your machine, works offline, and lets you sign documents without sending them anywhere.

Why Desktop in 2025?

This was the biggest architectural question. Desktop apps feel dated, right? Everyone uses web apps now. But there are legitimate reasons desktop makes sense here:

Privacy & Security

Some documents can’t leave the organization. A financial firm managing contracts. A government office with confidential records. A medical practice with patient data. For these users, cloud-based signing is a non-starter. Desktop means the document never leaves the machine.

Offline Access

Remote sites, field offices, airplanes. What do they have in common? Unreliable internet. A desktop app works without it. That’s not a luxury; it’s a requirement for some workflows.

No Subscription Model

We hear this constantly from businesses: subscription fatigue. “I already pay for five different SaaS tools. Do I really need another monthly bill to sign PDFs?”

A one-time purchase desktop app solved that. Low cost of entry, no recurring fees, no credit card required.

Performance

A desktop app is fast. Signing a 50-page PDF? Instant. No network latency. No server round-trips.

The Tech Stack

We had to make some interesting choices here:

• Python — cross-platform without needing to rebuild for Windows/macOS/Linux
• Tkinter — yes, really. Built-in to Python, native look and feel, and it’s easier than you’d think for modern UIs
• PyPDF2 and ReportLab — PDF manipulation without heavy dependencies
• Cryptography library — for actual secure signing
• PyInstaller — bundle everything into a standalone executable

Building in Python felt risky at first. Desktop apps need performance, and Python isn’t known for speed. But we were pleasantly surprised. The actual work (PDF manipulation, signing) is fast. The UI is responsive. The bundle size is reasonable (about 80MB after compression).

Features We Built

Custom Signature Design

This was more complex than “just sign with a digital certificate.” Users needed to actually create a signature:

• Text-based signatures (your name in a nice font)
• Logo and image uploads (companies want their letterhead)
• Adjustable size, rotation, and transparency
• Real-time preview as you adjust

We spent more time on this UI than we expected. Making it intuitive took iteration. The first version was clunky. We simplified and simplified until it felt natural.

PDF Import and Preview

This is where a lot of e-signature tools fail. You sign a document and have no idea where the signature went until after you submit.

QSign shows you the document. You click exactly where you want the signature. You see a preview. Then you confirm. No surprises.

Sounds obvious, but many cloud tools don’t do this well. Probably because they’re trying to handle thousands of simultaneous users. We had the luxury of building for one user, one document at a time.

Signature Validation

Here’s something most e-signature tools don’t do well: validation.

We built a system where:

1. Every signature includes a cryptographic hash
2. You can verify a signed document later to confirm:
   • It was signed with your key
   • It hasn’t been tampered with since
   • When it was signed

For the logistics client, this meant they could prove they signed off on a shipment three months ago, and that the document hasn’t been altered since. That’s compliance gold.

Audit Logs

Every action is logged locally:

• Who signed
• When they signed
• Which document
• Which version

For regulated industries, this is mandatory. We made sure QSign’s audit trail was clean and exportable.

Batch Processing

The logistics client needed to sign dozens of documents in a session. So we added batch mode:

• Load multiple PDFs
• Set up your signature once
• Apply the same signature to all documents with the same placement
• Export all at once

Saved them hours per day.

Building the UI in Tkinter

Tkinter, used thoughtfully, offers a dependable cross-platform UI layer.

We used:

• System-matched themes for a native feel
• Consistent typography and color tokens
• Appropriate layout managers for predictable resizing
• Background threading for long operations (PDF loading, signing) to maintain responsiveness

For PDF preview, we used a pdf2image-based rendering approach to provide accurate on-canvas previews prior to signing.

Cross-Platform Testing (The Unexpected Challenge)

“It works on my machine” took on new meaning. We built on macOS. Tested on Windows in a VM. Then deployed to a Linux server running in a warehouse.

Things that broke:

• File path separators (Windows uses backslash, Unix uses forward slash — Python helped here)
• Font rendering (different fonts available on different systems)
• PDF rendering (subtle differences in how each OS renders PDFs)
• Screen scaling (high-DPI screens on Windows, Retina on macOS, standard on Linux)

We tested on:

• Windows 10 and 11
• macOS Big Sur, Monterey, Ventura
• Ubuntu 20.04 and 22.04

Each platform got 2-3 weeks of dedicated testing. Not glamorous, but necessary.

The Weird Bugs

Of course, there were weird bugs:

Bug 1: The Signature That Wouldn’t Disappear

A user applied a signature to the wrong page, tried to undo, but the signature ghost remained. Turned out the undo logic wasn’t clearing image references properly. Fixed by being more aggressive about garbage collection.

Bug 2: The Rotated PDF

Some PDFs have rotation metadata that the viewer respects but PDFs libraries ignore. A rotated PDF would show correctly in the preview, then the user would sign it, and the signature would appear rotated. Took forever to debug. The fix involved reading PDF metadata before processing.

Bug 3: The Midnight Bug

Signatures created after midnight were getting the wrong timestamp. Classic edge case — our timestamp code wasn’t timezone-aware. User in Tokyo signing at 11:59 PM, and the logged timestamp was different from actual time. Fixed with proper timezone handling.

Launch and Real-World Usage

We launched QSign in August. The logistics client started using it immediately. Within a month:

• They’d signed 2,000+ documents
• Workflow time went from 5 minutes per document (including cloud uploads) to 30 seconds
• No more “wait, did that upload?” moments

Other clients came on:

• A law office using it for contract signings
• A medical practice for patient consent forms
• A real estate firm for closing documents

What Actually Surprised Us

1. People still want desktop apps. Everyone talks about web-first, but for certain workflows, desktop is better.
2. Performance matters more than we thought. Users feel the difference between instant signing and a 2-second cloud round-trip.
3. Compliance isn’t just legal; it’s peace of mind. Users loved having audit trails. It gave them confidence.
4. One-time purchase vs. subscription is underrated. The cost was low ($50), so it was an easy sell. No approval meetings needed.

Limitations and Future Plans

QSign isn’t meant to replace enterprise e-signature platforms. It’s meant to be simple, fast, and offline-first.

Things we might add:

• Certificate-based signatures (for legal compliance in certain jurisdictions)
• Biometric authentication (fingerprint/face ID on supported systems)
• Team mode (shared signature library)
• Integration with document management systems

But the core is solid. A tool that signs PDFs without unnecessary complexity. That was the goal, and we hit it.

Need a custom desktop tool or offline-first application? We’d love to hear from you.