Formstack Salesforce Integration

Native or Connected Is the Decision Everything Else Inherits

Formstack integrates with Salesforce in two fundamentally different ways: through Salesforce-native managed packages that run inside your org, or through cloud products that connect to it from outside. The two differ in where data lives, how records are created, what governs access and how much API capacity they consume. Twopir Consulting makes that decision explicitly, then builds the mapping, prefill, portal publishing and document generation on top of it.

Salesforce Integration Model
CAPTURE SURFACES & SYSTEM OF RECORD Formstack Forms Native package or cloud + connector Salesforce System of record · Security model Experience Cloud Public Web Pages Lightning Pages TWOPIR INTEGRATION LAYER Object & Field Mapping Primary & child objects Record types · Dedupe Prefill & Identity Dynamic Prefill Access & sharing Documents & Sign Merge · Delivery Signature routing DESIGNED AROUND API BUDGET AND GOVERNOR LIMITS 2πr RESULT IN SALESFORCE Right Records Correct object, record type and relationships Files on Record Generated and signed documents where they belong Reportable Process Cycle time and drop-off in native Salesforce reports PREFILL · CAPTURE · MAP · GENERATE · SIGN · ATTACH · REPORT
Definition

How Does Formstack Integrate With Salesforce?

Formstack integrates with Salesforce in two ways, and they are architecturally different rather than two settings of the same thing. Forms for Salesforce and Documents for Salesforce are managed packages installed from AppExchange that run inside your Salesforce org; data is collected, processed and stored there, under Salesforce's own security and compliance model. Formstack's cloud products — Formstack Forms, Formstack Documents and Formstack Sign — run on Formstack's platform and connect to Salesforce through integrations, so data travels out to Formstack and results come back.

Both are legitimate. Which one is correct for you depends on whether Salesforce is the definitive system of record for the process, whether the same capture has to serve systems outside Salesforce, which capabilities each model actually carries, and how much Salesforce API capacity the integration will consume. Twopir Consulting makes that call as a documented architectural decision and then builds the mapping, prefill, publishing and document routing on top of it.

Packages Formstack (native form builder) and Formstack Documents are separate AppExchange managed packages. Each is installed independently — installing one does not install the other.
Data residency Native: submissions are created and stored in your Salesforce org. Connected: data is processed on Formstack's platform, which Formstack hosts on AWS in the United States, then synced back.
API consumption Formstack documents a minimum of two API calls per form submission — one to authenticate against the org and one to create the primary object record — with additional calls for dependent fields and related objects.
Prerequisite Forms for Salesforce requires API access on the org. That is generally present in Enterprise, Unlimited and the industry clouds, and needs explicit confirmation on Group and Professional editions.

Verify limits against current documentation. Package capabilities, edition prerequisites and published limits change with each Formstack and Salesforce release — for example, compatibility with a new Salesforce seasonal release arrives through a Formstack package update. Every technical figure on this page reflects Formstack's published documentation as reviewed for this build. Confirm the current values for your plan, your edition and your installed package version before designing against them.

The Architectural Decision

Salesforce-Native Packages vs Connected Cloud Products

This is the comparison most Formstack and Salesforce projects skip, and the one that causes the most expensive rework when it is skipped. Read the last row first: it is the question that usually settles it.

Formstack deployment models for Salesforce
ConsiderationSalesforce-native packagesConnected cloud products
Where it runsInside your Salesforce org, installed from AppExchange as managed packages.On Formstack's platform, connected to Salesforce through an integration.
Where submission data livesCollected, processed and stored in Salesforce. Data does not leave the org to be captured.Captured and stored on Formstack's platform, then synced into Salesforce.
Security modelSalesforce's own — profiles, permission sets, sharing rules, field-level security and your existing compliance posture.Formstack's platform controls, plus whatever the integration user's Salesforce permissions allow.
Record creationDirect creation and update against any standard or custom object, including related child objects.Created through the integration; depth of relationship handling depends on how the connection is configured.
Prefill from SalesforceDynamic Prefill pulls live record data at render time rather than passing values in the URL, and can be driven from Flow or an Experience Cloud record list.Possible, but typically depends on passing parameters in, which is a weaker position for sensitive data.
Document generationDocuments for Salesforce merges from Salesforce data natively and attaches output to records, with report-driven and high-volume batch generation.Formstack Documents merges on Formstack's platform; Salesforce data travels out and the finished file comes back.
Salesforce API consumptionUses org API capacity per submission — a real budget line at volume, and something to size deliberately.Uses API capacity through the integration, with the pattern depending on sync design and batching.
Non-Salesforce destinationsPossible but not the model's strength; Salesforce is assumed to be the centre.Strong. One form can route to several systems, which is often the whole reason to choose it.
Edition prerequisitesRequires org API access; some publishing and prefill capabilities depend on features not present in every edition.Fewer Salesforce-side prerequisites, but adds a data-transfer relationship to assess.
Choose it whenSalesforce is the definitive system of record, data residency inside the org matters, and the process lives in Salesforce.The same capture must serve several systems, or you need cloud-only capabilities Salesforce-native does not carry.

