How to Automate NDA Signing: From Template to Signature in Under 60 Seconds

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  Deal Stage     │     │  CRM Webhook    │     │  Your Server    │
│  Change (CRM)   │────▶│  (HTTP POST)    │────▶│  (Node/Python)  │
└─────────────────┘     └─────────────────┘     └────────┬────────┘
                                                         │
                                              Template + Variables
                                                         │
                                                         ▼
┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  File to        │     │  Signed Webhook  │     │  Signbee API    │
│  S3 / GCS      │◀────│  (document.      │◀────│  POST /send     │
└─────────────────┘     │   completed)     │     └────────┬────────┘
                        └─────────────────┘              │
                                                         ▼
                                                ┌─────────────────┐
                                                │  Signer Email   │
                                                │  (signing link) │
                                                └─────────────────┘

# Mutual Non-Disclosure Agreement

**Effective Date:** {{effective_date}}

## Parties

**Disclosing Party:** {{company_a_name}}, a {{company_a_state}}
{{company_a_entity_type}}, with its principal office at
{{company_a_address}} ("Party A")

**Receiving Party:** {{company_b_name}}, a {{company_b_state}}
{{company_b_entity_type}}, with its principal office at
{{company_b_address}} ("Party B")

## 1. Definition of Confidential Information

"Confidential Information" means any non-public information
disclosed by either Party to the other, whether orally, in writing,
or by inspection, including but not limited to: technical data,
trade secrets, business plans, customer lists, financial data,
product roadmaps, source code, algorithms, and proprietary
processes.

## 2. Obligations of Receiving Party

Each Party agrees to:
(a) Hold Confidential Information in strict confidence
(b) Not disclose to any third party without prior written consent
(c) Use Confidential Information solely for {{purpose}}
(d) Protect with at least the same degree of care used for its
    own confidential information, but no less than reasonable care
(e) Limit access to employees and agents with a need to know

## 3. Exclusions

Confidential Information does not include information that:
(a) Is or becomes publicly available through no fault of Recipient
(b) Was rightfully known to Recipient prior to disclosure
(c) Is independently developed without reference to or use of
    the Confidential Information
(d) Is rightfully received from a third party without restriction
(e) Is required to be disclosed by law or court order, provided
    Recipient gives prompt written notice to Discloser

## 4. Term and Survival

This Agreement is effective for {{term_years}} year(s) from the
Effective Date. Confidentiality obligations survive for
{{survival_years}} year(s) after expiration or termination.

## 5. Return of Materials

Upon termination or written request, each Party shall promptly
return or destroy all Confidential Information and certify
destruction in writing.

## 6. Remedies

Each Party acknowledges that breach may cause irreparable harm
for which monetary damages are inadequate. The non-breaching
Party is entitled to seek injunctive relief in addition to
any other remedies available at law or in equity.

## 7. Governing Law

This Agreement shall be governed by the laws of
{{governing_law_jurisdiction}}, without regard to conflict
of law principles.

## 8. Entire Agreement

This Agreement constitutes the entire understanding between
the Parties regarding confidentiality and supersedes all prior
agreements, whether written or oral.

By signing below, each Party acknowledges that it has read,
understood, and agrees to be bound by the terms of this
Agreement.

import express from "express";
import fs from "fs/promises";
import crypto from "crypto";

const app = express();
app.use(express.json());

// Load template once at startup
const NDA_TEMPLATE = await fs.readFile("./nda-template.md", "utf-8");
const SIGNBEE_API_KEY = process.env.SIGNBEE_API_KEY;

function renderTemplate(template, variables) {
  return Object.entries(variables).reduce(
    (doc, [key, value]) => doc.replaceAll(`{{${key}}}`, value),
    template
  );
}

