Documents are rebuilt by hand, every time
Someone opens last month's agreement, saves a copy, and edits the names and numbers. It works until the template changes, until a clause is missed, or until the person who knew the drill is on leave.
Most teams buy Formsite to replace a PDF and end up with forty forms nobody owns. We treat it as what it actually is — the capture, approval and document layer in front of your CRM. Twopir Consulting designs the form architecture, builds the approval workflows, generates the PDFs, and maps every submission into the right Salesforce objects. Capture, approve, generate, record — one designed pipeline.
Trusted by 500+ organizations — including real estate, legal, healthcare and professional-services teams running data capture, approvals and document workflows on Salesforce with Twopir Consulting.










Formsite Delivery Capability
Almost every organization that comes to us for Formsite help has the same underlying issue: the information needed to produce a document is collected in one place, the document is built in another, and the system of record finds out last. The cost is not the typing. It is the rework, the delay and the disputes.
Someone opens last month's agreement, saves a copy, and edits the names and numbers. It works until the template changes, until a clause is missed, or until the person who knew the drill is on leave.
A client fills in a form, an administrator re-types it into a document, and someone else re-types it into the CRM. Each retype is a chance to introduce an error nobody catches until a customer does.
A proposal needs a manager's sign-off and a discount needs finance. Both happen by email, so nobody can answer "where is it now?" without asking around, and there is no record of who approved what.
Forty forms and a dozen document layouts accumulate across departments. Several are near-duplicates, two are legally out of date, and no one can say which is current — because no one was ever made responsible.
Responses sit in a form tool's own results table. Salesforce has no idea the enquiry, the renewal or the onboarding pack exists, so pipeline reporting is wrong and follow-up depends on someone remembering.
When a regulator, an auditor or a client asks who submitted what and who signed off, the answer has to be reconstructed from inboxes and shared drives — which is slow, expensive and rarely complete.
Formsite is an online form and survey platform that collects structured data, routes it through multi-step approval workflows, turns each submission into a formatted PDF, and writes the result into connected systems including Salesforce. It is built and operated by Formsite, and it is listed on the Salesforce AppExchange. Its documentation is published at Formsite Support.
That definition matters, because Formsite is often shortlisted next to Salesforce-native document generation tools — and they solve different problems. Formsite produces a document from a submission: someone fills in a form, and the answers populate a PDF. A native docgen application produces a document from a record that already exists in Salesforce. If your starting point is data you still need to collect — from a client, a tenant, an applicant, a field team, a counterparty — Formsite is the right shape of tool. If your starting point is a closed Opportunity that already holds every value the contract needs, it is not, and we will tell you so on the first call rather than three weeks into a build.
Formsite is usually the right fit for growing and mid-market companies that need a governed capture-and-approval layer in front of the CRM without building a customer portal to get it. We work with growing, mid-market, and enterprise organizations that need help with complex CRM implementations, integrations, and business system challenges — and in Formsite engagements the decisive question is almost always the same: does this process begin with information you do not have yet? If it does, this is the layer to design properly.
These are three separate engagements with different scopes, timelines and buyers. Most teams need one of them, not all three — and knowing which one you need is the fastest way to a sensible quote.
You have bought Formsite, or you are about to, and you need it stood up properly the first time — designed around your process rather than assembled form by form.
Best for teams moving off paper, PDFs or a spreadsheet-and-email process.
Formsite is already live, but it has grown without governance. Forms duplicate, logic contradicts itself, PDFs render badly, and the Salesforce mapping has drifted from the data model.
Best for teams whose Formsite estate outgrew whoever originally set it up.
The requirement runs past what the platform does natively. This is engineering work around Formsite — and it is where we are explicit about what is configuration and what is custom development.
Best for teams with a real requirement the platform's native feature set does not reach.
| Requirement | How it is delivered | Scope |
|---|---|---|
| Create Salesforce records from a submission | Native. The integration writes to standard and custom objects, and a single form can create records in more than one object. | Configuration |
| Attach an uploaded file to the Salesforce record | Native. Files uploaded on the form are saved into Salesforce as Files, attached to the mapped parent object. | Configuration |
| Generate a branded PDF from the submission | Native. Built-in table format, an uploaded fillable-PDF template, or the Custom PDF editor using pipe codes and image codes. | Configuration |
| Route a submission through multi-step approval | Native. Workflow links two or more forms, passing data forward, with the next step delivered as a Workflow link by notification email. | Configuration |
| Look up an existing Salesforce record from the form | Not native. The integration sends new records and updates ones it created; it cannot retrieve existing records. We pre-populate through the launch link instead, or build a middleware lookup. | Custom |
| Update a Salesforce record the form did not create | Not native, for the same reason. Handled downstream in Salesforce — the submission lands as a record, and Flow or Apex applies it to the target record. | Custom |
| Populate a reference (lookup) field | Supported, but it needs the related record's Salesforce ID to be present on the submission — which is a design decision made before the form is built, not after. | Design |
| Signatures with full legal attribution | The native Signature item captures a drawn signature with submission time and IP address. Where stronger per-signer attribution is required, we integrate DocuSign. | Design |
Formsite's Salesforce integration requires API access, so the connected Salesforce org needs a Professional, Enterprise, Unlimited or Developer edition. Confirming this early avoids the most common late-stage surprise in a Formsite project.
Formsite ships a large feature set. Only some of it matters to any given process. These are the capabilities that carry the weight in the engagements we run.
The structural work that decides whether a form estate stays maintainable: what is one form versus several, which questions are shared, and how rules keep each respondent on the shortest valid path.
Multi-step processes where a submission has to be reviewed, corrected or authorized before anything downstream happens — with each step recorded rather than remembered.
Turning a submission into a document someone is willing to sign or file. This is where most self-built Formsite estates fall short, and where careful template work shows immediately.
The integration layer, designed against your data model rather than bolted on afterwards — so a submission creates the right records, on the right objects, with the right relationships intact.
The items that let a form finish a transaction instead of starting a phone call — collected once, attached to the record, and carried into the generated document.
The governance layer that decides whether this passes an audit. Formsite provides the controls; the work is configuring them to your policy and proving they hold.
Every connection below is stated with its direction of travel, because that is the detail that decides an architecture. Formsite pushes; it does not generally pull. Designing around that fact — rather than discovering it in week three — is most of the job.
Formsite → Salesforce. Submissions create records on standard and custom objects, with uploaded files attached to the mapped parent. Editing a result updates the record it created. Requires API access on the Salesforce org.
Inside Salesforce. Everything the integration deliberately cannot do — matching to existing records, updating a parent, assignment, escalation — runs downstream on the record once it lands. This is where most custom work belongs.
Formsite → DocuSign. For agreements needing per-signer authentication and a formal audit trail beyond the native Signature item's timestamp and IP capture.
Formsite → storage. Generated PDFs and uploaded attachments filed automatically into the document repository your teams already work in, rather than left in a results table.
Formsite → spreadsheet. A pragmatic landing zone for operational reporting, reconciliation and the interim period while a process is still being proven.
Formsite → payment gateway. Deposits, fees and prepayments taken at the point of submission, so the transaction and the paperwork complete in the same step.
Formsite → anywhere. The route to systems without a first-party connector — including HubSpot. Useful for low-volume, non-critical paths; we recommend a direct integration where the process is business-critical.
Formsite → notification and marketing. Alerting the team that owns the next step, and adding consenting respondents to the right marketing audience without a manual export.
Six phases, one continuous engagement. A focused single-process build typically runs four to six weeks; a multi-department rollout with several document templates and a custom Salesforce data model runs longer. We scope it honestly before you commit.
We walk the process as it runs today — who fills what in, who checks it, where it waits, and what the document has to say at the end. We also inventory the existing form and template estate, because the first real decision is usually how many of them should survive.
We decide what each submission becomes in Salesforce before designing a single form. Which objects, which relationships, which fields are authoritative. Getting this wrong is the most expensive mistake in a Formsite project, because the mapping is built on top of it and every template inherits it.
The build phase inside Formsite: question structure, conditional rules, calculations and validation, then the Results Docs templates that turn a submission into a document your brand and legal teams will sign off on. Forms and documents are designed together — a field nobody collects cannot appear in a PDF.
We connect the form to Salesforce, map every item to its target field, and build the downstream automation — Flow or Apex — that does the work the integration is not designed to do. Approval workflows, notifications and routing are configured and tested against real approvers, not placeholders.
We test every conditional path, not just the happy one: partial submissions, rejected approvals, edge-case values, and what the PDF does when an optional section is empty. Then we train the people who will own it — including whoever will build the next form after we leave.
A controlled launch, usually running parallel with the old process until volume proves out. After go-live we monitor completion and drop-off, tune the forms people actually struggle with, and extend the estate under governance as new processes come in.
The pattern is consistent: a process that starts with information you do not yet hold, needs a check before it proceeds, and ends in a document plus a record.
Listing agreements, buyer representation forms, offer submissions and disclosure packs collected from agents and clients, generated as branded PDFs, and landed against the property and contact records in Salesforce — so transaction status is visible without chasing an agent.
One governed intake that collects details, consents, documents and a signature in a single pass, creates the account and contact records, and produces the onboarding pack automatically — replacing a welcome email with six attachments.
A rep submits the requirement, calculations price it, conditional routing sends anything past threshold to the approver, and the approved version generates as a proposal PDF with the opportunity updated behind it.
Course, event and programme registration where the questions change by option chosen — the case where a form platform is the right answer and a full customer portal is over-built for the requirement.
Regulated data collection where the value is the audit trail: what was asked, what was answered, what was uploaded, who reviewed it and when — held against the client record instead of in a filing cabinet.
Recurring paperwork sent out on a schedule with a pre-populated launch link, returned as a structured submission, routed for approval where terms changed, and reflected on the contract record.
Inspections, surveys and job sheets completed on a phone, with photo uploads attached to the record and a completion report generated for the client before the team leaves site.
Purchase requests, access requests, expense claims and HR paperwork — the internal processes that quietly consume administrative time and produce no record anyone can report on.
The gains depend on your volumes and starting point, so we scope them against your process rather than quote a percentage. These are the changes that show up consistently.
The PDF exists the moment the form is complete, correctly populated, in the current template — instead of being assembled later by whoever has capacity.
The respondent types it; the document and the CRM record both inherit it. Every retype removed is an error class removed with it.
"Where is it?" becomes a lookup rather than a phone call, and "who approved this?" has an answer that does not depend on an inbox.
The hundredth document matches the first, because the template is the source rather than the last copy someone happened to open.
Enquiries, onboardings and renewals appear as records when they happen, so pipeline reporting and follow-up stop depending on manual entry.
New processes are added to a governed structure with clear ownership, instead of adding the forty-first form nobody can account for.
These engagements were built on Salesforce rather than on Formsite, and we present them as what they are. They are the reason we are credible on this work: the same problems — capture, approval, document output, audit trail — solved under real operational load.
Standardising capture, compliance and contract paperwork across a multi-agency brokerage.
Enquiries arrived from portals, WhatsApp and email and were routed by hand; contracts took days and compliance checks were filed manually. Every AML and KYC check now carries a timestamped audit trail linked to the client record.
Read the real estate case studyA registration form estate delivered on a Force.com Site instead of a full community platform.
The client needed a registration form, not a community licence — exactly the decision a Formsite evaluation turns on. We scoped to the requirement and built branded, multi-flow registration with save-for-later.
Read the registration case studyConnecting document management to the CRM so filing stops being a separate job.
The same architectural principle a Formsite build depends on: the document and the record belong together, and the moment they are filed separately someone has to reconcile them later.
Read the document integration storyMore engagements across CRM, integration and automation are published in Twopir Consulting's success stories.
Most Formsite problems are not Formsite problems. They are data model problems, process problems, or ownership problems that show up as a form nobody trusts.
A form built before the data model is settled produces records that need cleaning up forever. We decide what a submission becomes in Salesforce first, then build the form that produces it.
Formsite pushes records; it does not retrieve existing ones. We put that on the table in discovery, along with what it means for your requirement — rather than absorbing it into a change request later.
If your documents should be generated from records that already exist in Salesforce, a native document generation application fits better. Saying so costs us a project and saves you a rebuild.
A PDF that a client signs is a brand and legal artifact, not a data dump. We build templates to that standard, and we test what they do when optional content is missing.
We train the people who will build the next form, document the mapping, and set the governance rules — so the estate stays coherent after we leave instead of sprawling again.
The parent engagement. Formsite sits in front of Salesforce — if the CRM itself needs design work, start here.
Connecting Salesforce to the systems around it, including the middleware work that sits behind a Formsite lookup requirement.
The comparable engagement on Formstack, for teams evaluating both platforms before committing.
Industry context for proposal, engagement and client onboarding paperwork on Salesforce.
Intake, matter and document workflows for legal teams — the most document-intensive version of this problem.
Managed support after go-live, covering the Formsite estate and the Salesforce automation behind it.
A Formsite consultant designs the process the forms serve, not just the forms. That means deciding what each submission should become in your system of record, structuring the form estate so it stays maintainable, building the conditional logic and approval workflows, designing the PDF templates, mapping everything into Salesforce, and testing the paths that are not the happy path. Building a form is the quick part; deciding what it should collect and where the answers belong is the work.
Formsite's Salesforce integration sends form submissions into Salesforce as records. It works with standard and custom objects, a single form can create records in more than one object, and files uploaded on the form can be saved into Salesforce as Files attached to the mapped parent record. Editing a result in Formsite also updates the record it created. The integration requires Salesforce API access, so the org needs a Professional, Enterprise, Unlimited or Developer edition.
Not directly. The integration sends new records and can update records it created, but it cannot retrieve or delete existing Salesforce records. This is the single most important constraint to design around. In practice we solve it one of two ways: pre-populate the form through its launch link so the relevant identifiers travel with the request, or let the submission land as a record and handle the matching and updating downstream in Salesforce with Flow or Apex. Both work well — but they have to be chosen deliberately, at architecture stage.
Yes. Formsite's Results Docs feature turns each submission into a PDF using one of three approaches: a built-in table format, a fillable PDF template you upload and map to form items, or a custom template built in Formsite's own PDF editor using pipe codes to insert answers and image codes to insert uploaded images. Generated PDFs can be attached to notification emails or saved to connected storage such as Google Drive. The quality of the result depends almost entirely on the template work, which is where we spend the time.
They solve different problems and are often complementary. Formsite generates a document from a submission — it is the right choice when the process starts with information you still need to collect from a client, applicant, agent or counterparty, and when that information needs checking or approving on the way through. A Salesforce-native document generation application generates from records that already exist in the CRM, which suits contracts and quotes assembled from a closed opportunity. If your requirement is genuinely the second one, we will say so.
A focused implementation covering one process — a single form set, one or two document templates and a straightforward Salesforce mapping — typically runs four to six weeks including testing and training. A multi-department rollout with several document templates, approval routing across teams and custom Salesforce development takes longer, and the variable is almost never the form building. It is the number of approvals the process needs and how settled your Salesforce data model is when we start.
Yes, and it is a common starting point. The usual pattern is an estate that grew form by form without an owner: near-duplicates, contradictory logic, PDF templates that break on edge cases, and a Salesforce mapping that no longer matches the data model. We start with an assessment that inventories what exists and what each form is actually used for, then rationalize and rebuild against a proper architecture — usually keeping far fewer forms than clients expect.
Tell us what gets collected, who has to approve it, what document comes out at the end and where the record needs to land. We will tell you what Formsite configuration covers, what needs building around it, and what it takes to deliver — before you commit to anything.
Speak with a team that understands forms, documents, Salesforce & the architecture between them