Salesforce · Document Generation

Conga Composer consulting and implementation that holds up in production

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.

Composer Document Flow
SALESFORCE DATA SOURCES Salesforce Records Opportunity · Quote · Contract Conga Queries SOQL datasets · Related lists Reports as Datasets Global Merge Fields External Data TWOPIR COMPOSER SOLUTION LAYER Templates Word · Excel · PPT PDF output Merge Logic IF · TableGroup TableHide Automation Batch · Trigger Salesforce Flow ONE SOLUTION RECORD · VERSIONED · REGRESSION TESTED 2πr DELIVERED DOCUMENTS Stored on Record Salesforce Files, attached where it belongs Delivered by Email Merged Conga email templates, per recipient Sent for Signature Conga Sign, DocuSign or Adobe Acrobat Sign GENERATE · DELIVER · SIGN · STORE
4–8
Weeks · focused Composer rollout
5
Business days · written audit findings
12+
Years of Salesforce delivery
500+
Organizations served

Trusted by 500+ organizations — including document-heavy teams in real estate, legal, professional services and manufacturing running their operations on Salesforce with Twopir Consulting.

Sotheby's
Mitratech
Ultra Consultants
CitroTech
Kacific

Built for Salesforce Document Automation

  • Salesforce Partner
  • Conga Composer
  • Conga Batch & Trigger
  • Conga Sign
  • Template Engineering
  • SOQL & Query Design
  • CPQ & Quoting
  • Contract Workflows
Where Document Work Breaks

The document problem is almost never a template problem

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.

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.

Template sprawl and silent version drift

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.

Re-keyed data puts errors in front of clients

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.

Quote and contract turnaround measured in days

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.

Approval, delivery and signature are manual relays

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.

One record at a time, with no way to run at volume

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.

Composer is licensed, but barely used

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.

Nobody owns the solution after go-live

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.

What It Is

Conga Composer, and the part an implementation has to add

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.

Where the product ends and the implementation begins
LayerWhat Conga Composer providesWhat the implementation has to add
DataA 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.
TemplatesWord, 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.
LaunchButtons, 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.
AutomationConga 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.
DeliveryDownload, 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.
SecurityEnforcement 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.
OwnershipConfiguration 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 Ways In

Implement it, fix it, or build well beyond it

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.

Conga Composer Implementation

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.

  • Requirements and current-state document audit
  • Data model review and Conga Query design
  • Template build across Word, Excel, PowerPoint and PDF
  • Conga Solution records, buttons and launch points
  • Delivery, storage and eSignature routing
  • Admin enablement and handover documentation

Optimization & Rescue

You already own Composer and it is underused, brittle or actively avoided. We audit what exists, keep what works, and rebuild what does not.

  • Review of existing Solutions, Queries and templates
  • Written findings, prioritised by risk and effort
  • Query rewrites for missing or duplicated related data
  • Template repair for the edge cases that break output
  • Performance work on slow or timing-out solutions
  • Adoption fixes: fewer clicks, clearer buttons, real training

Custom Build on Top of Composer

Where configuration runs out. Composer stays the generation engine; we build the Salesforce logic, automation and integrations around it.

  • Flow and Apex orchestration around generation events
  • Conga Trigger and Conga Batch automation design
  • Custom approval, routing and write-back logic
  • Integrations with CPQ, billing, storage and ERP systems
  • Document packages assembled from several sources
  • Multi-entity, multi-currency and multi-language output

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.

Capabilities

What we configure, build and hand over working

Every item below is real Conga Composer configuration or real Salesforce work around it — not a feature list copied from a vendor brochure.

Conga Query & Data Design

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.

Template Design & Build

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.

Solutions, Buttons & Parameters

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.

Batch & Background Automation

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.

Delivery & Email Merge

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.

eSignature Routing

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.

Permissions & Access Model

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.

Testing, Deployment & Support

Edge-case test sets, sandbox-to-production deployment of solutions and templates, documented naming standards, and ongoing support as products, pricing and clauses change.

Use Cases

What teams actually generate with Conga Composer

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.

Common Conga Composer document workflows and what each one depends on
DocumentWho runs itTypical Salesforce sourceWhat makes it non-trivial
Proposals & quotesSales, sales operationsOpportunity with products, or Quote with line itemsGrouped and conditional line items, discount and tax logic, sections that hide when empty
Contracts & agreementsLegal, revenue operationsOpportunity, Contract or a custom agreement objectClause selection driven by deal attributes, version control, routing to signature and back
Real estate transaction packetsBrokerage and transaction teamsListing, deal and contact records across related objectsSeveral documents assembled as one package, jurisdiction-specific forms, agent and commission data
Invoices & statementsFinance, billingBilling or invoice records with related transactionsMulti-entity and multi-currency presentation, tax treatment, scheduled batch runs at period end
Client onboarding packsCustomer success, operationsAccount with contacts, products and service recordsOne trigger producing several documents, each delivered to a different recipient
Renewal noticesAccount managementSubscription, asset or contract recordsScheduled generation ahead of a date, uplift calculations, suppression rules for accounts in dispute
Board and executive reportsLeadership, operationsSeveral Salesforce reports or queries as datasetsMany datasets in one output, Excel formula templates, consistent period-over-period formatting
Batch client communicationsMarketing, operations, member servicesA filtered report of the target recordsVolume, 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.