// CRM webhook endpoint — fires when deal reaches "NDA Required" stage
app.post("/webhooks/crm/deal-stage-change", async (req, res) => {
  const { deal, contact } = req.body;

  // Only trigger on the NDA stage
  if (deal.stage !== "nda_required") {
    return res.json({ skipped: true });
  }

  // Render the NDA with CRM data
  const nda = renderTemplate(NDA_TEMPLATE, {
    effective_date: new Date().toISOString().split("T")[0],
    company_a_name: "Your Company Inc",
    company_a_state: "Delaware",
    company_a_entity_type: "Corporation",
    company_a_address: "100 Main St, Wilmington, DE 19801",
    company_b_name: contact.company,
    company_b_state: contact.state || "N/A",
    company_b_entity_type: contact.entity_type || "Company",
    company_b_address: contact.address,
    purpose: deal.description || "Evaluating a potential business relationship",
    term_years: "2",
    survival_years: "3",
    governing_law_jurisdiction: "the State of Delaware",
  });

  // Send via Signbee API
  const response = await fetch("https://signb.ee/api/v1/send", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${SIGNBEE_API_KEY}`,
    },
    body: JSON.stringify({
      markdown: nda,
      recipient_name: contact.name,
      recipient_email: contact.email,
      title: `NDA — ${contact.company}`,
      expires_in_days: 7,
      metadata: {
        deal_id: deal.id,
        crm_source: "hubspot",
      },
    }),
  });

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

  console.log(`NDA dispatched: ${document_id} → ${contact.email}`);
  res.json({ document_id, signing_url });
});

// Signbee webhook — fires when signer completes the NDA
app.post("/webhooks/signbee/completed", async (req, res) => {
  const { event, document_id, signed_pdf_url, metadata } = req.body;

  if (event !== "document.completed") {
    return res.json({ ignored: true });
  }

  // Download the signed PDF
  const pdfResponse = await fetch(signed_pdf_url);
  const pdfBuffer = Buffer.from(await pdfResponse.arrayBuffer());

  // Upload to S3 (using AWS SDK v3)
  const { S3Client, PutObjectCommand } = await import("@aws-sdk/client-s3");
  const s3 = new S3Client({ region: "us-east-1" });

  const key = `signed-ndas/${metadata.deal_id}/${document_id}.pdf`;
  await s3.send(new PutObjectCommand({
    Bucket: process.env.S3_BUCKET,
    Key: key,
    Body: pdfBuffer,
    ContentType: "application/pdf",
    ServerSideEncryption: "AES256",
  }));

  console.log(`Signed NDA filed: s3://${process.env.S3_BUCKET}/${key}`);
  res.json({ filed: true, s3_key: key });
});

app.listen(3000, () => console.log("NDA automation server running on :3000"));

import os
import httpx
from datetime import date
from pathlib import Path
from fastapi import FastAPI, Request
from pydantic import BaseModel
from google.cloud import storage

app = FastAPI()

NDA_TEMPLATE = Path("nda-template.md").read_text()
SIGNBEE_API_KEY = os.environ["SIGNBEE_API_KEY"]
GCS_BUCKET = os.environ["GCS_BUCKET"]


class Contact(BaseModel):
    name: str
    email: str
    company: str
    address: str
    state: str = "N/A"
    entity_type: str = "Company"


class Deal(BaseModel):
    id: str
    stage: str
    description: str = "Evaluating a potential business relationship"


class CRMWebhook(BaseModel):
    deal: Deal
    contact: Contact


def render_template(template: str, variables: dict) -> str:
    result = template
    for key, value in variables.items():
        result = result.replace(f"{{{{{key}}}}}", value)
    return result


@app.post("/webhooks/crm/deal-stage-change")
async def handle_crm_webhook(payload: CRMWebhook):
    if payload.deal.stage != "nda_required":
        return {"skipped": True}

    nda = render_template(NDA_TEMPLATE, {
        "effective_date": date.today().isoformat(),
        "company_a_name": "Your Company Inc",
        "company_a_state": "Delaware",
        "company_a_entity_type": "Corporation",
        "company_a_address": "100 Main St, Wilmington, DE 19801",
        "company_b_name": payload.contact.company,
        "company_b_state": payload.contact.state,
        "company_b_entity_type": payload.contact.entity_type,
        "company_b_address": payload.contact.address,
        "purpose": payload.deal.description,
        "term_years": "2",
        "survival_years": "3",
        "governing_law_jurisdiction": "the State of Delaware",
    })

    async with httpx.AsyncClient() as client:
        response = await client.post(
            "https://signb.ee/api/v1/send",
            headers={
                "Content-Type": "application/json",
                "Authorization": f"Bearer {SIGNBEE_API_KEY}",
            },
            json={
                "markdown": nda,
                "recipient_name": payload.contact.name,
                "recipient_email": payload.contact.email,
                "title": f"NDA — {payload.contact.company}",
                "expires_in_days": 7,
                "metadata": {
                    "deal_id": payload.deal.id,
                    "crm_source": "hubspot",
                },
            },
        )

    data = response.json()
    return {"document_id": data["document_id"], "signing_url": data["signing_url"]}


@app.post("/webhooks/signbee/completed")
async def handle_signed_webhook(request: Request):
    body = await request.json()

    if body.get("event") != "document.completed":
        return {"ignored": True}

    document_id = body["document_id"]
    signed_pdf_url = body["signed_pdf_url"]
    deal_id = body.get("metadata", {}).get("deal_id", "unknown")

    # Download signed PDF
    async with httpx.AsyncClient() as client:
        pdf_response = await client.get(signed_pdf_url)

    # Upload to Google Cloud Storage
    gcs = storage.Client()
    bucket = gcs.bucket(GCS_BUCKET)
    blob_path = f"signed-ndas/{deal_id}/{document_id}.pdf"
    blob = bucket.blob(blob_path)
    blob.upload_from_string(pdf_response.content, content_type="application/pdf")

    return {"filed": True, "gcs_path": f"gs://{GCS_BUCKET}/{blob_path}"}