Salesforce · Document Generation

The deal runs in Salesforce. The paperwork should too.

PandaDoc generates proposals, quotes and contracts from Salesforce data, collects legally binding eSignatures, and writes status back to the record. Twopir Consulting implements it on your objects, configures it to your quote-to-cash process, and builds the Flow and Apex around it that the standard package does not cover. One record, one document, one signature — nothing re-keyed.

  • 6–8 wks typical engagement
  • Days → hours contract turnaround
  • 500+ clients served
Quote-to-Signature Flow
SALESFORCE RECORD Opportunity Stage · Amount · Terms · Close date Quote · Salesforce CPQ Products · Pricing · Discounts Account & Contacts Contact Roles Custom Objects PANDADOC DOCUMENT LAYER · CONFIGURED BY TWOPIR Template Tokens · Brand Content library Merge Pricing table Conditional content Approve Deal desk · Legal Routing rules eSign Audit trail Certificate ONE TEMPLATE PER DOCUMENT TYPE · NOTHING RE-KEYED 2πr BACK ON THE RECORD Status Synced Sent · Viewed · Completed, live Fields Written Back Signed values land on mapped fields Signed PDF Filed On the Opportunity, reportable PROPOSAL · QUOTE · CONTRACT · INVOICE
12+
Years of Salesforce & HubSpot delivery
500+
Clients served
250+
Deployments delivered
98%
Client retention

Trusted by 500+ organizations — including manufacturers, equipment operators and telecom infrastructure teams running field service on Salesforce with Twopir Consulting.

Ultra Consultant
Mitratech
LegalZoom
Spinify
Sotheby's International Realty
Ultra Consultant
Mitratech
LegalZoom
Spinify
Sotheby's International Realty

Built for Field Service Operations

  • Salesforce Partner
  • HubSpot Partner
  • PandaDoc for Salesforce
  • Sales Operations
  • RevOps & Deal Desk
  • Contracts & Legal
  • Finance & Billing
  • CPQ Admins
Where Deals Stall

Where quote-to-signature breaks inside a sales org

The deal is structured in Salesforce, then the document leaves it — into Word, into email, into a separate signing portal — and every step outside the record adds time, error and blind spots. These are the six failures we see most.

Proposals built from scratch every time

Reps copy Salesforce data into Word or Google Docs by hand, spending 30–45 minutes per document. Every manual copy is a fresh chance for a pricing error.

Data re-keyed by hand

Billing addresses, line items and tax rates get typed again for every quote — a high-risk, low-value task duplicated across every single deal.

Branding drifts rep to rep

Every rep's document looks a little different — fonts, layouts, logo placement. That inconsistency erodes buyer confidence exactly when the signature is on the table.

Signature sits outside the deal

Customers bounce between an email attachment and a separate eSignature portal. Each extra step is a day added to the close cycle.

No visibility after send

Once a proposal is emailed it disappears. Reps have no idea whether it was opened, reviewed or ignored until they chase the customer by hand.

Contracts take days, not hours

Approvals and legal review run through email threads with no routing rules and no audit trail. A contract that could go out the same day waits two or three.

Platform Context

Salesforce runs the deal. PandaDoc runs the paperwork.

PandaDoc is a document automation and eSignature platform. Its Salesforce application, PandaDoc for Salesforce, generates documents from Opportunity, Account, Contact, Lead, Quote and custom-object data, collects legally binding electronic signatures, and writes document status and mapped field values back to the Salesforce record. Documents are built from templates that carry Salesforce tokens, pricing tables and conditional content, so one template serves every deal type, region or product bundle.

It is built for teams that send proposals, quotes, contracts and renewals out of Salesforce at volume — sales operations, RevOps and deal desk, contracts and legal, finance and billing, and the CPQ admins who own pricing. PandaDoc's own Salesforce installation and configuration documentation describes the package; what follows is what that package does inside your org, and where Twopir Consulting takes it further.

What PandaDoc does

The document engine

Templates, tokens, pricing tables, conditional content, a content library, approval routing, eSignature with audit trail and certificate, and status sync to Salesforce. This is the vendor's product, installed from the AppExchange.

What Twopir does

The fit to your org

Object and field mapping, template and clause-library build, CPQ and approval design, Flow automation, status write-back, the custom development the package does not cover, and the handover that leaves your admins in control.

