WaiverStevie: Seamless eSignature for devs

eSignatures are not Signatures

Collecting a physical signature is a clear-cut process: one party presents a document to the other who can then sign and return. The entire flow occurs in one simple exchange. Incorporating a physical signature into a large pipeline is still easy. Take, for instance, a builder that:

  1. Submits an estimate
  2. Signs a contract
  3. Starts the project.

After sending the client a contract, the builder can just wait for a signed copy before proceeding with the project. Put another way, the signature step does not introduce a technical bottleneck that throws off the rest of the process.

But within the digital realm, things get more complex. Sure, the act of signing something on a screen is close enough to scribbling on a piece of paper. But apps, unlike people, need to be programmed to know if / when a user has signed something.  Thus automating a full pipeline that has a signature step is tough. And when reaching for a conventional eSignature solution like DocuSign, you'll need to make one of these sacrifices:

  • Settle for a manual bottleneck where an admin user checks for signatures and marks them in the system
  • Pay an exorbitant amount for an API plan (around $100 per month for just 40 signatures). Then rewire the rest of the app around a rigid (and poorly documented) API.
  • Axe the signature step and fall back on a far less sufficient form checkbox, which ostensibly acknowledges the terms. Usually, platform constraints disqualify this option.

Integrating an app with eSignature

A client approached us with what seemed a basic (and common) problem. They run a volleyball tournament with thousands of entries. Anyone may register on their website, but athletes had in the past signed liability waivers in person. This year they hoped to streamline the two into a single signup flow.

To add the eSignature step, we conducted an in-depth assessment of the major providers:

In short, these platforms gave us just two options, both very flawed:
  1. - Purchase a standard subscription and have an admin manually send signable waivers via the email feature.
  2. - Go with the expensive API plan (yes, access to an API means a pricier plan), and configure REST requests and webhooks with the app.

The first option meant rewiring the app so that an admin could manually update signups’ waiver status, i.e. had they signed or not. Worse yet, they’d need to hire a human to send and acknowledge waivers in an error-prone process. This option was out.

Option two sounded fine at first. That is, until we had understood each providers’ payment plans. The “basic” API plans hover at around 75$ - 90$ per month (or a yearly lock in of $500), and stipulate that you may send just 40 signature requests! In Docusign’s case, even the $720 per month plan limits you to 100 signature requests. This tournament garnered 4.5 thousand signups, above even the highest plan’s limits. Option two was a non-starter.

WaiverStevie vs the others

WaiverStevie: seamless & affordable eSignature

In the end, our only real option was to bootstrap our own provider, the initial iteration of WaiverStevie. We first built the signing machinery, where users can create signatures with their trackpads and touchscreens. To create a signable document, admins upload any PDF and annotate it (via WaiverStevie interface) with locations for signatures and dates. Signers click on these locations to fill them with the signature they just made.

We strove to build an eSignature solution that could drop right into any app. This meant exposing an API that can 1.) request a signature from someone and 2.) inform you who has signed what. More advanced still, we’ve implemented webhooks so admins could receive a payload upon signatures (or other events). This ensures that platforms can incorporate WaiverStevie without making any compromises on app flow.

WaiverStevie has since collected thousands of signatures. It's allowed multiple projects to automate systems that previously were handled manually. Crucially, it’s done so without ludicrous limits or payment plans. Our most basic plan includes 500 free signatures and our plus plan, 1,000 (both plans are at least 50% cheaper than DocuSign’s non-API plan).  If you need more, no problem; we’ll charge just five cents for each signature beyond what your tier includes.

Having proven the concept of WaiverCat in a couple of our clients’ projects, we’re now live and offer a no-cost Dev Plan.