Capability boundaries move between package releases. Treat this table as the shape of the decision, and confirm the specifics for your installed version before committing a design.

Failure Modes

Where Formstack and Salesforce Actually Come Apart

The integration is rarely what breaks. What breaks is an assumption made about Salesforce during the form build — and every one of these is cheaper to prevent than to unpick.

Duplicates Created on Every Submission

No matching key was defined, so a returning customer becomes a second Contact. The CRM quietly degrades, reporting drifts, and by the time anyone notices there are thousands of records to merge.

Data Lands on the Wrong Object

Everything is written to Lead because Lead was easiest. Six months later operations need it on a custom object with its own record types and lifecycle, and the migration is harder than the original build would have been.

API Consumption Nobody Budgeted For

Each submission consumes API calls — at minimum one to authenticate and one to create the primary record, with more for dependent fields and related objects. At volume that is a capacity decision, and it is usually discovered as an outage instead.

Prefill That Exposes More Than Intended

Prefill built by passing values in a URL is convenient and leaks. Any recipient can alter the parameters. Where the data is sensitive, prefill needs to resolve server-side against the record and be governed by the same sharing model as the rest of the org.

Validation Rules Rejecting Submissions Silently

A required field, a validation rule or a trigger on the target object rejects the write. The form told the user it succeeded. Nobody finds out until someone reconciles counts — which on most orgs is never.

Documents That Do Not Land on the Record

A file generated off-platform has to be delivered back and attached deliberately. When that step is missing, the executed contract lives in an inbox or a storage folder and the Salesforce record — the thing your team actually looks at — has no evidence of it.

Portal Forms Built Without an Access Model

A form published to an Experience Cloud site inherits that site's guest or authenticated user configuration. If sharing, object permissions and field-level security were not designed for that user, the form either fails or shows too much.

No Reconciliation Between the Two Sides

Nobody compares submissions received against records created. Without that check, a partial failure is indistinguishable from a quiet week, and the first real signal is a customer asking why nobody responded.

What We Build

Six Areas of Formstack and Salesforce Work

Deployment Architecture

The native-versus-connected decision, taken deliberately and written down with its trade-offs so it survives the people who made it.

  • Model selection against data residency and process scope
  • Package installation, configuration and version strategy
  • Edition and API prerequisite verification
  • Environment and sandbox strategy
  • Decision record with revisit criteria

Object & Field Mapping

Mapping designed against your data model rather than against whichever object was easiest to write to.

  • Primary and child object mapping, including custom objects
  • Record type and picklist alignment
  • Matching keys, upsert behaviour and duplicate prevention
  • Validation rule and trigger interaction review
  • Field-level security and profile access checks

Prefill & Progressive Capture

Forms that arrive already knowing what Salesforce knows — without putting the data in a URL for anyone to edit.

  • Dynamic Prefill configuration at object level
  • Prefill links generated from Flow for outbound journeys
  • Experience Cloud record-list driven prefill
  • Dependent field and conditional prefill behaviour
  • Access review so prefill cannot over-share

Portal & Publishing Surfaces

Getting the form in front of the right audience, with the access model designed rather than inherited by accident.

  • Experience Cloud publishing via the Formstack Lightning component
  • Internal Lightning page and record-page embedding
  • Public web publishing and embed patterns
  • Guest versus authenticated user access design
  • Branding and theming aligned to the portal

Documents & Signature in Salesforce

