How to Auto-Generate Contracts with E-Signature in Your Business App (Mobile + Web)

There is a workflow inside almost every SMB that wastes days per month and nobody notices it as a problem because it has always been this way:

1. A salesperson sends a quote to a client.
2. The client agrees verbally or via email.
3. Someone in the office takes a contract template (Word doc, usually).
4. Fills in the client name, the budget, the dates, the clauses.
5. Emails it as a PDF to the client.
6. The client prints, signs by hand, scans, emails back.
7. Office files the scan somewhere.

For a small business this is a few hours a week. For a $20M construction company with 20 active quotes at any time, this is one or two full-time admin roles. Multiplied across a year, the cost is real.

The fix is automatic contract generation with e-signature, integrated directly into your business app. Tap a button on an approved quote, the contract goes out, the client signs on their phone, the signed PDF returns and saves to your database. Days of admin work compressed to seconds.

This is the playbook.

The Pattern That Works

1. Template Once, Generate Forever

You define your contract template once. It has fields for client name, budget, clauses, dates, anything that varies. Two options for where the template lives:

• Inside your app code as an HTML / Markdown template, rendered to PDF via a library (react-pdf, pdfkit, jsPDF).
• In the e-sign provider's template system (DocuSign Templates, Dropbox Sign Templates, etc.). You upload a Word doc with merge fields, they handle the PDF generation.

For SMB use cases, the e-sign provider's templates are simpler. For complex multi-section contracts with conditional clauses, your own PDF generation gives more control.

2. The Button on the Quote Screen

In your app, when a quote is approved, a button appears: "Generate contract & send for signature." The user taps. What happens behind the scenes:

1. Your Supabase Edge Function (or Cloudflare Worker) is called with the quote ID.
2. The function loads the quote from your database, plus the client and project data.
3. It calls the e-sign API to create a new "Signature Request" using your template, with merge fields filled in.
4. The provider sends a signing email or SMS to the client with a link.
5. The function returns a status to your app: "Sent to client@example.com." A pending-signature record saves to the contract table.

Total time from tap to "sent": about 4 seconds.

3. The Client Signs on Their Phone

The client opens the email. Taps the link. A mobile-friendly signing page opens in their browser. They review the contract, tap "Sign here," draw their signature with their finger, tap submit.

No app to install. No printing. No scanning. Works on iPhone, Android, desktop browser, all out of the box.

4. The Signed PDF Returns to Your App

When the client signs, the e-sign provider fires a webhook to your backend. The webhook:

1. Verifies the signature is complete.
2. Downloads the signed PDF.
3. Stores the PDF in Supabase Storage or Cloudflare R2.
4. Updates the contract record: status = signed, signed_at = timestamp, signed_pdf_url.
5. Sends a push notification to the salesperson and the owner.
6. Optionally: triggers an invoice generation flow, schedules the project start, whatever next step you defined.

End-to-end, with a responsive client, this can complete in under 10 minutes from quote approval to signed contract.

The E-Sign Provider Comparison

For most SMB operators starting out, Dropbox Sign or SignNow are the simplest. Both have generous free tiers for testing.

The Implementation in Rork (~Half a Day)

This is what you tell Rork in plan mode:

"On the quote detail screen, add a button labeled 'Generate contract & send for signature.' When tapped, it should call a Supabase Edge Function that creates a signature request via Dropbox Sign using my template (template ID stored in env vars), with the client's name, email, and the quote amount as merge fields. Then it should save a pending contract record and show a confirmation toast. Set up a webhook endpoint that receives the signed PDF, stores it in Supabase Storage, and updates the contract record. When signed, fire a push notification to the owner."

Plan mode interrogates the edge cases:

• What if the client never signs? Add an expiration date (default 14 days) and a reminder flow.
• What if multiple parties need to sign? Handle the second-signer flow (your e-sign provider supports it via templates with multiple sign-here fields).
• What if the client wants to negotiate? Add a "Send for review (not signature)" option that lets them comment before final sign-off.

Then Rork builds. You connect the e-sign provider credentials. You test in their sandbox. You go live.

What This Looks Like for a Real Business

A construction company in Spain runs this exact flow. Provider contracts that used to take days of back and forth (template editing, PDF emails, phone reminders) now take a button click. The owner described it as: "Right now we have only to get a budget and with the button, we get a full contract for myself with all the articles that I want and with the budget, and send it to that person, and that person gets an email with a link. In that link they open and they can sign directly, and then we get the contract signed."

His office no longer has someone whose job is "chase signatures." The system runs itself.

Where to Be Careful

Three things to plan around:

1. High-value contracts may need a lawyer's review. A button-generated contract is fine for most business deals. For multi-million-dollar contracts, have a lawyer review the template once.
2. Document storage retention. Signed contracts often need to be retained for 6 to 10 years for tax/legal reasons. Make sure your Supabase Storage / R2 bucket has lifecycle rules and backups.
3. Compliance varies by jurisdiction. US, UK, EU, Latam all accept advanced e-signatures for most business contracts. Some specific contract types (wills, certain real estate deeds) require notarized or hand signatures. Always check locally.

Where to Start

Open Rork. Tell it: "Add a contract auto-generation and e-signature flow to my business app." Use plan mode to walk through the edge cases. Pick Dropbox Sign or SignNow as your provider. Set up a sandbox account (free). Build the flow in an afternoon. Test with yourself as the signer.

For related operator workflows:

• How to Build a Mobile CRM Your Team Will Actually Use
• How to Build a Mobile App for Your Construction Company