AI for Developers

I Vibecoded E-Signature in an Afternoon

Not a demo, an actual feature in a real app. I blocked out an afternoon and needed about forty minutes, with working code roughly ten minutes in. Here is the honest timeline.

Alex Martinez
Alex MartinezDeveloper Relations & Automation Lead
June 5, 20265 min read

I started the clock at 1:00 on a Tuesday afternoon, with an AI coding agent and the TurboDocx Quickstart Skill open in front of me. By 1:10 there was working code in the repo. At 1:14 I sent myself a real contract, signed it, and watched the completed PDF and audit trail come back. The signature was out the door before my coffee got cold. The integration was the fast part. The careful part, as it should be, was the review and the edge cases that came after.

Here is the real timeline, so you can calibrate your own expectations.

Start to finish, minute by minute

1:00

Scope it, install the skill, grab a key

Wrote down what "done" meant in one line: send a contract, collect a signature, get the signed PDF back. Then ran npx skills add TurboDocx/quickstart and signed up for a free account. Pasted the four credentials into .env. Two or three minutes, most of it waiting on the signup email.

1:10

Working integration, done

One plain-English prompt. The agent detected the framework, installed the SDK, configured it from the env vars, and wrote a send module plus an example route. The send call was a single sendSignature with the file, the recipient, and a signature field. Code finished about ten minutes after the skill went in.

1:14

First real signature email

Ran the example against my own inbox. The request email landed, I opened the link, dropped a signature, and watched the completed PDF plus the audit trail come back. Working end to end in under fifteen minutes.

1:22

The one thing that tripped me up

My very first send threw before any email went out. The cause was boring and fixable: senderEmail is required, and I had left TURBODOCX_SENDER_EMAIL out of .env. Set it, re-ran, and the email arrived. Worth knowing so you do not lose five minutes to it like I did.

1:30

Webhook and the edge cases

Added a completion webhook so the app reacts when a document comes back signed, then handled the paths that are not the happy one: a recipient who declines, and a request that expires before anyone acts. This part, not the SDK wiring, is where the remaining minutes went.

1:40

Review and ship

Read the diff like a normal PR, confirmed the key only ever lived server-side, and merged. Done well before the afternoon I had blocked off was.

The one command that starts the clock

Everything above starts here:

npx skills add TurboDocx/quickstart

After that, it is plain English in your agent. The full step-by-step is in the Claude Code guide and the Cursor guide, and the deeper walkthrough lives in Vibecode an E-Signature Flow.

What actually took the time

The agent wrote the happy path in minutes. What little time remained went to the things that make a feature production-ready, not the SDK wiring:

Verifying the webhook signature before trusting a completion event
Storing the signed PDF and audit trail somewhere durable
Handling declined and expired documents, not just signed
Confirming the API key only ever lived in the serverless layer

That split is the point. Letting the agent handle the boilerplate freed up the afternoon for the judgment calls that actually deserve a human.

The afternoon, told straight

The timeline above is clean because the work mostly was. But a few moments are worth slowing down on, because they are the ones that actually decide whether you ship by mid-afternoon or burn the whole day.

The first stretch was scoping, not coding. Before I let the agent touch anything, I wrote one sentence describing what finished looked like: a contract goes out, a signature comes back, the signed PDF lands somewhere I control. That sentence is what kept the prompt tight. I was not asking for a signing platform. I was asking for one flow, end to end. Installing the skill and grabbing a key took longer than scoping did, and most of that was the signup email.

The middle stretch was the send flow and the first real email. The agent wrote a single sendSignature call: a file, a recipient, and a signature field. I pointed it at my own inbox first, which is the move I would recommend to anyone. When that request email actually showed up, I opened the link, signed, and the completed PDF came back with an audit trail attached. That is the moment the feature stops being theoretical. It also surfaced the one snag of the day. My very first send threw before any email left the building, and the reason was unglamorous: senderEmail is required, and I had not put TURBODOCX_SENDER_EMAIL in my env file. One line added, one re-run, and the email arrived. If your first send fails fast with nothing in your inbox, check that env var before you check anything else.

The last stretch was the edge cases and shipping. Signed is the easy outcome. The ones that bite later are the recipient who declines and the request that quietly expires, so I wired both into the completion webhook alongside the success path. Then I read the diff like any other pull request, confirmed the API key never left the server, and merged. The afternoon I had set aside was still mostly ahead of me.

If you want the benchmark version of this, with the clock running against a more traditional build, see how long it takes to build an e-signature app. And if you would rather just start, the Quickstart Skill is the same one I used here.

Related Resources

Start your own afternoon

Install the Quickstart Skill and prompt your agent. Your first 5 signatures each month are free.