By James Aspinwall
You’ve closed the verbal agreement. The client said yes. Now you need to get it in writing, signed, and filed — without losing momentum to a week of back-and-forth PDFs, “which version is the latest?” emails, and a printer that jams at the worst possible moment.
PandaDoc handles the entire document lifecycle: create a proposal or contract from a template, fill in the details, send it for signature, track when it’s opened, and download the signed PDF. The client never prints anything. You never chase a fax.
What PandaDoc Does
PandaDoc is a document automation and e-signature platform. Three capabilities, tightly integrated:
Document creation — build proposals, contracts, SOWs, NDAs, and quotes using templates with dynamic fields. Drag-and-drop editor, pricing tables that calculate automatically, content blocks you can reuse across documents.
E-signatures — legally binding electronic signatures compliant with ESIGN and eIDAS. Recipients sign in the browser. No account required on their end.
Tracking — real-time visibility into document status. Know exactly when someone opens your proposal, how long they spend on each page, and when they sign.
Templates: Build Once, Use Forever
Templates are the foundation. Every document you send repeatedly should be a template.
What Makes a Good Template
A proposal template for a consulting engagement might contain:
- Cover page — your logo, the client’s name (dynamic field), date
- Executive summary — a content block you customize per deal
- Scope of work — reusable sections you toggle on or off
- Pricing table — line items with quantities, rates, and auto-calculated totals
- Terms and conditions — standard legal language, rarely changed
- Signature block — fields for both parties to sign and date
The key is separating what changes from what doesn’t. Terms and conditions are the same every time — lock them in the template. The scope section varies per client — make it a content block you edit. The pricing table uses your standard rates — override only when needed.
Template Variables
Variables pull data into documents automatically. Wrap a field name in brackets and PandaDoc replaces it when you create the document.
Common variables:
-
{Client.Company}— organization name -
{Client.FirstName}— contact’s first name -
{Client.Email}— contact’s email -
{Deal.Value}— total deal amount -
{Document.Date}— creation date -
{Sender.Company}— your company name
When you create a document from a template and link it to a CRM deal, these fields populate from the CRM data. No copy-paste, no typos.
Content Library
For sections you reuse across different templates — case studies, team bios, service descriptions, legal clauses — use the Content Library. Create a block once, store it centrally, and insert it into any document. Update the library block and every future document gets the updated version.
This is how you maintain consistency across a team. Three consultants sending proposals use the same service descriptions, the same terms, the same formatting. The Content Library is the single source of truth.
Creating a Document
From a Template
The typical flow:
- Select a template. Proposal, SOW, NDA, or whatever fits the situation.
- Fill in variables. Client name, project name, dates. If linked to a CRM, most of this is pre-filled.
- Customize the content. Edit the executive summary, toggle scope sections, adjust the pricing table.
- Add recipients. Who needs to sign, who needs to approve, who gets a CC.
- Review. Preview exactly what the recipient will see.
- Send. One click. PandaDoc emails the recipient a link to view and sign.
The whole process takes five minutes for a standard proposal. For a complex SOW, maybe fifteen. Compare that to starting from a Word doc every time.
Pricing Tables
Pricing tables are PandaDoc’s quiet superpower. They’re not static text — they’re live spreadsheets embedded in your document.
A pricing table for a consulting engagement:
| Item | Description | Qty | Rate | Total |
|---|---|---|---|---|
| Discovery Workshop | Two-day on-site assessment | 1 | $5,000 | $5,000 |
| Strategy Development | Architecture and roadmap | 1 | $15,000 | $15,000 |
| Implementation | Monthly engineering support | 3 | $25,000 | $75,000 |
| Subtotal | $95,000 | |||
| Discount (5%) | -$4,750 | |||
| Total | $90,250 |
Change a quantity or rate and the totals recalculate. Add a discount row and it applies automatically. The client sees a clean pricing table, not a formula-ridden spreadsheet.
You can also create optional line items — items the client can select or deselect before signing. “Add-on: 24/7 support — $5,000/month” as an optional row lets the client self-configure their package without a new document.
From Scratch
Sometimes you need a one-off document that doesn’t fit a template. PandaDoc’s editor works like a simplified word processor. Drag content blocks onto the page: text, image, pricing table, signature field, date field, checkbox. No design skills needed — the formatting handles itself.
Use this for custom letters, one-time agreements, or documents where the structure is unique. But if you find yourself building the same structure twice, make it a template.
Recipients and Signing Order
Roles
Every recipient has a role:
- Signer — must sign the document before it’s complete
- Approver — must approve before signers can sign (internal review)
- CC — receives a copy but takes no action
Signing Order
For a standard contract: you sign first (as the sender), then the client signs. PandaDoc enforces the order — the client can’t sign until you have.
For more complex scenarios: the client’s project lead signs, then their VP approves, then their legal team signs. Set the order and PandaDoc handles the sequencing. Each recipient gets notified only when it’s their turn.
What Recipients Experience
The recipient gets an email with a “Review Document” button. They click it, the document opens in their browser. No account creation, no app download. They scroll through, click on signature fields, type or draw their signature, and hit complete.
From the recipient’s perspective, the entire signing experience takes under two minutes. The less friction you put between “yes” and “signed,” the faster deals close.
Tracking: Know Exactly Where Things Stand
This is where PandaDoc earns its keep. Every document has a status trail:
| Status | What Happened |
|---|---|
| Draft | Created, still being edited |
| Sent | Delivered to recipients |
| Viewed | Recipient opened the document |
| Completed | All signatures collected |
| Expired | Signing deadline passed without completion |
| Declined | Recipient explicitly rejected |
The “Viewed” Signal
When a recipient opens your proposal, you know. PandaDoc tells you:
- When they opened it
- How many times they’ve viewed it
- How long they spent on each page (in the analytics)
This changes how you follow up. If someone opened the proposal three times but hasn’t signed, they’re interested but hesitant. Call them and ask if they have questions. If someone hasn’t opened it after three days, your email might have gone to spam or they’re busy — a gentle nudge is appropriate.
Without this visibility, you’re guessing. With it, every follow-up is informed.
Notifications
PandaDoc sends you real-time notifications:
- Document viewed
- Document completed
- Document expired
- Document declined
Set these up as push notifications or email. The moment a contract is signed, you know — and you can immediately trigger the next step (project kickoff, invoicing, team notification).
The Document Lifecycle for Consultants
Here’s how the pieces fit together for a typical consulting engagement.
Phase 1: NDA
Before sharing proprietary information in a proposal, send an NDA.
- Create from your NDA template
- Fill in the client’s legal entity name and date
- Send for mutual signature
- Takes five minutes to create, usually signed within 24 hours
Phase 2: Proposal
Once the NDA is signed, send the proposal.
- Create from your proposal template
- Customize the executive summary for this client’s specific situation
- Build the pricing table with the services discussed
- Include optional add-ons if relevant
- Send to the decision-maker, CC the project contact
The proposal is your sales document — it should answer “why us” and “what exactly will we do.” Keep it focused. Ten pages maximum. If the scope needs more detail, that goes in the SOW.
Phase 3: SOW or Contract
Once the proposal is accepted (verbally or by signing), formalize with a Statement of Work or Master Services Agreement.
- Create from your SOW/MSA template
- Reference the proposal for scope and pricing
- Add detailed deliverables, milestones, payment schedule, and acceptance criteria
- Include legal terms: liability, IP ownership, termination, confidentiality
- Set signing order: you first, then client
This is the binding document. It should be precise enough that both sides know exactly what’s being delivered, when, and for how much.
Phase 4: Change Orders
Scope changes mid-project. It happens. Don’t renegotiate the whole contract — send a change order.
- Create from your change order template
- Reference the original SOW
- Describe the scope change, revised timeline, and cost impact
- Send for signature
Change orders protect both sides. The client knows exactly what the additional cost is. You have documentation that the scope changed.
Folders and Organization
As your document volume grows, organization matters.
PandaDoc folders work like file system folders. A practical structure:
Proposals/
2026/
Q1/
Q2/
Contracts/
Active/
Completed/
Expired/
NDAs/
Templates/
Change Orders/
Name documents consistently: {Client} — {Type} — {Date}. “Acme Corp — SOW — 2026-02-17” is findable. “Document (3) final FINAL v2” is not.
Sandbox vs Production
PandaDoc offers a free sandbox for development and testing. Documents created in sandbox have a [DEV] watermark and are not legally binding. Use sandbox to:
- Build and test templates
- Test your CRM integration
- Train new team members
- Demo the signing experience to stakeholders
When you’re ready for production, switch to a paid plan. Templates and content library items carry over. The transition is straightforward.
What PandaDoc Doesn’t Do
Negotiation. PandaDoc tracks whether a document is signed, not the back-and-forth of negotiation. If a client wants to redline your contract, they’ll do it in Word or by email. You incorporate their changes, create a new version in PandaDoc, and resend.
Version comparison. PandaDoc tracks document status, not a diff between versions. If you need to compare what changed between v1 and v2 of a contract, use a separate tool. PandaDoc just knows “this is the current version.”
Complex approval workflows. PandaDoc supports sequential signing and basic approval roles, but it’s not a full workflow engine. If you need seven-level approval chains with conditional routing, you’ve outgrown PandaDoc’s native capabilities.
Long-term storage. PandaDoc stores your documents, but it’s not a document management system. Download signed PDFs and archive them in your file system or cloud storage for long-term retention.
The Habits That Make It Work
Template everything. If you’ve sent it twice, make it a template. The upfront investment of thirty minutes saves hours over the life of the template.
Send the same day. When a client says yes, send the contract that afternoon. Every day between verbal agreement and signature is a day the deal can slip. PandaDoc makes same-day turnaround possible — use that speed.
Follow the “Viewed” signal. Don’t wait a week to follow up. When you see they’ve viewed the document, follow up within 24 hours while it’s fresh in their mind.
Close the loop. When a document is signed, trigger the next step immediately. Don’t let a signed contract sit for three days before someone starts the project. The speed from signature to kickoff sets the tone for the entire engagement.
PandaDoc removes the mechanical friction from contracts and proposals. What’s left is the part that actually matters — writing a compelling proposal and closing the deal.