Salesforce · Document Generation

Nintex DocGen turns Salesforce records into finished, signature-ready documents.

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.

DocGen Run · Salesforce Org
SALESFORCE RECORD DATA Opportunity & Quote Stage · Amount · Line items Account & Contact Entity · Signatory · Terms Custom Objects Related Lists Files & Price Book NINTEX DOCGEN PACKAGE · BUILT BY TWOPIR Data Sources Objects · Relationships Filters · Conditions Templates Word · Excel · PPT PDF · Conditional text Delivery E-sign · Email · Store Approval routing ONE PACKAGE PER DOCUMENT TYPE · VERSIONED & GOVERNED 2πr DELIVERED DOCUMENT Sent to Sign Nintex eSign or DocuSign, status back Filed on Record Salesforce Files, SharePoint or Box Audit Trail Who generated what, when, from which data PACKAGE · MERGE · DELIVER
12+
Years of Salesforce & HubSpot delivery
500+
Clients across US, Canada, UK, UAE, AU & NZ
40+
Consultants, architects & QA in delivery
250+
CRM deployments delivered end to end

Trusted by 500+ organizations — including revenue, legal and operations teams running document generation on Salesforce with Twopir Consulting.

Hey Market
Platform9
Mitratech
Spinify
Fix Stream
Ultra Consultant
Partner Client
Sotheby's International Realty

Built for Document Operations

  • Salesforce Partner
  • Nintex DocGen for Salesforce
  • Nintex Workflow
  • Nintex RPA
  • Revenue Operations
  • Contract & Legal Teams
  • Proposal & Sales Ops
  • Field Service
Where Document Work Stalls

Where document generation breaks down around Salesforce

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.

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.

Approvals disappear into email

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.

Templates multiply and drift

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.

The stack holds one process in three places

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.

Rule-based work consumes the same hours every cycle

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.

Compliance depends on people remembering

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.

Platform Context

What Nintex DocGen for Salesforce actually is

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.

  • Revenue Operations
  • Sales Operations
  • Contract & Legal Teams
  • Proposal Managers
  • Finance & Billing
  • Salesforce Admins & Architects
Scope

Implement, configure, build on — three different engagements

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.

Comparison of the three Nintex DocGen engagement types Twopir Consulting offers: implement, configure, and build on
EngagementWhat the work isWhere 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.

What We Deliver

What Twopir actually builds on the product

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.

DocGen Package Design

The core deliverable. One governed package per document type, built around the data it needs rather than assembled from a starter kit.

  • Document inventory and consolidation
  • Data source and relationship mapping
  • Conditional logic by entity, region or deal type
  • Multi-template documents in a single run
  • Versioning and change control

Template Engineering

Turning the documents you already send into templates that merge cleanly — including the ones with tables, nested clauses and awkward pagination.

  • Word, Excel, PowerPoint and PDF templates
  • Legal-approved clause libraries
  • Line-item tables from related records
  • Brand, layout and pagination control
  • Multi-language and multi-entity variants

Approval & Workflow Routing

The step that takes documents out of email. Requests route to the right approver automatically, and the record shows where each one sits.

  • Nintex Workflow approval design
  • Salesforce-native approval processes where they fit better
  • Threshold, discount and exception routing
  • Escalation and reminder rules
  • Status visibility on the record

Delivery, E-Signature & Storage

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.

  • Nintex eSign and DocuSign routing
  • Signature status written back to the record
  • Filing to Salesforce Files, SharePoint or Box
  • Customer-facing email delivery
  • Audit trail of what was generated, when and from what

RPA & Process Mapping

The wider Nintex platform, where a document project usually goes next — automating the rule-based work either side of the document.

  • Nintex RPA for repetitive, rule-based tasks
  • Automation of systems with no usable API
  • Nintex Process Manager mapping and governance
  • Identifying which processes pay back first
  • Sequencing automation after the documents are stable

Enablement & Ongoing Support

Handover that holds. Your admins should be able to change a clause or add a template without raising a ticket with us.

  • Admin and end-user training
  • Runbooks for template and package changes
  • Managed package upgrade testing
  • New document types as the business adds them
  • Retained support as volume grows
Integration Architecture

What moves between Nintex, Salesforce and the rest of your stack

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.

Salesforce ↔ Nintex DocGen

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.

Nintex DocGen → Nintex eSign

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.

Nintex DocGen → DocuSign

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.

Nintex DocGen → SharePoint & Office 365

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.

Salesforce Files & Box

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.

Salesforce CPQ & Quotes

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.

Nintex Workflow ↔ Salesforce

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.

Nintex RPA → legacy systems

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.

Our Delivery Model

From manual assembly to a governed document process

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.

Step 01

Document & Process Audit

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.

Step 02

Package & Data Architecture

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.

Step 03

Build & Integrate

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.

Step 04

Pilot, Validate & Launch

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.

Step 05

Enable & Optimize

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.

Proof

What this looks like on a real engagement

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.

Case Study

UAE Luxury Real Estate — 250+ Agents

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.

< 4 hrs Contract turnaround, from 2–3 days
250+ Agents on the automated document flow
Near-zero Document errors, merged from the CRM

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 Study
Common Scenarios
Document Generation Contracts and invoices at volume

Sales 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.

Approval Routing Multi-department sign-off

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.

RPA Repetitive data entry

Operations teams hand rule-based work — data entry, record updates, status changes — to Nintex RPA, usually in the systems that never got an API.

Mobile Field and remote approvals

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.

See More Client Work
Why Twopir

Not a reseller. An architectural partner.

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.

We design the document process before we build the package

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.

We name the boundary between configuration and code

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.

We work the whole Nintex surface, not only DocGen

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.

The Salesforce platform depth sits underneath it

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.

Enterprise capacity across six markets

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.

Common Questions

Answers before the first call

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.

Next Step

Bring us the documents you send most, and we will show you the shortest path

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