Architecture

The Salesforce decisions that determine whether it scales

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.

Data Model & Relationships

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.

  • Master record selection: where generation belongs
  • Lookup, master-detail and junction object paths
  • Related-list depth and record-count expectations
  • Fields that should be formulas, not merge-time logic
  • Where a missing relationship needs building first

Query & Dataset Strategy

Datasets are where most solutions quietly fail. Getting them right is the difference between one clean query and eight overlapping ones nobody dares touch.

  • One tuned query per dataset, not per symptom
  • Filtering at the query, never inside the template
  • Sort, group and aggregate decisions made up front
  • Record ID selection for every object in the SELECT
  • Reports as datasets where a report is genuinely better

Automation & Flow Design

Automated generation is an orchestration problem. The question is not whether Flow can call it, but what happens on the unhappy path.

  • Entry criteria that prevent duplicate generation
  • Conga Trigger configuration driven by Salesforce Flow
  • Background-mode delivery defined before go-live
  • Failure handling, retries and operational alerting
  • Batch scheduling sized to real record volumes

Security, Sharing & Permissions

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.

  • Object and field-level read access per profile
  • Permission sets and connected-app enablement
  • Visualforce page access for Composer buttons
  • Sharing rules that affect what a query returns
  • Output tested against every role that will run it

Integration Surface

Documents rarely end their life in Salesforce. We design where the file goes, what the receiving system needs, and how status flows back.

  • eSignature providers and signed-document return
  • Storage in Salesforce Files or an external repository
  • CPQ, billing and ERP data feeding the merge
  • Status write-back so the record stays truthful
  • Middleware only where a direct path is genuinely worse

Data Quality, Testing & Deployment

A merge field is an honest mirror. Blank output on a live quote is almost always a data problem the document just made visible.

  • Required-field and data-completeness review up front
  • Edge-case test set: empty, maximum and unusual records
  • Sandbox build with a controlled promotion path
  • Naming and description standards on every solution
  • Change process so admins can edit without fear
How We Deliver

Six phases from first conversation to a solution you own

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.

Phase 01

Discovery & Current-State Assessment

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 assessment
Phase 02

Solution Architecture & Data Mapping

We 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 design
Phase 03

Configuration & Template Build

Conga 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 design
Phase 04

Integration, Automation & Customization

Generation 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 · Customization
Phase 05

Testing, Validation & Enablement

We 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 training
Phase 06

Deployment, Support & Optimization

Solutions 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 & optimization
Business Outcomes

What changes once the documents look after themselves

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

Documents in minutes, not afternoons Generation moves from a person assembling a file to a button or an automated event. Measure it as time from "terms agreed" to "document sent".
Fewer errors reaching a client Values come from the record instead of a keyboard. Measure it as the count of documents reissued because something was wrong the first time.
One current version of every document Templates live in one place with an owner and a change process. Measure it as the number of local copies still in circulation after ninety days.
Volume stops being a constraint Batch and scheduled runs make nine hundred statements the same amount of work as nine. Measure it as the hours period-end used to consume.
Better Salesforce adoption, not just better documents When the record produces the paperwork, keeping the record accurate stops being administrative overhead and starts being self-interest.
Changes your own team can make A clause update or a new product line becomes an ordinary admin task. Measure it as how long it takes you to change a document without calling us.
Why Twopir

Salesforce architects who also build the documents

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.

We fix the data layer, not just the document

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.

We are specific about what is configuration and what is code

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.

We take on the implementations other people left behind

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.

We build for the admin who inherits it

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 work with growing and mid-market companies

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.

Proof

Document-heavy operations we have rebuilt

Contracts that took days, commission paperwork tracked in spreadsheets, billing spread across systems. Each figure below is scoped to the engagement that produced it.

Case Study · Real Estate

UAE Luxury Real Estate Conglomerate

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.

250+ Agents on one platform
3 Delivery phases
1 System for AML/KYC, contracts & commission
Read the real estate case study
Case Study · Billing Operations

Accounting Seed & Salesforce Integration

Mass billing and matter management automated inside Salesforce, with third-party systems integrated so administration and invoicing stopped being manual work.

50% Increase in operational efficiency
45% Productivity gains from automation
35% Faster lead qualification & conversion
Read the integration story

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.

Common Questions

Conga Composer consulting, answered before the first call

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.

Next Step

Tell us which document is costing you the most time, and we will show you the build

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