What you get

Documents on the record

A branded, data-accurate document from a click on the Opportunity, signed without leaving the deal, with Sent, Viewed and Completed visible in Salesforce and the signed PDF filed where reporting can reach it.

Three Services, Three Buyers

Implement it. Configure it. Build on it.

"We work with PandaDoc" hides three different engagements. Twopir Consulting offers all three, and we tell you up front which one your scope actually needs — and where configuration stops and custom development begins.

Implement PandaDoc

Stand the package up correctly inside Salesforce — the part most teams rush and then live with.

  • AppExchange package install and connected-app setup
  • Lightning record pages with the PandaDoc component
  • Object enablement: Opportunity, Account, Contact, Lead, Quote, custom objects
  • User provisioning, permission sets, remote-site settings
  • Migration of existing branding, clause libraries and templates

Configure It to Your Process

Tailor templates, rules and routing to how your deals actually move — no code, but plenty of judgement.

  • Token and field mapping, including custom fields
  • Pricing tables fed from Products, Quote lines or CPQ
  • Conditional sections by deal type, region or bundle
  • Approval routing for deal desk and legal review
  • Status and field write-back to the record on Sent and Completed

Build on It

Custom development where the standard package ends — Salesforce Flow, Apex and the PandaDoc API.

  • Auto-create and send on stage change with Flow actions
  • Multi-record and related-list merges via custom JSON builders
  • Documents from objects with no standard relationship
  • Post-signature hand-off to billing and ERP through Salesforce
  • Custom Lightning components and guided quoting screens

Where configuration ends and custom development begins

The most useful line we draw on a discovery call. Everything in the first tier is standard PandaDoc for Salesforce capability that we set up; everything in the second needs code or the API, and we scope it as such.

RequirementHow it is deliveredTier
Pull standard and custom fields into a documentToken mapping in the PandaDoc template and Salesforce settingsConfiguration
Pricing table from Opportunity Products, Quote lines or Salesforce CPQProduct and pricing-table mapping; the CPQ integration for Quote objectsConfiguration
Show or hide sections by deal type, region or bundleConditional content rules on the templateConfiguration
Write signed values and status back to the recordTwo-way sync field mapping, exported on Sent and Completed (needs Salesforce API access)Configuration
Create and send a document automatically on stage changePandaDoc actions inside Salesforce Flow BuilderLow-code · Flow
Merge data from several related records into one documentCustom JSON builder in Apex against the PandaDoc integrationCustom development
Generate from an object the package has no relationship toApex or PandaDoc API call with a custom triggerCustom development
Create an invoice or ERP record when a contract completesFlow or Apex on the Completed status, integrated to Accounting Seed, QuickBooks or your ERPCustom development
What We Deliver

What PandaDoc puts inside your Salesforce org

Six things a finished implementation leaves behind. Each one is native PandaDoc capability; each one only works when it is mapped to your data model and your approval chain.

Template & Content Library

A governed set of templates per document type — proposal, quote, MSA, order form, renewal — with a shared clause library so every rep sends the approved version.

CRM Field Mapping

Opportunity, Account, Contact, Lead, Quote and custom-object fields populate document tokens automatically — including recipients pulled from contact roles.

Conditional Logic & Pricing Tables

Sections show or hide by deal type, product mix or region, and pricing tables fill from Products, Quote lines or Salesforce CPQ — one template, every scenario.

eSignature & Approvals

Documents route through deal desk and legal before they leave, then collect signatures with an audit trail and certificate — no hand-off to a second tool.

Status Sync & Reporting

Sent, Viewed, Signed and Completed land on the Salesforce record as they happen, so pipeline reports and dashboards show where every document actually is.

CPQ Quote-to-Document

Quotes built in Salesforce CPQ push into a branded, signature-ready document with live pricing, and quote status stays in step with the document.

Integration Architecture

What moves between Salesforce and PandaDoc, and in which direction

Salesforce stays the system of record. PandaDoc is the document layer that reads from it and writes back to it. Everything downstream — billing, ERP, HubSpot — hangs off the record, not off the document.

Salesforce → PandaDoc

Record fields, Opportunity Products or Quote lines, and recipients from contact roles flow into template tokens, pricing tables and signer slots when a rep clicks Create Document.

PandaDoc → Salesforce

