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.
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.
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.
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.
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.
| Consideration | Salesforce-native packages | Connected cloud products |
|---|---|---|
| Where it runs | Inside your Salesforce org, installed from AppExchange as managed packages. | On Formstack's platform, connected to Salesforce through an integration. |
| Where submission data lives | Collected, 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 model | Salesforce'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 creation | Direct 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 Salesforce | Dynamic 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 generation | Documents 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 consumption | Uses 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 destinations | Possible 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 prerequisites | Requires 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 when | Salesforce 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.
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.
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.
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.
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 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.
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.
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.
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.
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.
The native-versus-connected decision, taken deliberately and written down with its trade-offs so it survives the people who made it.
Mapping designed against your data model rather than against whichever object was easiest to write to.
Forms that arrive already knowing what Salesforce knows — without putting the data in a URL for anyone to edit.
Getting the form in front of the right audience, with the access model designed rather than inherited by accident.
Generation and signing that finish where they should: attached to the record, with the audit trail retained.
The part that decides whether anyone trusts the integration a year from now.
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.
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.
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.
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.
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.
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.
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.