Formsite · Salesforce · Document Workflows

Formsite Consulting & Implementation Services

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.

Formsite Pipeline Architecture
CAPTURE SURFACES Embedded & Hosted Forms Website · Portal · Branded URL Secure Links Clients · Agents · Internal staff Item & Page Rules Uploads & Signature Payment Items TWOPIR FORMSITE ARCHITECTURE LAYER Form & Logic Design Rules · Calculations Validation Workflow Multi-step approval Conditional routing Results Docs PDF templates Pipe & image codes DESIGNED ONCE · GOVERNED · BUILT TO SCALE 2πr DOWNSTREAM Salesforce Standard and custom objects · Files Documents PDFs generated and delivered on submit Audit Trail Who submitted, who approved, and when CAPTURE · APPROVE · GENERATE · RECORD
12+
Years delivering CRM work
500+
Clients served
250+
Deployments delivered
40+
Consultants & engineers

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.

LegalZoom
Sotheby's
Magnus Health
Sterling Law Offices, S.C.
Ideal Health Consulting
Social Justice Collaborative

Formsite Delivery Capability

  • Salesforce Partner
  • HubSpot Partner
  • Formsite Implementation
  • Salesforce Integration
  • Workflow & Approvals
  • Results Docs & PDFs
  • Data Migration
  • Managed Support
Business Challenges

Where document and data-capture workflows break down

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.

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.

The same data is keyed two and three times

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.

Approvals live in an email thread

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.

Template sprawl nobody owns

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.

Submissions never reach the system of record

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.

No defensible audit trail

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.

Definition & Fit

What Formsite is — and where it belongs in your stack

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.

How We Engage

Implement, configure, or build on top of Formsite

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.

Formsite Implementation

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.

  • Process and requirements discovery
  • Form architecture and data model design
  • Workflow, approval and notification build
  • Results Docs PDF templates
  • Salesforce object mapping and go-live

Best for teams moving off paper, PDFs or a spreadsheet-and-email process.

Optimization & Customization

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.

  • Form and template rationalization
  • Conditional logic and calculation rebuild
  • PDF template redesign and branding
  • Integration mapping repair and validation
  • Permissions, retention and access review

Best for teams whose Formsite estate outgrew whoever originally set it up.

Build On Top

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.

  • Salesforce Flow and Apex on inbound records
  • Middleware for lookups Formsite cannot perform
  • Pre-population from Salesforce via secure links
  • Downstream document assembly and storage
  • Custom reporting across forms and CRM

Best for teams with a real requirement the platform's native feature set does not reach.

Configuration or custom development? Where the line actually sits

How common Formsite requirements are delivered, based on what the platform supports natively.
RequirementHow it is deliveredScope
Create Salesforce records from a submissionNative. 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 recordNative. Files uploaded on the form are saved into Salesforce as Files, attached to the mapped parent object.Configuration
Generate a branded PDF from the submissionNative. 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 approvalNative. 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 formNot 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 createNot 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) fieldSupported, 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 attributionThe 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.

Capabilities

What we actually build inside Formsite

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.

Form Architecture & Conditional Logic

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.

  • Item and page rules for show, hide and skip logic
  • Calculations for pricing, scoring and totals
  • Validation that rejects bad data at the point of entry
  • Reusable question structures across related forms
  • Mobile and accessibility review before launch

Workflow & Approval Routing

Multi-step processes where a submission has to be reviewed, corrected or authorized before anything downstream happens — with each step recorded rather than remembered.

  • Linked forms passing data step to step
  • Approver notifications carrying the Workflow link
  • Conditional routing so notifications fire only when they should
  • Related results viewed together as one process record
  • Escalation and reminder patterns for stalled approvals

Results Docs & PDF Generation

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.

  • Fillable-PDF templates mapped to form items
  • Custom PDF layouts built with pipe and image codes
  • Brand-accurate typography, logos and legal blocks
  • Conditional content so one template serves several cases
  • Automatic delivery as notification attachments