Generation and signing that finish where they should: attached to the record, with the audit trail retained.

  • Documents for Salesforce template and merge mapping
  • Generation triggered by button, Flow or form submission
  • Report-driven and high-volume batch generation
  • Formstack Sign routing with roles and reminders
  • Delivery back to the record, with retention rules applied

Reliability & Reporting

The part that decides whether anyone trusts the integration a year from now.

  • API consumption modelling against org capacity
  • Failure handling, alerting and retry design
  • Reconciliation between submissions and records created
  • Process reporting built on Salesforce-native reports
  • Runbooks for the known failure cases
How We Deliver

From Org Review to a Reconciled Integration

Step 01

Org & Process Review

We look at the target objects, record types, validation rules, triggers and sharing model before deciding anything about the form. Existing API consumption and edition entitlements are established here, not assumed.

Step 02

Deployment Decision

Native or connected, decided against data residency, process scope, required capabilities and API budget — and recorded with the reasoning and the conditions under which it should be revisited.

Step 03

Mapping & Prefill Design

Field-by-field mapping including child objects, matching keys and duplicate behaviour, plus the prefill approach and the access model that governs it. Reviewed with your Salesforce admin before build.

Step 04

Build & Failure-Path Testing

Configuration in a sandbox, then testing that deliberately provokes the failure cases: rejected writes, duplicate submissions, missing required data, unavailable endpoints. A build only passes when its failures behave predictably.

Step 05

Launch & Reconcile

Deployment with a rollback position, then a reconciliation check comparing submissions received against records created and documents attached — run as a standing report rather than a one-off spot check.

Common Questions

Answers Before the First Call

Partly, and the distinction matters. Formstack offers Salesforce-native managed packages — Forms for Salesforce and Documents for Salesforce — that install from AppExchange and run inside your org, collecting and storing data under Salesforce's own security model. It also offers cloud products that run on Formstack's own platform and connect to Salesforce through integrations. Saying "Formstack is native" without specifying which products you mean is the ambiguity that causes most of the architecture mistakes we are called in to fix.

It depends entirely on the deployment model, which is why the decision matters. With the Salesforce-native packages, data is collected, processed and stored inside your org — it does not have to leave it to be captured. With the connected cloud products, data is captured on Formstack's platform, which Formstack hosts on AWS in the United States, and then synced into Salesforce. If your data residency, privacy or sector obligations restrict where personal data may be processed, this is the first question to settle, before any form is designed.

Formstack documents a minimum of two calls per submission for Forms for Salesforce — one to authenticate against your org and one to create the primary object record — with additional calls triggered by options such as dependent fields and related objects. The practical consequence is that a high-volume public form is a capacity decision, not just a design decision. We model expected consumption against your org's allocation during design, and where the number is uncomfortable we look at batching, at reducing related-object writes, or at whether that particular capture belongs in the connected model instead.

Yes. Formstack provides a Lightning component that you drag into the Experience Builder and point at the form, which places it on the site without custom code. The work that actually needs attention is the access model underneath it: an Experience Cloud form runs as the site's guest or authenticated user, so object permissions, field-level security and sharing have to be designed for that user rather than inherited from an internal profile. Prefill in a portal context can also be driven from a record list component, which is a cleaner pattern than passing identifiers in a URL.

Yes. Documents for Salesforce can merge from Salesforce data and be triggered from a button on an object, from Flow, or from a form submission. It can also generate from a Salesforce report — producing a document per row and optionally combining them into a single file — and it offers a high-volume generation capability that uses Salesforce's Batch Apex framework so large runs stay inside platform governor limits. Output can be attached back to the originating record, sent to storage, or routed onward for signature.

That is the most common reason we are engaged on this specific work. The first step is reconciliation: compare submissions received against records created and documents attached over a defined period. That single check usually separates "the integration is broken" from "the integration works and the mapping is wrong", and the two need very different responses. From there we produce a findings list ranked by data risk, and remediate in that order rather than rebuilding first.

Next Step

Settle the Architecture Before You Build the Next Form

Tell us which objects the process should write to, roughly what volume it carries and whether anything outside Salesforce needs the same data. That is usually enough for us to tell you which deployment model you should be on and what it would take to get there.

Delivered by a Salesforce Gold Partner. We implement and support Formstack independently and do not resell Formstack licences.