Salesforce · Conga Composer

Conga Composer, implemented as a system rather than a button.

Most Composer deployments are a handful of buttons an admin built under deadline, and they work until the org changes. Twopir Consulting implements Composer the way it is designed to be used: solution records with a purpose, a governed template set, deliberate data sources, and output that lands back on the record. Starting with the Salesforce data model, because that is where the failures are.

The Composer Pipeline
LAUNCH Button A user decides Conga Trigger A stage change decides Conga Batch A schedule decides THE CONGA SOLUTION RECORD Data Sources The record itself Salesforce reports Conga Queries Templates Word · Excel PowerPoint · PDF Conditional content Parameters Output format Behaviour per button Background mode ONE SOLUTION · MANY LAUNCH POINTS · ONE TEMPLATE SET 2πr WHERE THE OUTPUT GOES Delivered Email with a Conga HTML template Signed Conga Sign or DocuSign routing Stored & Logged Back on the record, or the content store IF IT DOES NOT COME BACK TO THE RECORD, IT DID NOT HAPPEN
12+
Years delivering Salesforce & CRM systems
500+
Organizations served worldwide
40+
Consultants, architects & developers
250+
Platform deployments completed

Trusted by 500+ organizations — including document-heavy legal, healthcare and professional services teams generating from Salesforce every day.

LegalZoom
Bernstein Liebhard LLP
Sterling Law Offices, S.C.
Social Justice Collaborative
Magnus Health
Ideal Health Consulting

Composer Delivery Coverage

  • Salesforce Partner
  • Solution Design
  • Template Development
  • Conga Queries
  • Background Mode
  • Conga Batch
  • Conga Trigger
  • Conga Sign
Where It Goes Wrong

The merge field is empty. The template is not the problem

Almost every Composer support call starts with a template and ends somewhere underneath it. These six account for most of what we are called in to fix.

Field-level security is hiding the data

The field has a value, the template references it correctly, and the running user cannot see it. Composer merges what the user can read, so the output is silently blank rather than loudly broken.

The detail region is malformed

A repeating table that renders one row, or every row, or nothing. The TableStart and TableEnd fields are mismatched or the dataset alias does not refer to the query that supplies it.

The data was never gathered

Composer reads the launching record natively, but related data needs a report or a Conga Query to reach it. Without one, the template references a field that was never supplied.

Forty solutions that should be one

A separate solution and template per region, per product, per language. Parameters and conditional content would collapse the set, but every variant was solved by duplication instead.

Users are making choices they should never see

Every run presents template pickers and output options, and every user picks differently. Background mode exists precisely so the administrator decides once and the user just gets the document.

It was built for a hundred records

Queries that select every field on every related record are fine in a sandbox. At real volumes the button times out, and the fix is the query rather than the licence.

Anatomy

What a Composer solution is actually made of

Conga Composer generates documents from Salesforce data using templates in Word, Excel, PowerPoint and PDF, then delivers, stores or routes them for signature. The unit of configuration is the Conga Solution record — it holds the templates, the data sources and the behaviour, and a well-designed one serves many launch points. Conga's Composer documentation is the authority on the product; this is how we design with it.

The parts of a Conga Composer solution, what each one decides, and where it goes wrong
ComponentWhat it decidesWhere it goes wrong
Solution recordWhich templates run, which data is gathered, and how the output behaves.One per variant instead of one per purpose, so a change means editing dozens.
Data sourcesWhat reaches the merge: the launching record, Salesforce reports, and Conga Queries for cross-object data.Nothing gathered beyond the record, so related data is missing — or everything gathered, so it is slow.
TemplatesLayout, brand and the merge fields. Word, Excel, PowerPoint or PDF, with conditional content for variation.Duplication instead of conditions; malformed detail regions; fields referencing a dataset that is not supplied.
Buttons & parametersWhere a solution is launched from and how it behaves at that launch point.Behaviour hard-wired into extra solutions rather than expressed as parameters.
Background modeWhether the user sees the interface at all. The administrator pre-defines the output and it runs on one click.Left off, so every user picks their own options and the output stops being consistent.
Output & storageFormat, delivery, where the file lands and what gets logged against the record.Emailed and forgotten, leaving Salesforce with no evidence of what was sent.

