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.
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.
Trusted by 500+ organizations — including manufacturers, equipment operators and telecom infrastructure teams running field service on Salesforce with Twopir Consulting.








Built for Field Service Operations
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.
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.
Billing addresses, line items and tax rates get typed again for every quote — a high-risk, low-value task duplicated across every single deal.
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.
Customers bounce between an email attachment and a separate eSignature portal. Each extra step is a day added to the close cycle.
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.
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.
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.
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.
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.
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.
"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.
Stand the package up correctly inside Salesforce — the part most teams rush and then live with.
Tailor templates, rules and routing to how your deals actually move — no code, but plenty of judgement.
Custom development where the standard package ends — Salesforce Flow, Apex and the PandaDoc API.
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.
| Requirement | How it is delivered | Tier |
|---|---|---|
| Pull standard and custom fields into a document | Token mapping in the PandaDoc template and Salesforce settings | Configuration |
| Pricing table from Opportunity Products, Quote lines or Salesforce CPQ | Product and pricing-table mapping; the CPQ integration for Quote objects | Configuration |
| Show or hide sections by deal type, region or bundle | Conditional content rules on the template | Configuration |
| Write signed values and status back to the record | Two-way sync field mapping, exported on Sent and Completed (needs Salesforce API access) | Configuration |
| Create and send a document automatically on stage change | PandaDoc actions inside Salesforce Flow Builder | Low-code · Flow |
| Merge data from several related records into one document | Custom JSON builder in Apex against the PandaDoc integration | Custom development |
| Generate from an object the package has no relationship to | Apex or PandaDoc API call with a custom trigger | Custom development |
| Create an invoice or ERP record when a contract completes | Flow or Apex on the Completed status, integrated to Accounting Seed, QuickBooks or your ERP | Custom development |
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.
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.
Opportunity, Account, Contact, Lead, Quote and custom-object fields populate document tokens automatically — including recipients pulled from contact roles.
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.
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.
Sent, Viewed, Signed and Completed land on the Salesforce record as they happen, so pipeline reports and dashboards show where every document actually is.
Quotes built in Salesforce CPQ push into a branded, signature-ready document with live pricing, and quote status stays in step with the document.
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.
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.
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.
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.
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.
| Flow | What moves | Business purpose | Who consumes it |
|---|---|---|---|
| Salesforce → PandaDoc | Field values, products and pricing, recipients | Documents generate from CRM data; nothing is re-keyed | Sales reps, proposal managers |
| PandaDoc → Salesforce | Status, signed PDF, mapped field values | The record shows the truth about every document | Sales managers, RevOps, finance |
| Salesforce CPQ ↔ PandaDoc | Quote lines, quote and document status | Live pricing on the document; no price drift between systems | Deal desk, CPQ admins |
| Salesforce → billing / ERP | Completed-contract trigger, signed terms, amounts | Invoice or subscription created from the signed document | Finance and billing |
| Salesforce ↔ HubSpot | Deal, contact and company data | Marketing and sales stay in sync when both platforms are in play | Marketing 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.
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.
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.
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.
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.
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.
One engagement where the document layer was part of a larger Salesforce rebuild, and the four scenarios where we see the product deliver most.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Your team leaves able to edit templates, adjust routing and read the reporting themselves — with Salesforce support available when the scope grows.
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.
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