Documents are assembled by hand from CRM data
Someone opens the record, copies the terms into a Word template, checks it, exports a PDF and emails it. The data was already structured — the document was not.
Nintex DocGen for Salesforce merges data from your Salesforce records into Word, Excel, PowerPoint and PDF templates, then routes the result for signature, storage or delivery — from a button on the record. Twopir Consulting implements, configures and extends it around your own contract, quote and approval process. We build the DocGen Packages; Salesforce stays the system of record.
Trusted by 500+ organizations — including revenue, legal and operations teams running document generation on Salesforce with Twopir Consulting.
Built for Document Operations
The data needed to produce a contract is almost always already in the CRM. What is missing is the machinery between the record and the signed document. Every manual step in that gap adds delay, error and risk.
Someone opens the record, copies the terms into a Word template, checks it, exports a PDF and emails it. The data was already structured — the document was not.
Without routing built into the process, approvals move through inboxes and side conversations. Nobody can answer where a document currently sits, or who is holding it.
Every team keeps its own copy of the quote or the contract. Legal-approved language stops being the language that actually goes out, and nobody notices until an audit or a dispute.
Salesforce has the customer, SharePoint or Office 365 has the document, and the approval lives in email. Teams re-key between them, which is where the errors enter.
Data entry, status updates and record maintenance follow fixed rules but still fall on people. That capacity is spent before anyone gets to the work that needs judgement.
When the process is not enforced by the system, steps get skipped under deadline pressure. Missing approvals and inconsistent records surface only afterwards, in the audit.
Nintex DocGen for Salesforce is a no-code document generation application that runs inside your Salesforce org. It merges data from Salesforce records into Word, Excel, PowerPoint and PDF templates and delivers the finished document — for review, e-signature or storage — from a button on the record. It is installed as a managed package from the Salesforce AppExchange, so the documents are generated where the data already lives.
The unit of work is the DocGen Package: one configured bundle holding the Salesforce data it draws on, the templates it merges into, and the delivery rules for what happens next. A quote, a master agreement and a renewal notice are three packages, each with its own data relationships, conditional content and routing. Designing those packages is the work — the merge itself is the easy part.
The product was previously sold as Nintex Drawloop DocGen, and the Drawloop name still appears in older documentation, AppExchange history and internal conversations. It is the same product line. Nintex also ships a wider automation platform around it — workflow, robotic process automation and process mapping — which is where a document project usually goes next. Nintex's own product documentation is published here.
What it is not: a contract lifecycle management suite, a CPQ engine, or a replacement for Salesforce. It generates and delivers documents from data you already hold — which means the quality of the output is set by the quality of the data model underneath it. That is usually the real project.
Most buyers arrive asking for "a Nintex project" and mean one of three quite different things. Twopir offers all three. Knowing which one you need is the cheapest decision in the whole engagement, so here is where each begins and ends.
| Engagement | What the work is | Where it stops |
|---|---|---|
| 01 · Standing it up Implement | Install and license the managed package in your org, connect it to the objects that hold your document data, set permissions and profiles, and build the first working DocGen Packages so a real document generates from a real record. Includes template conversion for the documents you use today and the button or action that launches them. | Ends when your standard documents generate correctly and are delivered where they need to go. Right for you if Nintex is new to the org, or was installed and never properly adopted. |
| 02 · Fitting it to you Configure | Tailor what already works to how your business actually runs: conditional content that changes clauses by region, entity or deal type; data relationships that pull line items and related records; approval routing before or after generation; multi-template documents assembled in one run. All done in the product's own configuration surface — no code deployed to your org. | Ends at the edge of what the product can be configured to do. Right for you if DocGen works but produces documents your team still edits by hand afterwards. |
| 03 · Extending it Build on | Custom Salesforce development around the product: Apex to prepare or reshape data before a merge, Lightning Web Components for a generation experience the standard button cannot give, Flow and platform events to trigger runs, and API work to move documents or status between Nintex and systems outside Salesforce. Delivered to your org's own standards — bulk-safe, test-covered, and reviewable. | Ends where a supported configuration would have done the same job. We will say so. Right for you if the requirement has already been ruled out as configuration. |
Where the boundary sits, plainly: if the requirement can be met by the product's own configuration — data relationships, conditional content, delivery and routing rules — it is configuration, and it stays supported through Nintex's own upgrades. The moment it needs Apex, a Lightning Web Component, or an API call, it is custom development, and it becomes code your org has to own and regression-test at every package upgrade. Most requirements that arrive described as "we will need custom development" turn out to be configuration. We check that first, in that order, and we tell you which side of the line you are on before anyone quotes it.
Nintex supplies the document engine. These are the pieces we design and build around it so the engine produces the documents your business actually sends.
The core deliverable. One governed package per document type, built around the data it needs rather than assembled from a starter kit.
Turning the documents you already send into templates that merge cleanly — including the ones with tables, nested clauses and awkward pagination.
The step that takes documents out of email. Requests route to the right approver automatically, and the record shows where each one sits.
What happens after the merge: where the document goes, who signs it, and where the signed copy is filed so it can be found later.
The wider Nintex platform, where a document project usually goes next — automating the rule-based work either side of the document.
Handover that holds. Your admins should be able to change a clause or add a template without raising a ticket with us.
A document process crosses several systems even when it looks like one button. These are the boundaries we design, and what travels across each one.
The core boundary. Record data — Opportunity, Account, Contact, custom objects and their related lists — flows into the package at run time; the generated file, its status and its timestamp are written back onto the record so sales and finance see the same state.
Generated documents are routed for signature without leaving the flow, and the completed signature status returns to the Salesforce record — so a rep sees a signed contract on the Opportunity rather than in a mailbox.
Where DocuSign is already the organisation's signature standard, DocGen delivers into it instead. The routing changes; the package, the templates and the data model do not.
Finished documents are filed into the Microsoft document library the business already treats as its record store, so legal and compliance keep working where they work today instead of learning Salesforce.
The alternative filing destination when documents should stay attached to the record itself, or when Box is the enterprise content store. Chosen deliberately — split filing is what makes documents unfindable a year later.
Quote line items, pricing, discounts and price-book data merge into the proposal or order form as a real table, so the document a customer receives matches the quote the system approved.
Approval routing wrapped around generation — before it, when a document must be authorised before it exists, or after it, when the draft needs sign-off. Approver decisions land back on the Salesforce record as status, not as an email thread.
Where a system has no usable API, RPA performs the rule-based entry and status updates a person would otherwise do by hand — used to close the last gap in a process, not as the first tool reached for.
A focused first deployment — one document type and one approval path — typically runs a few weeks end to end, including discovery, configuration, testing and launch. Programmes spanning several departments run longer. Discovery sets the scope and the sequence before any build starts, so the timeline comes from your documents rather than from a template.
We inventory the documents you actually send, trace each one back to where its data lives, and map the approval path it travels. Near-identical templates get consolidated here, before anyone builds them.
We design the DocGen Packages, the data relationships behind them, the conditional logic, and the delivery rules — and we resolve the data-model gaps the audit found, because a merge cannot fix a field that is empty.
We configure the packages and templates, wire up signature, storage and approval routing, and add custom development only where configuration genuinely cannot reach — with the reason recorded.
A defined user group generates real documents against real records. We compare every output against the document it replaces, correct the edge cases, then expand org-wide rather than launching everywhere at once.
We train admins and end users, hand over the runbooks, and stay for the package upgrades, new document types and process changes that arrive once the business trusts the system.
One client engagement, and the scenarios we are asked for most often. The numbers below are from that single named engagement and describe what changed there — not a benchmark, and not a promise for a different org.
Nintex and PandaDoc wired directly into Salesforce Opportunities, so contracts, offer letters and KYC onboarding forms generate from CRM data the moment a deal reaches the document stage.
Before: agents copied deal data out of Salesforce into Word templates, checked it by hand, then printed for a physical signature or emailed a PDF — 2–3 days per deal, and the most common source of delay in the pipeline. Document errors dropped to near-zero afterwards because every field is merged from the CRM record rather than retyped.
Read Full Case StudySales or finance generates contracts, invoices and reports straight from CRM data instead of assembling them by hand — the same document, produced the same way, every time.
Email approval chains are replaced by a workflow that routes each request to the right stakeholders, notifies them, and tracks the request end to end so nothing sits unresolved in an inbox.
Operations teams hand rule-based work — data entry, record updates, status changes — to Nintex RPA, usually in the systems that never got an API.
Field and remote staff review, approve and complete workflow steps from a mobile device, so document processes keep moving when the approver is not at a desk.
Nintex projects rarely fail at the merge. They fail at process design, at the data model underneath, and at adoption — which is where the engagement has to start.
The audit comes first: which documents you actually send, where their data lives, who approves them. Firms routinely find they are maintaining nine templates that should be three.
Configuration survives package upgrades; custom code is yours to own and regression-test forever. We tell you which side a requirement falls on before it is quoted, not after it is built.
Document generation, workflow approvals, RPA and process mapping are one platform. Knowing which of them a problem belongs to is what stops a workflow question being answered with a template.
With 12+ years and 500+ clients across Sales Cloud, Service Cloud, Experience Cloud and Platform, we know where a document project is really a data-model project — and say so early.
A 40+ person delivery team — architects, developers and QA — working across the US, Canada, UK, UAE, Australia and New Zealand, at a cost structure that suits mid-market as well as enterprise.
Nintex DocGen for Salesforce is a no-code document generation application that runs inside your Salesforce org. It merges data from Salesforce records into Word, Excel, PowerPoint and PDF templates, then delivers the finished document for review, e-signature or storage — launched from a button on the record. It is installed as a managed package from the Salesforce AppExchange, and the unit of configuration is the DocGen Package: a bundle holding the data it draws on, the templates it merges into, and the delivery rules for what happens next.
Yes — it is the same product line. Drawloop was acquired by Nintex and the product was sold for some years as Nintex Drawloop DocGen before settling on Nintex DocGen for Salesforce. The Drawloop name still appears in older documentation, in AppExchange history and in the way many teams still refer to it internally. If your org has "Drawloop" in its installed packages or its field names, this is the product this page is about.
Configuration is enough far more often than buyers expect. If the requirement can be met through the product's own surface — data relationships, conditional content, multi-template documents, delivery and approval routing — it is configuration, and it keeps working through Nintex's own package upgrades. It becomes custom development the moment it needs Apex, a Lightning Web Component, or an API call to a system outside Salesforce, at which point it is code your org owns and must regression-test at every upgrade. We test a requirement against configuration first and tell you which side of that line it falls on before it is quoted.
Yes. It installs into your existing org and reads your existing objects, records and relationships, including custom objects — there is no separate migration and no parallel data store. The honest caveat is that a merge can only use data that is actually there: if the terms, entity details or signatory fields your documents need are held inconsistently or in free text, that gets fixed as part of the work. We assess it during the audit rather than discovering it in the first template. If your org needs broader remediation first, that is Salesforce support and optimisation work.
A focused first deployment — one document type with one approval path — typically runs a few weeks end to end, covering discovery, configuration, testing and launch. Implementations spanning several departments and document families run longer, and the variable is almost never the merge: it is how many templates need consolidating and how clean the underlying data is. Discovery defines the scope and the delivery sequence before any build begins, so the estimate reflects your documents rather than an average.
Both generate documents from Salesforce data, both are mature AppExchange applications, and for a straightforward quote or proposal either will do the job well. The distinction that matters in practice is scope: Nintex sits inside a broader automation platform that also covers workflow approvals, robotic process automation and process mapping, so it suits organisations whose document generation is one step in a larger automated process. Conga Composer is the stronger fit when document assembly itself is the requirement and the surrounding process is already handled. We implement both, and we would rather scope the process first and pick the product second — our Conga Composer implementation work is the other side of the same conversation.
The wider platform as well. Document generation is usually the entry point because it produces a visible result quickly, but the same engagements go on to cover Nintex Workflow for approval routing, Nintex RPA for rule-based tasks in systems without a usable API, and Nintex Process Manager for mapping and governing the processes themselves. We sequence it deliberately: documents first, because they are self-contained and prove the value, then the automation either side of them. There is more background in our write-up on Nintex for process automation.
A discovery call starts with your actual templates and approval paths, not a demo. You will leave it knowing which document types pay back first, whether your requirement is configuration or custom development, and what a realistic first deployment looks like. Nintex DocGen is one of several Salesforce AppExchange applications we implement and extend.
Speak with a team that builds DocGen Packages, not slide decks

Delivering certified expertise to transform CRM, marketing automation, and AI-powered business processes for growing organisations worldwide.
Building 4A, Ground Floor, SP Infocity SEZ,
Phursungi, Pune, Maharashtra – 412308
✉ info@twopirconsulting.com 📞 +91 74208 94628New Haven, Connecticut,
United States - 06513
✉ info@twopirconsulting.com 📞 +1 (888) 912-9340