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.
- 01Compose the proposal and its pricing tableYou
- 02Email the client a link to the proposal pageYou
- 03Client reviews, types a name, clicks AcceptYou
- 04Acceptance reported from the client's browserEsign Comply
- 05Sealed record pinned to the exact quoteEsign Comply
- 06Accepted 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.
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.
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
The editor, the content blocks and the template library.
Registers the final proposal as an immutable document version.
Pricing table
Line items, options, discounts, tax and totals. Your UI and your math.
The accepted prices sit inside the registered version, so the record names the exact quote by hash.
Share link and emails
The proposal link, the cover email and the follow-ups, sent with a provider such as Resend.
The one-time code email at L2, sent and confirmed by Esign Comply.
Acceptance and signature
The acceptance block on your page: notice text, name field, Accept button.
The rules prompt for that block, and the browser SDK that reports the acceptance from the client's browser.
Deal status
Draft, sent, viewed, accepted and expired in your own pipeline.
GET /v1 and the signed record.completed webhook, so accepted means confirmed.
The accepted copy
The PDF of the accepted proposal and the emails that deliver it.
An evidence report for the acceptance, a public verification page and an optional emailed copy to the signer.
The record
Our receipt, stored on the deal.
The sealed record, a signed receipt (ES256), an RFC 3161 timestamp and a hash-chained ledger.
How to build your PandaDoc alternative, step by step
Nine steps from a draft quote to an accepted proposal with a record behind it.
- 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 generatorUse case Contract signing Document Proposal (type contract) Method Typed name Assurance L2, one-time code by email Signers Business
- 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 proposalPOST /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..." }
- 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.
- 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 proposalimport { 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>`, });
- 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/browserattaches to the proposal, the name field and the Accept button, and reports the acceptance from the client's browser.Browser · app/p/[token]/accept.tsximport { 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 }
- 06
Confirm on your server before you mark it accepted
A deal moves to accepted only after your server has read
GET /v1with the secret key, or handled the signed/records /{id} record.completedwebhook, 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); }
- 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.
- 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.
- 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
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 promptBuild 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.
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 yoursPricing 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 pricingQuestions 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 promptDoes 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 onBuild 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.