Document status — Sent, Viewed, Completed — the signed PDF, and any mapped field values export back to the record on Sent and Completed, so reporting never depends on a rep updating a stage.

Salesforce CPQ ↔ PandaDoc

Quote lines and pricing push into the document; document status updates the Quote, and Quote status updates the Opportunity. Finance and deal desk read one price, never a re-typed one.

Salesforce Flow → PandaDoc

Flow Builder actions create and send documents when a stage changes and update Opportunity fields afterwards — the no-code automation layer Twopir designs around your sales process.

Integration matrix · what each flow carries and who consumes it
FlowWhat movesBusiness purposeWho consumes it
Salesforce → PandaDocField values, products and pricing, recipientsDocuments generate from CRM data; nothing is re-keyedSales reps, proposal managers
PandaDoc → SalesforceStatus, signed PDF, mapped field valuesThe record shows the truth about every documentSales managers, RevOps, finance
Salesforce CPQ ↔ PandaDocQuote lines, quote and document statusLive pricing on the document; no price drift between systemsDeal desk, CPQ admins
Salesforce → billing / ERPCompleted-contract trigger, signed terms, amountsInvoice or subscription created from the signed documentFinance and billing
Salesforce ↔ HubSpotDeal, contact and company dataMarketing and sales stay in sync when both platforms are in playMarketing operations, RevOps

The first four flows are what a PandaDoc implementation on Salesforce delivers. The billing hand-off is custom work we build on top, using the same patterns as our Accounting Seed integrations. If your CRM is HubSpot rather than Salesforce, start with the PandaDoc for HubSpot implementation guide instead.

Delivery Model

Four phases, six to eight weeks

Most PandaDoc for Salesforce engagements run six to eight weeks end to end. The range depends on how many document types and approval paths need mapping, not on the software — and we say which end of it you are on before we start.

Phase 01

Discovery & Field Mapping

We audit the full document workflow — every field, approval step and downstream system a document touches — and map each one to a Salesforce source. This is also where implement, configure or build-on gets decided.

Phase 02

Template & Logic Build

We build dynamic PandaDoc templates with mapped tokens, conditional content, pricing tables and brand rules, migrating your existing clause libraries so nothing is rebuilt from scratch.

Phase 03

Integration & eSignature

We connect PandaDoc to Opportunities, Quotes and Salesforce CPQ, activate eSignature and approval routing, configure status and field write-back, and build any Flow or Apex the scope calls for.

Phase 04

Centralization & Handover

Salesforce becomes the single source of truth for every document. Structured sessions leave reps generating documents and admins managing templates and reading the reporting on their own.

Proof

Where PandaDoc on Salesforce has already paid off

One engagement where the document layer was part of a larger Salesforce rebuild, and the four scenarios where we see the product deliver most.

Case Study · Real Estate

Luxury Real Estate Conglomerate — UAE, 250+ Agents

Salesforce was in place, but contracts took days and every document was typed by hand. Property contracts, offer letters and KYC onboarding forms now generate from the Opportunity through Nintex and PandaDoc, go straight to the client for eSignature, and write status back to Salesforce in real time.

Days → hrs Contract turnaround
Near zero Document errors, data from CRM
250+ Agents on one workflow
  • Nintex and PandaDoc document automation on Salesforce Opportunities
  • Client eSignature sent from the record, status written back in real time
  • One of seven modules, alongside HubSpot–Salesforce sync, lead routing, AML compliance and commission automation
Read the Case Study

Sales proposals at volume

Teams generating 100+ proposals a month need every quote pulling live pricing, discounts and terms without a rep touching a spreadsheet. We build the template logic so volume stops being the bottleneck.

Contract & legal turnaround

Legal teams need conditional clauses, approval routing and a clean audit trail before a contract reaches a signature block. We configure the approval chain to match how your legal team actually reviews.

CPQ-to-invoice hand-off

Sales ops teams running Salesforce CPQ need quotes and invoices generated and signed without leaving the Opportunity. We connect CPQ output directly into PandaDoc so pricing is never re-keyed.

HR & onboarding documents

People teams need offer letters, NDAs and onboarding packets generated and signed at the same speed as a sales contract. We extend the same template and eSignature pattern beyond the sales org.

