Skip to content
Build guide · proposals and quotes

Build your own PandaDoc alternative

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.

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

The flow, and who does each part
  1. 01
    Compose the proposal and its pricing tableYou
  2. 02
    Email the client a link to the proposal pageYou
  3. 03
    Client reviews, types a name, clicks AcceptYou
  4. 04
    Acceptance reported from the client's browserEsign Comply
  5. 05
    Sealed record pinned to the exact quoteEsign Comply
  6. 06
    Accepted PDF to both sides, deal marked wonYou

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.

01

Proposal builder

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

02

Pricing tables

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

03

Optional line items

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

04

A proposal page per client

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

05

Accept and sign

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

06

View tracking

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

07

Templates and a content library

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

08

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. 01

    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. 02

    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. 03

    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. 04

    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. 05

    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
    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. 06

    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. 07

    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. 08

    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. 09

    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
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
starter-prompt.md
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
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

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

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

Build the proposal tool. Leave the record to us.

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.

Working with an AI tool? This page is also available as Markdown: /build/pandadoc-alternative.md