The order we design in

Data model first, then the solution, then the template. Teams almost always start with the template, because it is the part they can see — and that is why so many Composer problems turn out to be Salesforce problems discovered late.

If the relationship you need does not exist, or the field is empty on half the records, or the running user cannot see it, no amount of template work will fix the output.

What We Deliver

Composer work that survives contact with your org

Whether this is a first deployment or a rescue of one built years ago, the work divides the same way.

Solution Architecture

One solution per purpose rather than one per variant, with the launch points, behaviour and output decided deliberately rather than accumulated.

  • Solution-per-purpose design
  • Launch point mapping across objects
  • Parameter strategy instead of duplication
  • Naming and versioning conventions
  • Consolidating an existing sprawl

Template Development

Word, Excel, PowerPoint and PDF templates built with conditional content and well-formed detail regions, so one template covers what forty used to.

  • Conditional sections and dynamic content
  • Repeating detail regions with correct aliasing
  • Brand and layout governance
  • Multi-format output from one family
  • Existing template conversion and cleanup

Data Sources & Queries

Getting the right data to the merge and nothing more. Reports where a report fits, Conga Queries where cross-object reach is needed, tuned for the volumes you actually have.

  • Report versus Conga Query selection per dataset
  • Cross-object and nested-hierarchy queries
  • Dataset aliasing wired to detail regions
  • Query tuning for large record volumes
  • Documented, commented query library

Automation: Batch & Trigger

Removing the click. Conga Trigger fires generation from Salesforce automation when conditions are met; Conga Batch produces and schedules documents in bulk.

  • Conga Trigger configuration off record events
  • Conga Batch runs and scheduling
  • Background mode so no interface appears
  • Volume and platform-limit planning
  • Deeper treatment on automation & workflow

Signature & Delivery

Conga Sign natively, or DocuSign for Salesforce where you have standardised on it — with completion coming back to the record rather than stopping at the signature platform.

  • Conga Sign configuration and routing
  • DocuSign for Salesforce integration
  • Conga HTML email templates for delivery
  • Completion events written back to the record
  • Storage destination and naming design

Audit & Optimization

For deployments that already exist. What is there, what is broken, what is duplicated, and what is slow — with a plan that keeps whatever is working.

  • Inventory of solutions, templates and queries
  • Permission and field-level security diagnosis
  • Performance profiling of slow merges
  • Consolidation plan for template sprawl
  • Documentation of what was never written down
Use Cases

What teams actually build with Composer

Four patterns that recur across every industry we work in. The product is the same; what differs is the launch point and how much data has to be gathered.

On-demand, single record

A quote, proposal, receipt or engagement letter produced from one record on a button click. Data comes from the record plus a query or two for related detail, and the PDF lands back on the record with delivery logged.

Data-heavy internal reporting

Board packs, executive summaries and period reviews assembled from many Salesforce reports into one formatted Excel or PowerPoint file. This is where Composer's ability to take multiple reports as datasets earns the licence.

Triggered at a stage change

Paperwork that should exist the moment something happens — an order confirmation when a deal closes, a welcome pack on activation. Conga Trigger fires it, background mode means nobody sees an interface.

Scheduled in bulk

Statements, renewal notices and reminders produced for a whole population on a schedule rather than one at a time. Conga Batch handles the run; the design work is the volume planning around it.

Proof

What a designed deployment changes

Case Study

Legal Document Automation

Conga Composer on Salesforce · Twopir Consulting engagement

A legal team generating client-facing documents by hand from Salesforce data, with no reliable record of which version went out. We rebuilt the document layer on Composer: a governed template set replacing ad-hoc files, Salesforce reports and queries as the single data source, and generated output written back to the matter record with its delivery logged.

The change people noticed was not speed alone — it was that the document on the record and the document the client received became the same object, which is what made the process auditable.

Read the full case study
Vendor Evidence

Why Composer is a safe long-term bet

Market position — figures reported by Conga, not Twopir client outcomes