Salesforce Record Mapping

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.

  • Mapping to standard and custom objects
  • Multiple objects created from a single submission
  • Uploaded files attached to the mapped parent record
  • Reference field strategy for related records
  • Duplicate handling and data-quality rules in Salesforce

Signatures, Uploads & Payments

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.

  • Signature capture with submission time and IP recorded
  • DocuSign where stronger signer attribution is required
  • File uploads routed to Salesforce, Google Drive, Box or Dropbox
  • Payment items via Stripe, PayPal, Braintree or Authorize.net
  • Receipts and confirmations generated on submission

Security, Access & Retention

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.

  • Data retention rules to age out results on schedule
  • Two-factor authentication on account access
  • User roles and per-form permission boundaries
  • Encryption posture documented for security review
  • Salesforce-side field-level security and sharing rules
Integration Architecture

How Formsite connects to the rest of your stack

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.

Salesforce

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.

Salesforce Flow & Apex

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.

DocuSign

Formsite → DocuSign. For agreements needing per-signer authentication and a formal audit trail beyond the native Signature item's timestamp and IP capture.

Google Drive · Box · Dropbox · OneDrive

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.

Google Sheets & Microsoft Excel

Formsite → spreadsheet. A pragmatic landing zone for operational reporting, reconciliation and the interim period while a process is still being proven.

Stripe · PayPal · Braintree · Authorize.net

Formsite → payment gateway. Deposits, fees and prepayments taken at the point of submission, so the transaction and the paperwork complete in the same step.

Zapier

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.

Slack · Mailchimp · Constant Contact

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.

Our Approach

How a Formsite implementation actually runs

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.

Phase 01

Discovery & Current-State Assessment

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.

Phase 02

Solution Architecture

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.

Phase 03

Form, Logic & Document Design

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.

Phase 04

Integration & Automation

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.

Phase 05

Testing, Validation & Training

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.

Phase 06

Deployment, Support & Optimization

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.

Use Cases

Where Formsite earns its place

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.

Real estate transaction paperwork

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.

Client and customer onboarding

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.

Quotes, proposals and discount approval

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.

Registration and enrolment

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.

Compliance, consent and KYC capture

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.

Renewals and change requests

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.

Field and site data collection

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.

Internal request and approval workflows

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.

Business Outcomes

What changes once the pipeline is designed properly

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.

Documents produced on submission

The PDF exists the moment the form is complete, correctly populated, in the current template — instead of being assembled later by whoever has capacity.

Data entered once

The respondent types it; the document and the CRM record both inherit it. Every retype removed is an error class removed with it.

Approvals that can be answered for

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

Consistent output at volume

The hundredth document matches the first, because the template is the source rather than the last copy someone happened to open.

Salesforce that reflects reality

Enquiries, onboardings and renewals appear as records when they happen, so pipeline reporting and follow-up stop depending on manual entry.

An estate that scales without sprawl

New processes are added to a governed structure with clear ownership, instead of adding the forty-first form nobody can account for.

Proof

Capture and document work we have already delivered

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.

Case Study · Real Estate

UAE Luxury Real Estate Group

Standardising capture, compliance and contract paperwork across a multi-agency brokerage.

250+ Agents capturing client data to one standard
60 days Commission module paid for the engagement

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 study
Case Study · Registration

Student Registration Portal

A registration form estate delivered on a Force.com Site instead of a full community platform.

Multi-flow Registration paths varying by course
Save & resume Plus reCAPTCHA and site health reporting

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 study
Case Study · Documents

Salesforce & iManage Integration

Connecting document management to the CRM so filing stops being a separate job.

One step Upload from Salesforce, retrieve from anywhere
Cloud Official documents and work files stored centrally

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 story

More engagements across CRM, integration and automation are published in Twopir Consulting's success stories.

Why Twopir

A Formsite partner who knows the Salesforce side too

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.

We design the Salesforce side before the form side

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.

We tell you where the platform stops

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.

We will tell you when Formsite is the wrong tool

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.

Documents are treated as a design deliverable

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 hand over something your team can run

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.

Common Questions

Answers before the first call

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.

Next Step

Bring us the process, not just the form

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