Signed line items get retyped into billing
The customer agreed to a configuration. Somebody now types that configuration into the billing system by hand, and any difference between the two becomes a credit note next month.
Systems Integration · Document Workflow A signature should start something.
A signature should start something.
Usually it just ends an email thread.
In most companies the moment a contract is signed is the moment the automation stops. Somebody re-keys the line items into billing, somebody else updates the CRM, and a third person files the PDF. Integration is the work of making that signature an event other systems act on — billing, provisioning, finance, records. Signed, and everything downstream already knows.
2-way
0
1
Real-time
Trusted by 500+ organizations — including revenue, sales operations and legal teams running document generation, quoting and e-signature on Salesforce and HubSpot with Twopir Consulting.
Systems We Connect
- Salesforce Partner
- HubSpot Partner
- Chargebee
- Celigo
- Workato
- Zapier
- ERP & Billing
- Payments
Where the document workflow stops being automated
Document automation usually gets built to the point of signature and no further. These six gaps are all on the far side of it.
The signature does not trigger anything
No provisioning, no onboarding task, no finance notification. The deal closes and the rest of the company finds out when somebody mentions it.
Executed agreements live in three places
One copy on the CRM record, one in a shared drive, one in an inbox. During an audit or a renewal negotiation, nobody is certain which is the executed version.
Nobody owns a field, so both systems write to it
Bidirectional sync without an ownership rule means the last writer wins. The deal value changes depending on which system somebody looked at most recently.
Shadow automations nobody documented
A Zap built by someone who has left, doing something important, in a way nobody can describe. It works until it does not.
Failures are silent
A sync fails, nothing alerts, and the gap is found weeks later during reconciliation. An integration without error handling is a data-quality problem waiting for a deadline.
What Integration Means Here
Connectors and iPaaS — not custom code
This page covers integration built on PandaDoc's native connectors and on integration platforms — Zapier, Workato, Celigo and similar. That means the CRM apps for Salesforce and HubSpot, the payment and storage integrations PandaDoc ships, and event-driven automations that connect document status to the systems around it. It is configuration work: there is no codebase for your team to maintain afterwards.
Where this page stops. When a requirement cannot be expressed through a connector or an iPaaS recipe — generating from an object the connector does not surface, bulk runs, embedded document experiences, or business logic no rules engine can state — the answer is development against PandaDoc's REST API. That is a different engagement with a different cost and a maintenance commitment, and it lives on our PandaDoc API development page. We tell you which side of that line you are on during discovery, not after.
Three roles, kept separate. PandaDoc provides the document platform, its connectors and its webhook events. Your CRM, billing and ERP systems remain the systems of record for their own data. Twopir designs the data flow between them — which system owns which field, what moves in which direction, what happens when a sync fails, and who finds out.
The design decision that matters most is rarely technical. It is deciding, for every field that exists in two systems, which one is authoritative. Teams that skip that conversation build integrations that work in testing and disagree in production.
Connect, orchestrate, or build the connector yourself
Integration requests arrive at three levels of depth. The third one is a development project.
Connect
Standing up the native connections properly: CRM, payments, storage. Configuration, tested against your real records.
- CRM app installed, authenticated and field-mapped
- Document status writeback configured and validated
- Payment collection at signature
- Storage and records filing on completion
- Notification routing to the people who must act
- Failure-path testing, not only the happy path
Orchestrate
Multi-system flows across the quote-to-cash path, built on iPaaS with proper error handling and monitoring.
- Signed quote driving billing or subscription creation
- Provisioning and onboarding triggered on signature
- Renewal generation from contract dates
- Field ownership rules documented per system
- Retry, alerting and reconciliation reporting
- Shadow automations inventoried and rationalised
Build On
Where connectors and iPaaS genuinely cannot reach. Scoped and maintained as software — see our API development page.
- Generation from objects the connector does not surface
- Custom webhook services with retry and dead-lettering
- Bulk and scheduled document runs
- Embedded document experiences in your own product
- Transformations no rules engine can express
- Middleware to systems with no connector at all
| Requirement | Native connector | iPaaS (Zapier / Workato / Celigo) | Custom API |
|---|---|---|---|
| Populate a document from a CRM record | Yes | Limited — no live template population | Yes |
| Write document status to the CRM | Yes — near real time | Yes — per-event | Yes |
| Sync quote line items both ways | Yes | No | Yes |
| Trigger a task on signature | Via CRM workflow | Yes | Yes |
| Create an invoice from a signed quote | Depends on the platform | Yes — common pattern | Yes |
| Generate from a custom object | No | No | Yes |
| Bulk-generate on a schedule | No | Partly — rate limited | Yes |
| Embed signing in your own product | No | No | Yes — JavaScript SDK |
iPaaS is genuinely good at single-event, single-action jobs and genuinely bad at anything needing the document's own context. Knowing which is which saves a rebuild.
The boundary, in one sentence: a connector or an iPaaS recipe can move data between systems on an event; only the API can reach inside the document workflow to create, assemble or embed. If the requirement contains the words "generate from", "in bulk" or "inside our app", it is an API project.
The six things a durable integration needs
Most integration work is the last two. Most integration quotes stop after the first.
CRM Data Flow
The primary connection: records populate documents, document events return to the record.
- Field-by-field mapping from CRM objects to variables
- Document status, PDF and timestamps written back
- Quote and line-item synchronisation where supported
- Transformation for picklists, formulas and lookups
- Validation against real records before go-live
Billing, Payments & Subscriptions
Turning a signed configuration into an invoice or a subscription without a human in between.
- Signed line items driving subscription creation
- Invoice generation from accepted quotes
- Payment collection at the point of signature
- Billing status returning to the deal record
- Reconciliation reporting between signed and billed
Records, Storage & Retention
One executed version, filed where policy says it belongs, findable when it matters.
- Completed agreements filed to the CRM record
- Mirroring to a document management system where required
- Audit certificate stored alongside the agreement
- Retention rules applied at filing time
- Naming and metadata so the archive stays searchable
Event Routing & Downstream Triggers
Sent, viewed, signed and expired as events other systems act on, rather than as history.
- Provisioning or onboarding triggered on signature
- Follow-up tasks when a buyer opens a document
- Stall alerts when a document ages past a threshold
- Renewal sequences from contract dates
- Notifications routed to a person, not a channel
Ownership Rules & Conflict Design
The part that decides whether the integration is trustworthy in six months.
- A documented owning system for every shared field
- Conflict rules where both sides can write
- Idempotency so a replayed event does not double-post
- Loop prevention on bidirectional flows
- A written data-flow map handed to your team
Monitoring, Retry & Support
An integration nobody monitors is a data-quality incident with a delay on it.
- Retry and back-off on transient failures
- Dead-letter handling so nothing is silently dropped
- Alerting to an owner, with a runbook
- Reconciliation reports that surface drift early
- Rate-limit headroom checked on both platforms
What moves, in which direction, and why
Both platforms named, the business purpose, and the data that actually moves which way — for every connection we build.
Salesforce ↔ PandaDoc
Account, Contact and Opportunity data populates documents at creation; status, signed PDF and completion timestamps write back to the Opportunity, and quote line items sync with Opportunity Products in both directions.
HubSpot ↔ PandaDoc
Deal, company and contact properties populate quotes; deal line items sync both ways including optional products, and document events post to the activity timeline where workflows act on them.
Chargebee & subscription billing
The accepted quote's line items create or amend the subscription, and billing status returns to the CRM so sales sees a failed payment before the renewal call rather than after the churn.
ERP & finance systems
Signed order data flows to the ERP for fulfilment and revenue recognition; invoice and payment status flow back so the deal record reflects what finance actually sees.
Payment collection at signature
Deposit or first payment captured in the same session as the signature, with the payment result written to the document and the deal rather than reconciled later.
Document storage & DMS
Executed agreements filed to the CRM record and mirrored to your document management system with the audit certificate, under the retention rule that applies to that document type.
Zapier, Workato & Celigo
Event-triggered single-action flows: a signature creating a task, a status change notifying a system. Fast to build, limited by design — they cannot populate a template at creation time.
Slack & Microsoft Teams
Approval requests and signature notifications delivered to the individual who has to act, with the document link and the deal context attached.
Five phases, and the ownership map comes first
The technical build is rarely the hard part. Deciding which system is authoritative for each field is, and it is cheaper to decide it in Phase 02 than in production.
System & Data Inventory
We map every system that touches a document, every field that exists in more than one of them, and every existing automation — including the undocumented Zaps, which are usually where the surprises live.
Data Ownership & Flow Design
For each shared field we agree the owning system, the direction of travel and the conflict rule. This produces a written data-flow map that your team keeps, and it is the deliverable clients refer back to most.
Build & Connect
Connectors configured and iPaaS flows built, with idempotency, retry and loop prevention designed in rather than added after the first incident.
Failure Testing & Reconciliation
We test the paths that go wrong: rate limits, partial failures, replayed events, conflicting writes. Reconciliation reporting is built here so drift surfaces early.
Launch, Monitor & Hand Over
Go-live with alerting to a named owner and a runbook. Then a review at 30 and 90 days against the reconciliation reports, because integrations degrade quietly rather than loudly.
What changes when the chain does not break at signature
Real engagements, with the scope each number was measured against.
Quote-to-Cash Document Automation
40–150 sales users · 500+ documents per month · delivered in 8 weeks across 5 phases
100%
Transaction data auto-populated
0
Manual exports or copy-paste steps
Real-time
Status visible inside Salesforce
1
System of record for every document
Proposal creation used to take a rep 45 minutes of copying data, fixing formatting, and hoping nothing was wrong by the time it reached the customer. Now they click one button inside Salesforce and a fully accurate, branded document is ready to send in under a minute.
Salesforce · Chargebee · PandaDoc
The signed quote creating the subscription, and billing status returning to the CRM
3
Systems on one integrated path
0
Re-keying between quote and billing
1
Authoritative deal value
2-way
CRM synchronisation
Engagement scope: accepted PandaDoc quote line items drive subscription creation in Chargebee, and billing status returns to the Salesforce Opportunity so sales, finance and the customer read the same agreement. Outcome metrics for this engagement are being confirmed with the client before publication.
Teams where the handoffs are the problem
If the document workflow is fine and the trouble starts after signature, this is the right engagement.
RevOps teams owning quote-to-cash
You own the path from quote to invoice and you are tired of explaining why the billed amount and the signed amount differ.
Finance systems owners
Month-end reconciliation is a manual exercise because the signed configuration never reached the billing system automatically.
IT leaders rationalising integrations
There are more automations than anyone can list, several built by people who have left, and you need an inventory before you need a build.
Teams running PandaDoc without a CRM connection
Documents are built in PandaDoc and customer data is typed in. Connecting the CRM is usually the highest-return piece of work available.
Companies adding billing to an existing setup
Documents and CRM are connected; billing is not. This is a well-trodden path and a comparatively short engagement.
Teams recovering from a silent failure
A sync stopped working and nobody noticed for weeks. You need monitoring and reconciliation, not just a repair.
We design the data contract, not just the connection
Anyone can authenticate two systems. The value is in deciding what is true when they disagree.
Field ownership before field mapping
Every shared field gets a documented owning system and a conflict rule. This is the single most common omission in integrations we are asked to repair.
We test the failure paths
Rate limits, partial writes, replayed webhooks and conflicting updates. An integration that only works on the happy path is a scheduled incident.
We inventory the shadow automations
The Zap nobody remembers is the one that breaks. Phase 01 exists specifically to find them before they find you.
We are CRM architects, Salesforce Partner and HubSpot Partner
Most integration failures are CRM-side: field-level security, sharing rules, record types and API limits. That is our home ground.
We tell you when it is an API project
We would rather scope a development engagement honestly than sell an iPaaS recipe that cannot do the job and has to be rebuilt in a year.
15+ platform partnerships
Across 250+ deployments and 500+ clients in 12+ years, with a 40+ person team.
What teams ask before starting an integration project
The questions that decide approach, cost and who maintains it afterwards.
Use the native connector for anything involving the document's own context — populating a template from a record, syncing quote line items, writing status back. Use iPaaS for single-event, single-action jobs where no template population is needed: a signature creating a task, a status change notifying a system. Use custom API development only when neither can reach the requirement, because it is the only option that leaves you with code to maintain.
This page covers integration you can configure: native connectors and iPaaS recipes, with no codebase afterwards. The API page covers integration you have to build and maintain — custom objects, bulk generation, embedded document experiences, middleware to systems with no connector. The distinction matters because the second carries an ongoing engineering cost and the first does not. We tell you which one your requirement needs during discovery.
Not in the way the native connector does. Zapier can create a document from a template and pass field values it has been given, but it cannot pull live record context at creation time the way the CRM app does, and it has no access to document analytics or engagement data. For document creation driven by CRM records, the native integration is the right tool; Zapier earns its place on the events around it.
By deciding, in Phase 02, which system owns each shared field, and writing it down. Where both sides legitimately write — a quote value, for instance — we define an explicit conflict rule, add idempotency so a replayed event cannot double-post, and build loop prevention on bidirectional flows. The written data-flow map is a deliverable, not an internal artefact.
It depends entirely on whether anyone designed for it. We build retry with back-off for transient failures, dead-letter handling so nothing is dropped silently, alerting to a named owner with a runbook, and reconciliation reporting that surfaces drift before month-end. Integrations degrade quietly, so the monitoring is the part that makes them durable.
Yes, and they are worth checking before you scale rather than after. PandaDoc enforces per-endpoint rate limits, and Salesforce allocates API requests per 24-hour period based on edition and licence count. Teams running bulk sends or quarter-end pushes should confirm they have headroom on both sides. We check this during design and build back-off into anything that could hit a ceiling.
Frequently, and it is a common engagement. We start with the same inventory and ownership mapping — most of what we are asked to repair works correctly on the happy path and has no conflict rules, no retry and no monitoring. Adding those is usually cheaper than a rebuild, and we will tell you when it is not.
Connecting a CRM properly and validating it is typically two to four weeks. A multi-system quote-to-cash flow with billing, reconciliation and monitoring runs longer, and the variable is almost always how many shared fields need an ownership decision rather than how many systems are involved.
Next Step
If your automation stops at the signature, start here
Tell us which systems touch a document today and where the re-keying happens. We will come back with a data-flow map, the ownership decisions you need to make, and an honest split between what a connector can do and what needs building.
12+ years · 500+ clients · 40+ consultants · Salesforce Partner · HubSpot Partner