More document and signature work on Salesforce: Salesforce for real estate, Salesforce for law firms, Salesforce for SaaS, and the full success stories library.

Why Twopir

Not a reseller. An architectural partner.

PandaDoc is one layer of a quote-to-cash system. We implement it as part of that system — on a Salesforce org we understand end to end — which is what keeps the documents accurate after go-live.

We map your document, not PandaDoc's demo

Every template is built against your actual field structure, approval chain and deal types — not a generic sample that looks right until the first real quote.

We build the sync, not just the send

Status and field write-back to Salesforce is standard in every engagement, not an add-on. If reporting cannot see the document, the implementation is not finished.

We have done this on CPQ, not just Opportunities

Quote-to-document automation across Salesforce CPQ is a repeatable pattern for us — and so are Conga, DocuSign and Nintex when they sit alongside PandaDoc in the same org.

We tell you where configuration ends

You get a scoped line between standard capability and custom development before the engagement starts, so the build-on work is a decision, not a surprise invoice.

We hand over admin control, not a black box

Your team leaves able to edit templates, adjust routing and read the reporting themselves — with Salesforce support available when the scope grows.

Common Questions

Questions RevOps teams ask before we start

Most engagements run six to eight weeks across four phases — discovery and field mapping, template and logic build, integration and eSignature, then centralization and handover. The variable is how many document types and approval paths need mapping; a single proposal template on Opportunities sits at the short end, while multiple document types across CPQ and legal review sit at the long end.

Yes. PandaDoc for Salesforce creates documents from Salesforce CPQ Quote records, either as a generated PDF or as an editable document whose pricing table is filled from the quote lines, and it keeps quote status and document status in step. We connect it so quotes generate with live pricing and push straight into a signature-ready document without manual re-entry. PandaDoc also sells its own CPQ for Salesforce as a paid add-on for teams that do not run Salesforce CPQ; we scope that separately.

The Salesforce package runs on Professional, Enterprise, Unlimited and Developer editions, and the integration is available on PandaDoc's Business and Enterprise annual plans. The part that catches teams out is two-way sync: writing status and field values back to Salesforce needs API access, which means Enterprise edition or Professional with the API add-on. On Professional without API access you can still generate documents from Salesforce, but nothing syncs back. We confirm both edition and plan in discovery so the write-back you are counting on is actually available.

Configuration covers everything the standard package supports through settings: token and field mapping, pricing tables from Products, Quote lines or CPQ, conditional content, approval routing, and status and field write-back. Automating creation and sending on a stage change is low-code work in Salesforce Flow Builder using PandaDoc's actions. Custom development starts when a document needs data from several related records merged through a custom JSON builder, when it must generate from an object the package has no relationship to, or when a completed contract has to create an invoice or ERP record. We put every requirement on one side of that line during discovery.

Yes. PandaDoc's electronic signatures are built to comply with the US ESIGN Act and UETA and with the EU's eIDAS regulation, and every completed document carries a digital certificate and an audit trail recording signer identity, timestamps and IP address. That is what makes the signature enforceable; what we add is the routing and record-keeping in Salesforce so the signed document and its evidence are filed against the deal, not in someone's inbox.

Yes, with the right plan and configuration. PandaDoc holds SOC 2 Type II certification, supports GDPR requirements, and offers HIPAA-compliant features with a Business Associate Agreement for eligible enterprise customers. Compliance is then a matter of implementation: which fields are allowed into a template, who can approve and send, how signed documents are stored, and what Salesforce sharing rules govern access. We configure those controls to match your compliance requirements rather than the platform defaults.

It depends on what is already in the org and what the document has to do. PandaDoc combines generation, approval, eSignature and status sync in one package, which suits sales teams that want the whole quote-to-signature loop in a single tool. Conga Composer is the stronger choice when documents are complex, heavily formatted merges across many related objects, and it pairs with a separate signature tool. DocuSign is a signature and agreement platform first, and the right answer when generation already exists and only the signing step needs fixing. We implement all three, so the recommendation follows your document mix, not our preference — see our Conga Composer and DocuSign pages for how each is delivered.

Next Step

Ready to generate every proposal from a single Salesforce click?

We will map your document workflow, show you exactly what is slowing the close cycle down, and tell you which of implement, configure or build-on your scope actually needs.

We work across US EST, UK GMT and AEST time zones · response within 24 hours