How to Add E-Signatures to Your SaaS Product (Without Building a Template Engine)

The template engine trap

I've talked to dozens of SaaS founders who spent 2-6 months building document signing features. The pattern is always the same:

This is the template engine trap. You set out to add a simple "sign this document" button, and you end up maintaining a document management system that has nothing to do with your core product.

The escape is straightforward: generate documents programmatically from data you already have, and let a signing API handle everything else.

The API-first approach

Your SaaS product already stores the data that goes into documents. A CRM has client names and deal values. An HR tool has employee details and salary figures. A property management app has tenant names and lease terms. You don't need a template editor — you need string interpolation.

// Your app already has this data
const deal = await db.deals.findUnique({
  where: { id: dealId },
  include: { client: true, company: true },
});

// Generate the contract as markdown
const markdown = `# Service Agreement

**Provider:** ${deal.company.name}
**Client:** ${deal.client.name}
**Value:** $${deal.value.toLocaleString()}/month
**Start Date:** ${deal.startDate.toLocaleDateString()}

## Scope of Work
${deal.scope}

## Payment Terms
Payment is due within 30 days of invoice date.
Late payments incur a 1.5% monthly fee.

## Term
This agreement runs for ${deal.termMonths} months
from the start date above.
`;

// Send for signature — one API call
const response = await fetch("https://signb.ee/api/v1/send", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": `Bearer ${process.env.SIGNBEE_API_KEY}`,
  },
  body: JSON.stringify({
    markdown,
    recipient_name: deal.client.name,
    recipient_email: deal.client.email,
    webhook_url: "https://yourapp.com/webhooks/signbee",
  }),
});

const { document_id, signing_url } = await response.json();

// Save the document reference and redirect
await db.deals.update({
  where: { id: dealId },
  data: { documentId: document_id, status: "awaiting_signature" },
});

// Option A: Redirect user to signing page
// Option B: Embed signing_url in an iframe
// Option C: Send via email (Signbee does this automatically)

No template engine. No PDF library. No drag-and-drop editor. The markdown is generated from your existing data models, and Signbee handles everything from PDF rendering to email delivery to signature capture and audit trail generation.

Three embedding strategies

Once you have a signing_url from the API, there are three ways to present it to your user:

For most SaaS products, the redirect strategy is the sweet spot. The signer clicks "Sign Agreement" in your app, gets redirected to the signing page, signs, and gets redirected back. Signbee supports a redirect_url parameter that sends the signer back to your app after signing:

const response = await fetch("https://signb.ee/api/v1/send", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": `Bearer ${process.env.SIGNBEE_API_KEY}`,
  },
  body: JSON.stringify({
    markdown: contractMarkdown,
    recipient_name: "Jane Smith",
    recipient_email: "jane@client.com",
    redirect_url: "https://yourapp.com/deals/123/signed",
    webhook_url: "https://yourapp.com/webhooks/signbee",
  }),
});

const { signing_url } = await response.json();
// Redirect the user: window.location.href = signing_url
// After signing, they land on /deals/123/signed in your app

White-label vs API-first: which approach?

SaaS builders often debate between white-label e-signature providers (where you rebrand their UI) and API-first providers (where you control the flow). Here's how they compare:

Signbee bridges both approaches. The signing page is clean and minimal — it doesn't look like "Signbee" is signing your documents. But you also get full API control to build custom signing flows if you need them. No monthly fees, no user seats, just $0.50 per document. For a deeper comparison of providers, see our best e-signature APIs for developers guide.

Handling the webhook lifecycle

The signing URL is only half the integration. You also need to update your SaaS product when the document is signed, viewed, or declined. Here's the webhook handler pattern:

app.post("/webhooks/signbee", async (req, res) => {
  const { event, data } = req.body;

  switch (event) {
    case "document.signed":
      await db.deals.update({
        where: { documentId: data.document_id },
        data: {
          status: "signed",
          signedAt: new Date(data.timestamp),
          signedPdfUrl: data.signed_pdf_url,
        },
      });
      // Trigger onboarding, activate subscription, etc.
      await activateClientAccount(data.document_id);
      break;

    case "document.viewed":
      await db.deals.update({
        where: { documentId: data.document_id },
        data: { status: "viewed", viewedAt: new Date(data.timestamp) },
      });
      break;

    case "document.declined":
      await db.deals.update({
        where: { documentId: data.document_id },
        data: { status: "declined" },
      });
      // Notify the account owner
      await notifyDealOwner(data.document_id, "declined");
      break;
  }

  res.sendStatus(200);
});

This is where the real value lives for SaaS builders. The webhook lets you trigger downstream workflows — activating accounts, starting subscriptions, sending welcome emails, updating CRM stages — all automatically when a document is signed. For implementation details, see the webhooks guide.

Cost comparison for SaaS builders

E-signature pricing matters at scale. If your SaaS sends 500 documents per month, here's what you're looking at:

For a detailed pricing breakdown across all providers and volume tiers, see the full pricing comparison.

What about self-hosted options?

Docuseal is a popular open-source option. You host it on your own infrastructure and avoid per-document fees. But the trade-off is real: you're running a Ruby on Rails app, managing a PostgreSQL database, handling backups, monitoring uptime, and maintaining security patches. For SaaS builders who want to focus on their core product, the operational overhead usually outweighs the cost savings.

The break-even point depends on your volume. Below 1,000 documents per month, a managed API like Signbee is cheaper when you factor in engineering time. Above 5,000 per month, self-hosting might make sense if you have a dedicated DevOps team. For most SaaS products in the 100-2,000 doc/month range, API-first is the clear winner.

Integration checklist for SaaS builders

Frequently Asked Questions

Last updated: May 12, 2026 · Michael Beckett is the founder of Signbee and B2bee Ltd.