# Build your own PandaDoc alternative

> Build your own PandaDoc with Cursor, Claude Code or Lovable. A PandaDoc alternative for proposals and quotes: your pricing tables, acceptance and e-signature.

Source: https://esigncomply.com/build/pandadoc-alternative

Build guide · proposals and quotes

You're building a proposal tool: a quote with a pricing table, a link you send to the client, and an Accept button that counts as a signature. The pricing table is your UI, and Esign Comply gives your AI tool the acceptance rules and keeps the independent record of what the client agreed to.

[Get started](https://esigncomply.com/signup) · [Generate a prompt](https://esigncomply.com/product/prompt-generator)

Free plan: 10 live signatures a month and a full test mode. No card required.

The flow, and who does each part

1. Compose the proposal and its pricing table · You
2. Email the client a link to the proposal page · You
3. Client reviews, types a name, clicks Accept · You
4. Acceptance reported from the client's browser · Esign Comply
5. Sealed record pinned to the exact quote · Esign Comply
6. Accepted PDF to both sides, deal marked won · You

## What you're building: a proposal and quote tool

A sales document that closes itself. These are the parts people expect from a proposal tool.

### Proposal builder

Cover page, scope, timeline and terms, composed from blocks you design.

### Pricing tables

Line items, quantities, discounts, tax and totals, calculated by your code.

### Optional line items

The client ticks the add-ons they want and the total updates on the page.

### A proposal page per client

One link per deal, on your domain, with your branding.

### Accept and sign

The client types their name and clicks Accept. No printing and no scanning.

### View tracking

You see when the client opened the proposal and how often they came back.

### Templates and a content library

Reusable sections, saved products and prices, one click to start a new quote.

### Accepted copy as a PDF

Both sides receive the proposal as accepted, with names and dates.

You vibe code · Esign Comply handles

## Who does what in your PandaDoc alternative

The editor, the math and the page are yours. Esign Comply pins the exact quote the client accepted and holds the record of the acceptance.

### Proposal editor and templates

You vibe code

The editor, the content blocks and the template library.

Esign Comply handles

Registers the final proposal as an immutable document version.

### Pricing table

You vibe code

Line items, options, discounts, tax and totals. Your UI and your math.

Esign Comply handles

The accepted prices sit inside the registered version, so the record names the exact quote by hash.

### Share link and emails

You vibe code

The proposal link, the cover email and the follow-ups, sent with a provider such as Resend.

Esign Comply handles

The one-time code email at L2, sent and confirmed by Esign Comply.

### Acceptance and signature

You vibe code

The acceptance block on your page: notice text, name field, Accept button.

Esign Comply handles

The rules prompt for that block, and the browser SDK that reports the acceptance from the client's browser.

### Deal status

You vibe code

Draft, sent, viewed, accepted and expired in your own pipeline.

Esign Comply handles

`GET /v1/records/{id}` and the signed `record.completed` webhook, so accepted means confirmed.

### The accepted copy

You vibe code

The PDF of the accepted proposal and the emails that deliver it.

Esign Comply handles

An evidence report for the acceptance, a public verification page and an optional emailed copy to the signer.

### The record

You vibe code

Our receipt, stored on the deal.

Esign Comply handles

The sealed record, a signed receipt (ES256), an RFC 3161 timestamp and a hash-chained ledger.

9 steps

## How to build your PandaDoc alternative, step by step

Nine steps from a draft quote to an accepted proposal with a record behind it.

1. **Generate the prompt**

   In the Esign Comply dashboard, pick contract signing, your regions, your signer types and your stack. The prompt gives your AI tool the rules for the acceptance block: the notice wording, the empty name field, the single Accept button.

   Prompt generator

   ```
   Use case    Contract signing
   Document    Proposal (type contract)
   Method      Typed name
   Assurance   L2, one-time code by email
   Signers     Business
   ```

2. **Lock the quote and register it as a version**

   When the proposal is ready to send, render it with its line items and totals to HTML and publish it as a version. If the client changes an option, publish a new version and have them accept that one: the record pins whichever version they signed.

   Server · publish the proposal

   ```
   POST /v1/documents/doc_Pr88/versions
   Idempotency-Key: proposal-2291-rev3

   {
     "version_label": "proposal-2291-rev3",
     "content": {
       "format": "html",
       "text": "<h1>Website redesign</h1><table>...$18,400...</table>"
     }
   }

   // 201 Created
   { "id": "dv_Lm02", "render_hash": "sha256:41ab..." }
   ```

3. **Create one session per signer**

   The person accepting on the client side gets one session on that version, and a countersigner on your side gets a second session on the same `version_id`, with your app tracking the order. Create each session when that person opens the proposal, because a session lasts 30 minutes by default and 24 hours at most.

   Server · when the client opens the proposal

   ```
   // One session per signer, pinned to the revision on screen.
   // esc is the server SDK: new EsignComply(process.env.ESIGNCOMPLY_API_KEY)
   const { data: session, error } = await esc.sessions.create(
     {
       profile: "prof_proposal_7b3d", // typed name, L2
       signer: {
         external_id: contact.id, email: contact.email, name: contact.name,
         class: "business", country: "US",
       },
       documents: [
         { document: proposal.documentId, version: proposal.versionId },
       ],
       context: {
         url: `${origin}/p/${proposal.token}`,
         locale: "en-US",
         purpose: "contract_signature",
       },
       metadata: { proposal_id: proposal.id },
     },
     { idempotencyKey: `accept-${proposal.id}-${contact.id}-${attempt}` },
   );
   // Send the browser only session.client_token, session.api_url
   // and session.documents.
   ```

4. **Email the client their proposal link**

   The link opens the proposal page in your app. Send it with your own cover note through a provider such as Resend, and schedule your follow-ups the same way.

   Server · send the proposal

   ```
   import { Resend } from "resend";

   const resend = new Resend(process.env.RESEND_API_KEY);
   const url = `https://yourapp.com/p/${proposal.token}`;

   await resend.emails.send({
     from: "Dana at Acme <dana@yourdomain.com>",
     to: contact.email,
     subject: `Proposal: ${proposal.title}`,
     html: `<p><a href="${url}">View the proposal</a></p>`,
   });
   ```

5. **Build the acceptance block with the browser SDK**

   Render the registered HTML unmodified on the proposal page, with your own styling around it. `@esigncomply/browser` attaches to the proposal, the name field and the Accept button, and reports the acceptance from the client's browser.

   Browser · app/p/\[token\]/accept.tsx

   ```tsx
   import { EsignComply } from "@esigncomply/browser";

   const ceremony = await EsignComply.attach({ clientToken, apiUrl });

   // The <article data-esc-document> that holds the registered proposal
   await ceremony.presentDocument({
     versionId,
     mode: "inline",
     container: proposalArticle,
   });

   // L2: Esign Comply emails the code to the contact on the session
   await ceremony.verify.start({ method: "email_otp" });
   await ceremony.verify.confirm({ code: codeInput.value });

   ceremony.observeAssent({
     region: acceptBlock,
     typedName: nameInput,
     submit: acceptButton,
   });

   // From the click handler of your Accept button
   const result = await ceremony.complete();
   // { recordId, receipt, verifyUrl, status }
   ```

6. **Confirm on your server before you mark it accepted**

   A deal moves to accepted only after your server has read `GET /v1/records/{id}` with the secret key, or handled the signed `record.completed` webhook, and matched the record to the revision you sent.

   Server · confirm the acceptance

   ```
   // Check the record names this contact and this exact revision.
   const { data: record, error } = await esc.records.get(recordId);

   const confirmed =
     !error &&
     ["recorded", "timestamped", "anchored"].includes(record.status) &&
     record.signer.external_id === contact.id &&
     record.documents.every((d) => d.version_id === proposal.versionId) &&
     record.livemode === (process.env.VERCEL_ENV === "production");

   if (confirmed) {
     await markAccepted(proposal.id, record.id, record.receipt);
   }
   ```

7. **Produce the accepted PDF and send copies**

   Render the accepted revision to a PDF with the client's typed name, the acceptance time and the verification link, then email it to both sides. With receipts on, Esign Comply also emails the client a copy and a verification link.

8. **Show deal status in your pipeline**

   Draft, sent, viewed, accepted, expired: keep these on your own proposal row. Viewed is your page load, accepted is a confirmed record, and expired is your own deadline.

9. **Keep our receipt and offer the evidence report**

   Store the signed receipt on the deal. When finance or the client asks what was agreed, download the evidence report: it names the proposal version by hash and lists every step of the acceptance.

   Server · evidence for one acceptance

   ```
   // Use a key with full_access or read_only permission
   GET /v1/records/rec_Pd31/report      // evidence report (PDF)
   GET /v1/records/rec_Pd31/evidence    // evidence package (ZIP)

   // Anyone checks the package offline
   npx esigncomply-verify rec_Pd31.zip
   ```

[Read the quickstart](https://esigncomply.com/docs/quickstart) · [Browser SDK reference](https://esigncomply.com/docs/sdk/browser)

For Cursor, Claude Code, Lovable

## A starter prompt to paste into your AI tool

Paste this first. It describes the proposal tool and points your AI tool at the docs. Then paste the generated prompt from the dashboard.

[Generate the full prompt](https://esigncomply.com/product/prompt-generator)

`starter-prompt.md`

```markdown
Build a PandaDoc-style proposal and quote tool in this codebase.

A user composes a proposal from sections and a pricing table: line items, quantities, discounts, optional add-ons and a total, computed by our code. They email the client a link (use Resend) to a proposal page in our app. There the client reviews it, confirms a one-time code sent to their email, types their name and clicks Accept. Then mark the deal accepted and email both sides the accepted proposal as a PDF. Statuses: draft, sent, viewed, accepted, expired.

Use Esign Comply for the signing ceremony and the record. First read and follow https://esigncomply.com/setup.md and https://esigncomply.com/llms.txt. Never invent API methods, endpoints or parameters: if the docs do not cover it, stop and ask me.

Before the client accepts, publish the final proposal, with the chosen line items and totals, as an Esign Comply document version and render that registered HTML unmodified. One session per signer. Mark a deal accepted only after our server has confirmed the record.

Next I will paste the prompt generated in the Esign Comply dashboard. It has the exact rules for the signing screen and overrides this message.
```

The record

## Why not build the record yourself

A proposal is a price and a promise, and the argument later is always about which version the client accepted. When the only copy of that answer sits in a table you can edit, you are asking the client to take your word for it. Esign Comply pins the acceptance to the exact proposal version by hash, receives the ceremony from the client's browser, and seals the record with keys you do not hold and an outside RFC 3161 timestamp. The evidence package verifies offline with an open-source tool, by anyone you give it to.

[Why the record should not be yours](https://esigncomply.com/why)

Annual, per domain

## Pricing in one line

The Free plan includes 10 live signatures a month and a full test mode, with no card. Starter is $200 per year for 2,000 live signature events, Unlimited is $1,200 per year, and Enterprise starts at $10,000 per year. One event is one signer's completed signing act: an accepted proposal is one event, and a countersignature is a second.

[See pricing](https://esigncomply.com/pricing)

## Questions about building your own PandaDoc

### Can I build a PandaDoc alternative with Lovable or Cursor?

Yes. The proposal editor, the pricing table, the share link and the acceptance page are ordinary product code that Lovable, Cursor, Claude Code, v0, Bolt or Replit can write. Esign Comply generates one prompt with the rules for the acceptance block and records each acceptance from the client's browser.

[Generate a prompt](https://esigncomply.com/product/prompt-generator)

### Does Esign Comply provide the pricing table?

The pricing table is your UI and your math: line items, options, discounts and totals all live in your app. Esign Comply comes in when the quote is final. You publish the rendered proposal as a document version, and the record of the acceptance pins those exact prices by hash.

### What happens when the client changes an option?

Publish a new version with the chosen line items and have the client accept that version. Versions are immutable, so every revision stays on file, and the record names the one that was accepted.

### Who sends the proposal emails?

You do, from your own domain, with a provider such as Resend: the cover email, the follow-ups and the accepted copy. Esign Comply sends the one-time code when you verify the client's email, and an optional receipt to the signer with a copy and a verification link.

### Is an acceptance made on my own proposal page recognized?

Yes. Electronic signatures are recognized under the U.S. ESIGN Act and state UETA laws: a signature cannot be denied legal effect just because it is electronic. Your acceptance block follows ceremony rules drawn from those laws and from leading U.S. online-assent decisions, and Esign Comply keeps an independent record pinned to the exact proposal version.

[U.S. rules we draw on](https://esigncomply.com/compliance/united-states)

### More build guides

- [Build your own DocuSign](https://esigncomply.com/build/docusign-alternative)
- [Build your own Dropbox Sign](https://esigncomply.com/build/dropbox-sign-alternative)
- [Build your own Adobe Acrobat Sign](https://esigncomply.com/build/adobe-sign-alternative)
- [Build your own signNow](https://esigncomply.com/build/signnow-alternative)
- [Build your own DocSend](https://esigncomply.com/build/docsend-alternative)
- [Build your own clickwrap](https://esigncomply.com/build/clickwrap)
- [All build guides](https://esigncomply.com/build)

### A copy-paste prompt for your AI tool

- [Cursor](https://esigncomply.com/build/cursor)
- [Claude Code](https://esigncomply.com/build/claude-code)
- [Codex](https://esigncomply.com/build/codex)
- [Windsurf](https://esigncomply.com/build/windsurf)
- [GitHub Copilot](https://esigncomply.com/build/github-copilot)
- [Devin](https://esigncomply.com/build/devin)
- [Lovable](https://esigncomply.com/build/lovable)
- [v0](https://esigncomply.com/build/v0)
- [Bolt](https://esigncomply.com/build/bolt)
- [Replit](https://esigncomply.com/build/replit)
- [ChatGPT](https://esigncomply.com/build/chatgpt)
- [Grok](https://esigncomply.com/build/grok)
- [Grokbot](https://esigncomply.com/build/grokbot)
- [Muse](https://esigncomply.com/build/muse)
- [All AI tools](https://esigncomply.com/build#tools)

## Build the proposal tool. Leave the record to us.

[Get started](https://esigncomply.com/signup) · [Documentation](https://esigncomply.com/docs)

Free plan: 10 live signatures a month and a full test mode. No card required.

PandaDoc is a trademark of its owner. Esign Comply is not affiliated with it.

---

Every page on esigncomply.com has a Markdown version at the same URL plus `.md` (the home page is `https://esigncomply.com/index.md`). https://esigncomply.com/llms.txt lists them.