Conga reports that more than 8,000 customers use Composer to create over 10 million documents every month, and that Composer was named the leader in the G2 2024 Grid for Salesforce CRM Document Generation, scoring highest for both market presence and customer satisfaction.

These are Conga's figures about Conga's install base. We cite them because they answer a real evaluation question — whether Composer is a durable choice for a Salesforce-native document layer — and on that question, the install base is the relevant evidence.

Conga's product page
Why Twopir

We debug Composer from the Salesforce side

We help growing and mid-market companies solve complex CRM, integration, and business system challenges, and we work with enterprise organizations facing the same problems at larger scale.

Empty merge fields are a permissions problem

More often than anything else. Composer merges what the running user can read, so field-level security, sharing and profile design are where we look first — and that is a Salesforce skill, not a Composer one.

We collapse template sprawl instead of adding to it

The instinct when a new variant appears is to copy the template. Conditional content and parameters do the same job with one artefact, and that is the difference between a set you can maintain and one you cannot.

We design for your three-year record count

Most Composer performance problems are queries written when the object held a fraction of today's data. We ask about the future number before writing the first one.

We use the configuration surface properly

Background mode, parameters, conditional content and Conga Queries cover far more than most deployments use. Reaching for code before exhausting those is how Composer builds become fragile.

We document the query library

Commented queries and named datasets, so the next person can tell what a solution gathers without reverse-engineering a template to find out.

Common Questions

Answers before the first call

In our experience the most common cause is field-level security: Composer merges what the running user is permitted to read, so a field with a perfectly good value renders blank for a user whose profile cannot see it. The next most common causes are data that was never gathered — related records need a Salesforce report or a Conga Query, since the launching record alone does not carry them — and a template field referencing a dataset alias that no query supplies. All three present identically as a blank space, which is why the template is usually the last place worth looking.

Yes, and this is where most of the real capability sits. When Composer runs from a record it gathers that record's data natively, and it can additionally take Salesforce reports and Conga Queries as data sources — which is how a document reaches related lists, cross-object data and nested hierarchies. A single solution can draw on many datasets at once, which is what makes data-heavy outputs like board packs and period summaries practical. The design question is not whether it can reach the data but selecting only what the template needs, because gathering everything is the usual cause of slow merges.

Yes — that is what background mode is for, and it is one of the most under-used settings in Composer. The administrator configures the solution with background parameters so the template choice, output format and logging behaviour are all pre-defined, and the user gets the finished document from a single click with no interface in between. Beyond saving time, it is the mechanism that makes output consistent: if every user can choose, every user eventually chooses differently, and the brand and format governance you designed stops holding.

By expressing the variation as conditions and parameters rather than as separate files. Sections that appear or disappear based on the data handle most regional, product and tier differences within one template, and parameters let the same solution behave differently depending on which button launched it. Consolidation is normally done in stages — group the near-duplicates, identify what actually differs, build one parameterised version, then retire the old set once it is proven. The benefit is not tidiness; it is that a brand or legal change becomes one edit rather than forty.

Yes, through two different mechanisms. Conga Trigger connects Composer to Salesforce automation so generation fires when conditions are met — the classic example being final paperwork produced when an opportunity is marked Closed Won. Conga Batch produces documents for many records at once and can be scheduled for a future date and time, which suits statements, renewal notices and reminders. Both need volume planning, because Salesforce API and email limits and Conga's own workflow limits all apply. We cover the design considerations on Conga automation and workflow services.

Fix, in almost every case. An old Composer deployment usually contains a great deal of accumulated knowledge about edge cases, and rebuilding discards it in exchange for an unknown set of new problems. We start with an inventory of solutions, templates and queries, establish what is sound and what is fragile, and consolidate rather than replace. The work that most often pays for itself is collapsing duplicated templates, tuning queries that have outgrown their design, and writing down what was never documented.

Start Here

Bring us the document that never merges cleanly

Whether you are deploying Composer for the first time or inherited a set of buttons nobody documented, the starting point is the same: what the document has to say, and what in your Salesforce org is stopping it.

Serving: US | Canada | UK | UAE | Australia | New Zealand