Documents are still assembled by hand
Someone exports a record, opens last quarter's Word file, replaces the names and numbers, saves a new version and emails it. Every document is a fresh opportunity to get something wrong.
Most Conga Composer projects do not fail at installation. They fail at the data layer — a query that misses a related record, a template that breaks on the one deal with eleven line items, a solution nobody can safely change once its author leaves. Twopir designs the queries, templates and automation underneath your documents so generation stays correct as the business changes. Quotes, contracts, invoices and client packets, straight from Salesforce.
Trusted by 500+ organizations — including document-heavy teams in real estate, legal, professional services and manufacturing running their operations on Salesforce with Twopir Consulting.
Built for Salesforce Document Automation
Teams usually arrive asking for a better proposal template. What they actually have is a data problem, a logic problem and an ownership problem wearing a template's clothes. Fix the layer underneath and the template stops breaking.
Someone exports a record, opens last quarter's Word file, replaces the names and numbers, saves a new version and emails it. Every document is a fresh opportunity to get something wrong.
Four regions keep four copies of the same agreement. Legal updates one. Nobody can say which version a client actually signed, or which clause set is current.
Pricing, legal entity, tax treatment and contact details get retyped between systems. The mistakes that reach a customer are the expensive ones — and they are always avoidable.
The commercial terms were agreed on Tuesday and the paperwork lands on Friday. Document latency shows up in the pipeline as slipped close dates long before anyone calls it a document problem.
Generation is automated, then the file is downloaded, attached to an email by hand, chased for approval in chat, and re-uploaded after signature. The automation stops exactly where the delay starts.
Month-end statements, renewal notices and portfolio reports are fine as a single click and impossible across 900 accounts — because nothing was built to run scheduled or in batch.
A common starting point: the original queries were brittle, templates broke on edge cases, or only one document type was ever built — so the team quietly went back to manual work.
The one person who understood the query syntax has moved on. Changing a clause now feels risky, so the documents freeze while the business keeps moving.
Conga Composer is a document generation application for Salesforce. It is installed as a managed package, launched from a record, a button or an automation, and it merges Salesforce data into Microsoft Word, Excel and PowerPoint templates or PDF forms — then delivers the finished file by download, email, attachment to the record, or onward to eSignature. Conga publishes the full feature reference in its Composer for Salesforce documentation.
What the product does not decide for you is the hard part: which records the document should see. A Composer solution is assembled from a master record plus the datasets you feed it — Conga Queries holding tuned SOQL, Salesforce reports, global merge values — and the quality of that data layer is what separates a solution that survives three years from one that breaks the first time a deal has an unusual shape.
That is the work we do. Twopir treats a Conga Composer engagement as a document infrastructure problem, not a template-building exercise: data model first, then queries, then templates, then the automation and delivery around them. If you are still deciding whether Composer is the right tool at all, the Conga Composer overview for Salesforce teams covers the product itself; this page is about the build.
| Layer | What Conga Composer provides | What the implementation has to add |
|---|---|---|
| Data | A merge engine that reads the master record and any datasets supplied to it. | The object model, relationships and Conga Queries that make the right related records reachable in the first place. |
| Templates | Word, Excel, PowerPoint and PDF form templates with merge fields, conditional IF logic, TableGroup and TableHide. | Document design, clause and pricing logic, edge-case handling, and a versioning convention the business can maintain. |
| Launch | Buttons, links and URL parameters that start a solution from a record or an automation. | Where generation belongs in the process, who can trigger it, and what happens to the record when it succeeds or fails. |
| Automation | Conga Batch for scheduled and bulk runs; Conga Trigger for generation initiated by Salesforce Flow. | The Flow design, entry criteria, background-mode configuration and error handling that make unattended runs safe. |
| Delivery | Download, email, storage in Salesforce, and routing to Conga Sign or another eSignature provider. | Approval routing, recipient logic, storage conventions and the write-back that keeps the record's status accurate. |
| Security | Enforcement of the running user's Salesforce object and field permissions. | Permission sets, connected-app and Visualforce access, and a tested access model per role — so nobody merges a field they should not see. |
| Ownership | Configuration stored in Salesforce records you control. | Documentation, naming standards, a sandbox-to-production path, and admins trained to change it without fear. |
Scroll the table sideways to read every column →
Three different situations, three different scopes, three different buyers. Tell us which one you are in and the first call gets a great deal more useful.
A first deployment, or a first serious one. We stand up Composer end to end — from the Salesforce data model through to signed, filed documents.
You already own Composer and it is underused, brittle or actively avoided. We audit what exists, keep what works, and rebuild what does not.
Where configuration runs out. Composer stays the generation engine; we build the Salesforce logic, automation and integrations around it.
Where the boundary actually sits: if the requirement can be expressed as data, template logic or a Conga parameter, it is configuration and it belongs in Composer. If it needs state, branching across records, or a decision the merge engine cannot see, it belongs in Salesforce automation next to Composer — not buried inside a template. Keeping that line clean is what makes a solution maintainable by your own admins later.
Every item below is real Conga Composer configuration or real Salesforce work around it — not a feature list copied from a vendor brochure.
Tuned SOQL in Conga Query records that traverse parent records, related lists, junction objects and custom objects — so the document sees the full context, once, without duplicates.
Word, Excel, PowerPoint and PDF form templates built with Template Builder, including conditional IF logic, TableGroup grouping and TableHide for sections that must disappear when empty.
Conga Solution records and launch points configured for Lightning, with the URL parameters that control template selection, datasets, output format and what the user is shown.
Conga Batch for scheduled and bulk generation, Conga Trigger driven by Salesforce Flow, and background-mode configuration so unattended runs deliver without a user watching them.
Conga email templates merged per recipient, attachment rules, storage conventions in Salesforce Files, and the activity or status write-back that proves the document actually went out.
Generated documents handed to Conga Sign, DocuSign or Adobe Acrobat Sign, with signer logic, approval routing tied to deal data, and the signed file returned to the right record.
Permission sets, connected-app enablement and Visualforce page access configured per role — and merge output tested against real profiles, because Composer honours the running user's field access.
Edge-case test sets, sandbox-to-production deployment of solutions and templates, documented naming standards, and ongoing support as products, pricing and clauses change.
The same engine, pointed at different records. What changes between these is the data design and the delivery path — which is where the implementation effort really goes.
| Document | Who runs it | Typical Salesforce source | What makes it non-trivial |
|---|---|---|---|
| Proposals & quotes | Sales, sales operations | Opportunity with products, or Quote with line items | Grouped and conditional line items, discount and tax logic, sections that hide when empty |
| Contracts & agreements | Legal, revenue operations | Opportunity, Contract or a custom agreement object | Clause selection driven by deal attributes, version control, routing to signature and back |
| Real estate transaction packets | Brokerage and transaction teams | Listing, deal and contact records across related objects | Several documents assembled as one package, jurisdiction-specific forms, agent and commission data |
| Invoices & statements | Finance, billing | Billing or invoice records with related transactions | Multi-entity and multi-currency presentation, tax treatment, scheduled batch runs at period end |
| Client onboarding packs | Customer success, operations | Account with contacts, products and service records | One trigger producing several documents, each delivered to a different recipient |
| Renewal notices | Account management | Subscription, asset or contract records | Scheduled generation ahead of a date, uplift calculations, suppression rules for accounts in dispute |
| Board and executive reports | Leadership, operations | Several Salesforce reports or queries as datasets | Many datasets in one output, Excel formula templates, consistent period-over-period formatting |
| Batch client communications | Marketing, operations, member services | A filtered report of the target records | Volume, per-recipient merge accuracy, deliverability, and a record of what was sent to whom |
Scroll the table sideways to read every column →
Document work in real estate has its own shape — listings, offers, disclosures and commission paperwork moving between agents, clients and brokerages. If that is your context, the Propertybase and Salesforce real estate CRM work sits directly alongside this one.
Composer inherits your Salesforce architecture, good or bad. These are the areas we assess before anyone opens a template — and the ones that decide whether the solution is still working in two years.
Every merge field traces back to an object relationship. Where that path is missing, the document cannot show the value — no template trick fixes it.
Datasets are where most solutions quietly fail. Getting them right is the difference between one clean query and eight overlapping ones nobody dares touch.
Automated generation is an orchestration problem. The question is not whether Flow can call it, but what happens on the unhappy path.
Composer merges as the running user. That is a feature, and it is also how a solution that worked for an admin fails silently for a sales rep.
Documents rarely end their life in Salesforce. We design where the file goes, what the receiving system needs, and how status flows back.
A merge field is an honest mirror. Blank output on a live quote is almost always a data problem the document just made visible.
A focused rollout covering core document templates, Conga Queries and one or two Conga Solutions typically runs four to eight weeks. Broader programmes — many document types, heavy integration, multi-entity output — run longer, and we say so before you sign, not after.
We sit with the people who make the documents today and watch the real process — including the spreadsheet nobody mentions. We collect live examples of every document in scope, note who approves and who sends, and inspect the Salesforce org behind them. If Composer is already installed, existing Solutions, Queries and templates are reviewed here. This is where scope gets honest: most teams discover they have fewer genuinely distinct documents than they thought, and one harder one than they expected.
Covers · Business & requirements discovery · Current-state assessmentWe decide which object each document generates from, trace every value on the page back to a field and a relationship, and design the datasets that will feed the merge. Gaps surface here — a value on the current document that exists nowhere in Salesforce is a data decision, not a template decision. Why it matters: nearly every failed Composer implementation we are asked to rescue skipped this phase and started with the template.
Covers · Solution architecture · Data mapping · Security & access designConga Queries are written and tested against real records before a template is touched. Then templates are built to the approved design with conditional logic, grouping and hidden-when-empty sections, and wired into Conga Solution records with the right launch points and parameters. Why it matters: templates built on proven datasets are quick to change later; templates carrying their own data logic are the ones nobody dares edit.
Covers · Composer configuration · Template & document designGeneration is connected to the process around it: Salesforce Flow for automatic runs, Conga Trigger and Conga Batch for unattended and scheduled output, approval and routing logic, eSignature hand-off, storage rules and status write-back. Anything configuration genuinely cannot express is built in Salesforce next to Composer — never hidden inside a template. Why it matters: this is the phase that turns a faster document into a faster process.
Covers · Salesforce integration · Workflow automation · CustomizationWe test against a deliberate edge-case set — empty records, maximum line counts, unusual currencies, the deal everyone remembers — and we run every solution as the profiles that will actually use it, because Composer merges with the running user's access. Then we train admins on how to change it and users on how to run it. Why it matters: a document that is correct for an administrator and blank for a sales rep is a permissions bug, and it is always found here or in front of a client.
Covers · Testing & validation · User trainingSolutions and templates are promoted from sandbox on a controlled path, with naming standards and written documentation so the next admin can follow the logic. After go-live we watch real usage: which documents get generated, which get edited afterwards, which never get used. Those signals drive the next round of work. Why it matters: document requirements change every time pricing, legal wording or the product set changes — the solution has to change with them.
Covers · Deployment · Post-implementation support & optimizationWe do not publish a guaranteed percentage, because the honest answer depends on how much manual work you are doing today. What we can describe is the shape of the change, and how to measure it in your own numbers.
Document automation is only as strong as the Salesforce data behind it. We work on both sides of that line, which is why our Composer solutions tend not to need rescuing.
If the object model cannot reach the value, no template can print it. We are Salesforce architects first, which means the missing relationship gets built rather than worked around.
You get a clear boundary and a reason for it. Configuration where configuration belongs, Salesforce automation where it does not, and nothing important hidden inside a Word template.
A good share of our Conga work starts with an org where Composer is licensed and unused. We audit the existing Solutions, Queries and templates and return written findings, prioritised, within five business days.
Named solutions, described buttons, documented queries, a sandbox path and a trained team. The test of a good handover is whether your admin can change a clause next quarter without opening a ticket.
We help growing and mid-market companies solve complex CRM, integration and business system challenges, and we serve enterprise organizations with the same architecture discipline. The constraint we design for is a real team with real deadlines.
Contracts that took days, commission paperwork tracked in spreadsheets, billing spread across systems. Each figure below is scoped to the engagement that produced it.
A brokerage with 250+ agents where leads were manual, contracts took days and commissions lived in spreadsheets — unified onto one Salesforce and Propertybase platform in three phases.
Mass billing and matter management automated inside Salesforce, with third-party systems integrated so administration and invoicing stopped being manual work.
On published Conga Composer figures: Conga's own customer material describes the New York State Health Foundation producing grant letters far faster with Composer, and Conga reports that more than 8,000 customers generate over 10 million documents a month with it. Those are the vendor's numbers, not ours, and we cite them as context rather than as an outcome we measured. The two engagements above are Twopir's, and each figure is scoped to what it measured. You can review the rest on our Salesforce client success stories.
Conga Composer is one layer of a Salesforce estate. These pages cover the layers next to it.
The overview page: what Conga Composer is, how document generation works inside Salesforce, and where it fits in a document automation stack.
Quotes, contracts, invoices and batch automation — the implementation detail behind a Conga Composer rollout.
Where each document generation tool is the stronger fit — Composer when assembly is the requirement, Nintex when the surrounding workflow is the problem.
The real estate platform most of our transaction-document work is built on, from listings through to commission paperwork.
The wider layer documents sit inside: CRM build, integrations, automation and reporting owned end to end.
Retained admin and development support, including the Conga Composer solutions we build and the ones we inherit.
Background reading on automating contracts, proposals, invoices and reports with the wider Conga suite.
Delivery outcomes across real estate, legal, professional services and manufacturing engagements.
A full engagement covers requirements discovery, a review of your Salesforce data model, Conga Query design, template build across Word, Excel, PowerPoint or PDF, Conga Solution and button configuration, delivery and eSignature routing, testing against real records and user profiles, admin training, and deployment from sandbox to production. Smaller engagements are scoped to one part of that — most often a rescue of an existing build, or automation added to a solution that already works manually.
A focused rollout covering core document templates, Conga Queries and one or two Conga Solutions typically runs four to eight weeks. The variables that move that number are the number of genuinely distinct documents, how clean the Salesforce data model is underneath them, whether automated or batch generation is in scope, and how many people have to approve the document design. We give a phase-by-phase estimate after discovery rather than a single figure before it.
That is where a large share of our Conga work starts. Adoption usually stalls for one of three reasons: the original queries were brittle and returned the wrong related records, templates broke on edge cases so people stopped trusting the output, or only one document type was ever built. We audit the existing Solutions, Queries and templates, return written findings prioritised by risk and effort within five business days, and then rebuild what is not holding up rather than starting from an empty org.
If the requirement can be expressed as data, template logic or a Conga parameter, it is configuration: queries, merge fields, conditional sections, output format, delivery options. If it needs state, branching across several records, or a decision the merge engine cannot see, it belongs in Salesforce automation beside Composer — a Flow, or Apex where a Flow is genuinely the wrong tool. Keeping that boundary clean is what lets your own administrators maintain the solution afterwards, so we state which side of the line each requirement falls on during architecture, not during the build.
Yes. Conga Batch runs solutions on a schedule or across a set of records, and Conga Trigger runs a solution in response to Salesforce Flow. Both run in the background, which means the delivery method has to be decided in advance rather than chosen by a user at run time. The implementation work is less about switching automation on and more about the design around it: entry criteria that prevent duplicate generation, volumes the schedule can actually handle, and what happens when a run fails at two in the morning.
Composer can email the finished file, attach it to the Salesforce record, or hand it onward for signature — Conga Sign is the native option, and we also connect generated documents to DocuSign, Adobe Acrobat Sign or an existing provider. The part worth designing carefully is what happens after signature: which record the signed file returns to, what status changes, and who gets notified. That write-back is what keeps Salesforce truthful about where each agreement stands.
You do. Everything we build lives in your Salesforce org as Conga Solution, Query and template records you control, with naming standards, descriptions on every button and written documentation for the data behind each document. We train your administrators to make ordinary changes — a new clause, an added product line, a revised layout — without calling us. Where a team would rather retain us, ongoing support is available, but it should be a choice rather than a dependency the build created.
Bring one real example — a proposal, a contract, a statement — and the Salesforce record behind it. In a first call we can usually tell you whether it is a query problem, a template problem or a process problem, and what a sensible scope looks like.
Salesforce architects and Conga Composer specialists · US | Canada | UK | UAE | Australia | New Zealand