I Vibe-Coded a Signable Invoice App in About 12 Minutes

I wanted to see how far a single sitting could go. The goal was simple to say and historically annoying to build: an invoicing app that produces a PDF with a real signature field, then emails that invoice to a client so they can sign it. No starter template, no SDK archaeology, no afternoon lost to documentation. Just describe what I wanted and let the AI build it.

That describe-it-and-let-the-AI-write-it loop is exactly what vibe coding is. It gets dismissed as a way to ship disposable frontends, but it shines on the work developers least enjoy: forms, file generation, and integration plumbing. A signable invoice app is all three. I used Lovable for the app itself (see the full Lovable review for a deeper look at the tool) and the TurboDocx Quickstart Skill to teach it how to send documents for signature. Total time, start to working app: about 12 minutes.

Vibe coding means you describe the outcome you want in plain language and an AI agent writes the code. You stay in the loop as the editor, not the typist. The skill is in choosing the right prompts and reviewing what comes back, which is why this works best when the agent has ground truth for the tricky parts. For document signing, that ground truth comes from the Quickstart Skill: it gives the agent the exact install command, the real SDK surface, and the conventions to follow, so it does not guess at method names or hardcode secrets. The same Quickstart Skill is agent-agnostic, so if you prefer a code-first editor you can vibecode an e-signature flow in Claude Code or Cursor with the identical prompts. If you want the longer treatment, here is what vibe coding is in full.

The second prompt did the heavy lifting. By pointing Lovable at the Quickstart Skill, I gave it a single command to teach itself everything it needed about signing:

npx skills add TurboDocx/quickstart

That installs an open Agent Skill through the skills CLI. The skill gives the agent the real TurboSign SDK surface and reads credentials from environment variables instead of baking them into source. For this app the values were:

TURBODOCX_API_KEY=your_api_key_here
TURBODOCX_ORG_ID=your_org_id_here
TURBODOCX_SENDER_EMAIL=you@company.com
TURBODOCX_SENDER_NAME=Your Company Name

Grab those from a free account at app.turbodocx.com (your first 5 signatures each month are free). Behind the “Send for signature” button, TurboSign takes the generated invoice PDF, sends it to the signer's email, and collects the signature on hosted infrastructure. If you want the longer walkthrough, here is the step-by-step TurboDocx and Lovable integration guide and adding e-signature to a Lovable app in detail.

The first version of the send flow stopped at a review step, so the recipient saw an “under review” status before the email went out. I did not want that for invoices, where the point is to get the document in front of the client immediately. So I asked for the change in one sentence, and Lovable swapped the call: instead of createSignatureReviewLink, the app now uses sendSignature directly, which fires the email right away with no review gate. That is the kind of distinction you would normally only find after reading the API docs carefully. Here, it was a single follow-up prompt.

The result is a small but complete invoice generator. You fill in the invoice details, the app produces a PDF with interactive signature and date fields, and you can download that signable PDF directly. Enter a signer name and email, click “Send for signature,” and TurboSign emails the invoice for the client to sign. Three screens, one real workflow, and every signature handled by a hosted API rather than my Friday afternoon. If the PDF mechanics are new to you, how signable PDFs work and what an electronic signature is are good primers, and e-signatures for invoices covers why this matters for getting paid.

The headline is not that I saved a few hours. It is that someone who cannot write a line of code could have run the same three prompts and gotten the same app. To put the 12 minutes in context, a from-scratch build would realistically run a few days once you add up the moving parts. As an illustrative estimate, not a measured benchmark:

• Pick and read an e-signature SDK, set up an account, find the API key flow (half a day)
• Build the invoice form and a PDF generator with real signature fields (a day or two)
• Wire the send flow, handle the review-vs-direct-send distinction, test emails (another day)

For a realistic deep dive on those numbers, see how long it actually takes to build a signing app from scratch. The point of vibe coding is that the same outcome arrives in minutes because the AI handles the form, the PDF, and the integration while you stay focused on the result. You can see the whole approach in add e-signatures to invoices without code and the no-code e-signature stack.

A fair caveat: signatures are legal instruments, so the parts that need human judgment still need it. Read the diff, confirm the right people sign in the right order, and handle the decline and expiry cases, not just the happy path. Vibe coding legal documents covers where the AI build ends and careful review begins. The compliance heavy lifting (tamper-evident audit trails, ESIGN, UETA, and eIDAS alignment) runs on TurboDocx infrastructure, which you can read about in the US e-signature compliance and European compliance guides, and on the e-signature API overview.

Want to try the exact build yourself? Open your AI app builder, install the TurboDocx Quickstart Skill, and use the same three prompts. The Lovable project from this run lives at this Lovable project link if you want a reference point.