From handshake to signature

In Per bowl, not per hour we said the brief is the contract, the price respects the brief, and the deadline respects both. Nice words. But there’s a gap between a client saying “yes, let’s do it” and the kitchen actually turning on — the awkward stretch where nobody’s sure who sends what, which PDF is the final one, or whether the thing was ever really signed.

We closed that gap with two small tools we built ourselves and one file that travels between them. This is the story of how a “yes” becomes a signature. If you’re a client, it’s what the first couple of days with us feel like. If you build things, it’s a small case study in doing more with less.

Every quote is just a file

The first tool is QuoteBowl, and its whole personality fits in one sentence: a quote is just a file. You build it in the browser — client details, line items, discounts, tax, live totals ticking along as you type — and out comes a clean, branded PDF and a small portable file that captures the whole thing. No server humming in the background, no database to babysit. Close the tab, open it later, your work is still there.

We were fussiest about the money. Prices are counted in whole cents rather than dollars-and-decimals, because rounding a fraction of a penny the wrong way is exactly how a quote ends up off by a cent from the invoice. The math that adds it all up is a single, carefully tested recipe — and the same recipe feeds both the numbers on screen and the numbers on the PDF, so the two can never quietly disagree. The subtle bit is discounts and tax: knock 10% off a quote with a mix of taxable and non-taxable lines, and the tax has to shrink by the right amount on only the taxable side. That’s the kind of thing you get wrong once, in front of a client, and never again.

The rest is comfort: it saves as you go, it undoes generously when you fat-finger something, you can drag line items into order, and the PDF comes out looking like us — real logo, real fonts — instead of a generic document.

An honest word about the lock on the door

Here’s the part most studios wouldn’t say out loud. QuoteBowl’s login screen isn’t real security. It’s a speed bump — a tool that lives on our own internal network, gated by a simple password so a stray browser tab doesn’t wander in, nothing more.

Why admit that? Because the danger isn’t the speed bump; it’s pretending it’s a vault. We know exactly what it is and where it’s safe to run, and because the quote is just a portable file, the day we need real accounts we can add them without tearing the tool apart. Knowing what something isn’t is half of building it well.

The handoff

QuoteBowl is ours. It’s internal, and the client never touches it. So how does the quote reach them?

That portable file gets handed to the second tool — quotebowl-sign, the public-facing one — which picks it up and turns it into a “deal” the client can open from a link. This is the quiet trick that makes the whole thing trustworthy: both tools speak the same format, so the quote the client approves is the exact quote we built. Nothing is retyped, nothing is “let me just re-export that and email it over,” nothing drifts between versions.

The client’s side of the table

For the client it’s simple: a link arrives, they open it, they read the quote, and when they’re happy they approve and sign — all in the browser, on their phone if they like. No account to create, no app to download, no printer.

Behind that calm surface, a deal moves through a fixed set of stages, and it can only move forward one step at a time.

It goes from sent to viewed to accepted to out for signature to signed — with declined and expired as the honest off-ramps. A deal can’t leapfrog from “sent” straight to “signed,” and once something is signed or declined, that’s final. If a quote expires, we can send a fresh one; we can’t quietly reach in and change history. That constraint isn’t bureaucracy — it’s what keeps everyone honest about where things actually stand.

Why a trail beats a filing cabinet

This is the part we’re quietly proud of, and it’s why we built our own instead of renting a signing service by the seat.

Every meaningful moment — the client opening the quote, approving it, agreeing to the terms, signing — gets written to a log that we only ever add to and never edit. That log is the proof: a timestamped account of who did what, and when.

And the documents themselves are fingerprinted. When we show a contract, we record a unique cryptographic fingerprint of exactly what was on the client’s screen; when they sign, we record another for the signed copy. Those two fingerprints bind “what we showed you” and “what you signed” together. If anyone ever claimed the signed contract said something different, you check the fingerprint against the stored file — it either matches or it doesn’t. There’s no arguing with the math. It’s more rigor than a quick e-signature button gives you, and it costs us nothing per signature.

What we deliberately didn’t build

You’ll notice what’s not in here. No user accounts, no cloud sync, no multi-currency, no payment links, no automated email blasts. We drew that line on purpose for the first version.

That’s not laziness — it’s the same fixed-scope discipline we sell. We built the thin slice that actually closes a deal: make the quote, get it approved, get it signed, keep the proof. Everything else waits on a list until it earns its place. We hold our own tools to a brief exactly the way we hold a client project to one.

The quietly nerdy bit

For the builders reading: there’s no always-on server anywhere in this. Both tools live at the edge — pages served straight to the browser, with tiny functions that wake up only when someone acts and go back to sleep after. The whole path from quote to signature, proof trail and all, runs with nothing to keep patched at two in the morning and nothing to scale when a busy week hits.

Could you outgrow it? Sure — real accounts, a proper identity system, a hook into a CRM. But most small studios never actually reach that wall. A portable file, a strict set of stages, fingerprinted documents, and the edge get you much further than the reflex to “just stand up a backend” would have you believe.

The simple version

A quote your client can open from a link, read, approve, and sign in a couple of taps — and a record that proves they did, one nobody can quietly rewrite afterward. The handshake still matters most. We just made everything after it as clean as the conversation that earned it.

— The Geek Cat