Submissions never reach the CRM
Cognito Forms has no native Salesforce or HubSpot connector. Without a deliberate integration, entries sit in the form platform and someone re-types them into the CRM — or nobody does, and the lead is simply lost.
Forms · Workflow · Document Automation
Cognito Forms collects the data. We make your CRM act on it.
Cognito Forms is an online form builder with workflow automation, payments, e-signature and Word-template document merge. What it does not have is a native Salesforce or HubSpot connector — that layer has to be designed, built and maintained. That layer is the work we do.
12+
500+
40+
250+
Trusted by 500+ organizations — and fluent in the automation, integration and document platforms that sit around a Cognito Forms build.
Cognito Forms Delivery Capability
- Salesforce Partner
- HubSpot Partner
- Form & Workflow Design
- Document Automation
- CRM Integration
- REST API & Webhooks
- Data Migration
- Managed Support
Where form and document workflows quietly break down
Most teams do not have a forms problem. They have a problem at the seams — between the form, the CRM, the document, and the person who has to chase all three. Every seam is a place where data stops moving.
Documents are still assembled by hand
Proposals, agreements and disclosure packs get rebuilt in Word for every deal. The same client details are typed three times, formatting drifts between authors, and the version that reaches the client is rarely the one legal approved.
Nobody owns the field mapping
A form field called "Property Type" has to land on the right object, match a picklist value exactly, and not create a duplicate contact. When that mapping lives in one person's Zap, it breaks the first time the form changes.
Failed submissions fail silently
A required CRM field changes, validation rejects the record, and the automation drops it. Without retry logic, logging and failure alerts, the first sign of trouble is a customer asking why nobody called back.
Template sprawl nobody can maintain
Custom Cognito Forms documents are Word templates with merge tokens, billed per live template per form. Teams accumulate near-identical variants instead of using conditional content — paying more each month for a library that is harder to change.
Plan limits become operational incidents
Cognito Forms meters entries, document merges, API requests and storage. Entries submitted past the monthly cap are locked, and the vendor's documentation gives a 30-day window to upgrade before access to those locked entries is lost.
Platform Definition
What Cognito Forms is — and where it stops
Cognito Forms is an online form builder with workflow automation. You build forms with conditional logic and calculations, collect data and payments, route entries through approval workflows using roles and statuses, capture electronic signatures, and generate documents from submissions using Word templates. It is built and sold by Cognito, LLC. You can read the vendor's own document merging documentation for the platform-level detail.
Here is the boundary that matters, and it is the one most consulting pages get wrong: Cognito Forms generates documents from Cognito Forms entry data — not from Salesforce or HubSpot records. There is no button on a Salesforce record that produces a Cognito Forms document, and no way to merge an Opportunity or a custom object into a Cognito template. If you need documents generated from CRM records, that is a different class of tool — Conga, Nintex DocGen or PandaDoc — and we will tell you so rather than sell you the wrong architecture.
Who it fits. Cognito Forms is a strong choice when the work starts outside your CRM: public intake forms, client-facing applications, registrations, service requests and signed paperwork from people who will never have a CRM licence. It is a weak choice when the process starts from an existing CRM record. Most of the engagements we take on are the first kind — and the value is in getting that captured data into the system of record cleanly, then acting on it, whether that record lives in Salesforce or HubSpot.
Implement, configure, or build on top of Cognito Forms
These are three different engagements with three different price points and three different risk profiles. Knowing which one you actually need is usually the first useful outcome of a conversation with us.
| Engagement | What it covers | Right for you when |
|---|---|---|
| Implement | Requirements discovery, form and workflow design, building the forms, roles and statuses, payment and signature setup, document templates, the CRM integration, testing, migration and go-live. | You are adopting Cognito Forms, or replacing paper, email or an older form tool, and need the whole operation designed rather than a form drawn. |
| Configure & optimize | Auditing forms you already run, rebuilding conditional logic and calculations, consolidating duplicate document templates, fixing broken automations, tightening permissions, and reducing metered usage. | Cognito Forms is already live but is fragile, expensive, or producing data your CRM cannot use. |
| Build on | Custom development against the Cognito Forms REST API and JSON webhooks: middleware services, bi-directional sync, document post-processing, filing into storage, and custom logic no iPaaS step can express. | Your process is beyond what Zapier, Make or Power Automate can hold, or you need error handling, retries and audit logging that a no-code step cannot provide. |
The boundary in one sentence: configuration is everything achievable inside the Cognito Forms builder and a no-code automation platform; custom development begins where the API, webhooks or your own middleware are required. We will always tell you which side of that line a requirement falls on before work starts.
What a Cognito Forms engagement actually delivers
Six workstreams. Most engagements use four of them; which four depends on where your process currently breaks.
Form & Workflow Design
We design the form around the decision it feeds, not the other way round — so the data that arrives is data your CRM can act on without cleanup.
- Field, section and repeating-section structure
- Conditional logic and calculation design
- Roles, statuses and approval routing
- Save-and-resume and multi-step flows
- Validation that protects CRM data quality
Document Template Engineering
Custom Cognito Forms documents are Word templates carrying merge tokens and expressions. We build them so one template covers what would otherwise be five.
- Word template build, from your approved layout
- Merge syntax for repeating sections and tables
- Conditional content instead of template sprawl
- PDF or editable Word output per use case
- Template consolidation to control per-template cost
CRM Integration Architecture
The layer Cognito Forms does not ship. We decide how entries reach Salesforce or HubSpot, what they become there, and what happens when that fails.
- Object, field and picklist mapping
- Duplicate matching and record resolution
- Zapier, Make or Power Automate configuration
- Webhook and REST API integrations
- Retry, logging and failure alerting
Security, Access & Compliance
Forms collect the data your organisation is most accountable for. We configure access so the right people see entries and the wrong people cannot.
- Organisation user permission levels
- Workflow roles governing section visibility
- Folder-level permissions on Enterprise plans
- HIPAA and encryption configuration where in scope
- Retention and data-handling alignment
Reporting & Usage Control
Cognito Forms meters entries, document merges, API calls and storage. We make usage visible before it becomes an invoice surprise or a locked entry.
- Entry views built for the teams that use them
- Submission and conversion reporting in the CRM
- Usage monitoring against plan limits
- Plan-fit review before renewal
- Archiving and export routines
Rescue, Support & Optimization
If Cognito Forms is already live and already painful, we start by finding out why — then fix the parts that are costing you time or money.
- Audit of forms, templates and automations
- Rebuilding broken or undocumented integrations
- Migration from other form platforms
- Change support as forms and processes evolve
- Ongoing retainer support
How Cognito Forms data actually reaches your CRM
There are five real paths. Choosing between them is an architecture decision about volume, error handling, cost and who will maintain it — not a preference. It is the same call we make on any systems integration engagement.
Cognito Forms + Zapier
A new or updated entry triggers a Zap that creates or updates a Salesforce or HubSpot record. Entry data flows one way, capture to CRM. Fastest to stand up; weakest at volume, branching logic and failure recovery. We build and maintain these as part of our Zapier integration services.
Cognito Forms + Make
The same capture-to-CRM direction with more branching, iteration and data transformation per scenario. Where one submission has to become several related records, Make usually costs less to run than Zapier.
Cognito Forms + Power Automate
A certified Power Platform connector with entry created, updated and deleted triggers plus entry and file actions. The right choice for Microsoft-centred organisations, and it can write to SharePoint and Dataverse as well as the CRM.
Webhooks & REST API
Cognito Forms posts full entry JSON to an endpoint you control on submit, update or delete, and its REST API reads and writes entries. This is the path when you need real error handling, retries, audit logging or logic no automation step can express.
Salesforce Flow connector (Beta)
Salesforce publishes a Cognito Forms connector for Flow Builder through MuleSoft for Flow, letting a Flow use Cognito Forms as a data target. It is Salesforce-built, in Beta, and needs the MuleSoft entitlement — we assess it per org rather than assume it.
Document destinations
Generated PDFs rarely belong in the form platform. We route them to where the business looks — filed against the Salesforce or HubSpot record, into SharePoint, Google Drive or Box, and attached to the notification the client actually receives.
Payments
Cognito Forms takes payment natively through Stripe, Square and PayPal at the point of submission. We connect that transaction back to the CRM record so the deal, the document and the payment tell the same story.
MCP connector
Cognito Forms ships an MCP connector that lets AI assistants such as Claude and ChatGPT query forms and entries directly. We scope what it should be allowed to reach before it is switched on, not after.
How we run a Cognito Forms implementation
Six phases, one continuous engagement. The order matters: every phase removes a decision the next phase would otherwise have to guess at.
Discovery & Current State
We map the process end to end — who submits, who approves, which document results, where it must land. We also audit what exists: forms, templates, automations and the plan you are on. Most scope surprises are found here or paid for later.
Solution Architecture
We decide what Cognito Forms owns, what the CRM owns, and how they talk — the integration path, the object and field mapping, the duplicate-matching rule, and the error-handling model. This is written down and agreed before anything is built.
Build & Configure
Forms, conditional logic, calculations, roles, statuses and approval routing get built. Word templates are engineered with merge syntax and conditional content so one template does the work of several.
Integration & Automation
We connect capture to the system of record over the path chosen in Phase 02, then build what no-code cannot: retries, logging, alerting and reconciliation. An integration that cannot tell you it failed is not finished.
Testing & Launch
We test with real submission data, including the bad ones — malformed entries, duplicates, rejected records, failed payments. Then migration, user training for the people who live in the entry views, and a monitored go-live.
Support & Optimization
Forms change, CRM fields change, plans change. We monitor metered usage against your limits, keep the integration healthy as both ends evolve, and consolidate templates as the library grows.
Where a Cognito Forms build earns its keep
The pattern is consistent: structured capture from people outside your CRM, a document produced from what they submitted, and a clean record created at the other end.
Real estate transactions
Listing intake, buyer and tenant applications, disclosure packs and signed agreements — captured once, merged into the transaction document, and filed against the property record in Salesforce for real estate.
Client onboarding
A single onboarding form replaces the welcome-pack email thread: details collected, engagement letter generated and signed, and the account, contacts and onboarding tasks created in the CRM automatically.
Quotes & proposals
Calculations price the work as the form is completed, conditional logic includes only the relevant scope sections, and the merged proposal goes out as a PDF — with the opportunity created in the CRM at the same moment.
Legal & professional services intake
Matter intake with conflict-relevant questions, conditional follow-ups, retainer generation and signature — routed for approval before a record is created, so nothing unqualified reaches the pipeline — the capture layer in front of Salesforce for law firms.
Registrations & events
Registration with payment taken at submission, a confirmation document issued automatically, and attendee records and campaign membership written straight into the CRM.
Service & support requests
Structured request forms with file uploads that open a properly categorised case, route by approval where spend is involved, and give the requester a reference without anyone re-keying anything.
Internal approvals
Purchase requests, change approvals and HR forms using roles and statuses so each approver sees only their section — with the approved outcome recorded as a document and a CRM or finance-system update.
Renewals & recurring paperwork
Annual declarations, renewal confirmations and compliance attestations issued on a schedule, pre-filled where the data is already known, and reconciled against the CRM so you can see who has not responded.
What changes once the seams are closed
The gains come from removing handoffs, not from the form being prettier. These are the changes teams report after the capture, document and CRM layers are working as one system.
Data is entered once
What the submitter types becomes the CRM record and the document. Re-keying disappears, and with it the transcription errors that made reporting untrustworthy.
Documents are consistent by construction
Every agreement comes off the same approved template with the same clauses. Version drift stops being something you police and starts being something that cannot happen.
Turnaround stops depending on who is available
Generation and delivery happen on submission or approval rather than when someone gets to it, so the document arrives while the client is still paying attention.
Failures become visible
With logging and alerting in place, a rejected record surfaces the same day instead of at month-end — and the reconciliation report tells you what to fix.
The process scales without more admin headcount
Adding a practice area, region or document variant becomes a configuration change against an architecture that expects it, not a new manual routine for someone to absorb.
The same problem, already solved
Two published engagements either side of the Cognito Forms problem: getting form submissions into Salesforce cleanly, and generating documents from records at scale.
★★★★★
We used to spend half a day every Friday entering form data into Salesforce. Now it happens automatically the moment someone fills out a form on the website. Our sales team responds faster, our data is clean, and our ops team can actually do strategic work.
SaaS Operations Team Service & consulting platform, US · 35–50 employees Form-to-CRM
Web Forms → Salesforce Opportunities
The same integration problem a Cognito Forms build has to solve: submissions creating and de-duplicating Salesforce records with no manual entry. Results below are from this engagement only.
100% Of submissions create Opportunities automatically
0 Duplicate records — de-duplication automated
4h Per week of ops overhead eliminated
★★★★★
Before, creating a complex quote with multiple product lines took 90 minutes of manual work. Now it's instant — and without the risk of pricing errors.
Project Lead Accounting software provider, Australia · 50+ sales and ops staff Document Generation
Document Generation from CRM Records
Where documents must come from Salesforce data rather than form entries — the architecture we recommend instead of Cognito Forms. Fifteen template variants rationalised into four. Results from this engagement only.
45% Reduction in manual document effort
50% Fewer pricing and specification errors
100% Brand consistency across documents
Twopir has not published a Cognito Forms engagement. The work above is the same problem shape — form-to-CRM integration and template-driven document generation — delivered on adjacent platforms, and every figure is scoped to the engagement it was measured on.
A form is easy. The system around it is not.
Anyone can build a Cognito Form. The work worth paying for is the mapping, the document engineering, the error handling and the decisions about what should not be automated at all.
We are CRM people who implement Cognito Forms
The hard part of a Cognito Forms project is almost never the form — it is what the data has to become in Salesforce or HubSpot. We work with growing and mid-market companies to solve complex CRM, integration and business system challenges, and that is the side of this problem that usually fails.
We will tell you when it is the wrong tool
If your documents need to come from CRM records rather than form submissions, Cognito Forms is not the answer and we will say so. We would rather lose the scope than deliver an architecture you have to unpick in a year.
We build integrations that fail loudly
Most form-to-CRM integrations have no error handling at all. We build retries, logging, alerting and reconciliation as part of the work, because a silent failure is more expensive than an obvious one.
We design for what the platform charges for
Entries, document merges, API calls, storage and live templates are all metered. We design forms and templates to keep you inside the plan you are paying for, and flag plan-fit before renewal rather than after an overage.
We stay after go-live
Forms and CRM schemas both keep changing, and an integration is only correct on the day it ships. Ongoing support is how the system is still working eighteen months later.
Where this sits in the wider stack
A Cognito Forms build almost never stands alone. These are the services it connects to most often — and the honest alternatives if Cognito Forms turns out not to be your tool.
Salesforce consulting
The CRM side of this work — data model, automation and reporting. Start with Twopir's Salesforce consulting services.
HubSpot consulting
If HubSpot is your system of record, the capture and document layer is architected the same way. See HubSpot implementation and revenue infrastructure.
Integration services
The layer Cognito Forms does not ship. See our systems integration services, or Zapier integration services for the no-code path specifically.
Salesforce document generation
When documents must be produced from CRM records, not form entries. See Salesforce document generation services and Nintex DocGen consulting.
Other form platforms
Compare the field before committing: our online form builder comparison, plus FormAssembly Salesforce consulting and Formstack consulting services.
Real estate
Listing, transaction and tenant workflows where form capture feeds the CRM. See Salesforce for real estate.
Legal & professional services
Matter intake, retainers and engagement letters. See Salesforce for law firms.
E-signature integration
Cognito Forms signs inside the form. When signature must happen downstream of the CRM instead, see DocuSign Salesforce integration.
Cognito Forms questions, answered plainly
Yes, but not through a native connector built by Cognito Forms. Integration runs through an automation platform — Zapier, Make or Microsoft Power Automate — or through Cognito Forms' own JSON webhooks and REST API. Salesforce separately publishes a Cognito Forms connector for Flow Builder as part of MuleSoft for Flow, currently in Beta. Choosing between these paths is an architecture decision based on volume, branching logic, error handling and who will maintain it, and it is usually the first thing we work through on a Cognito Forms consultation.
No. Cognito Forms generates documents from its own form entry data using Word templates with merge tokens, producing PDF or editable Word output. It cannot merge a Salesforce Opportunity, Quote or custom object into a template, and there is no Cognito Forms button on a Salesforce record. If you need documents generated from CRM records, the right tools are Salesforce-native document generation products such as Conga, Nintex DocGen or PandaDoc. We implement those too — see our Salesforce document generation services — so we have no incentive to recommend the wrong one.
Six phases: discovery and current-state audit, solution architecture, building the forms and document templates, the CRM integration and automation, testing and launch, then ongoing support. The phase that decides whether the project succeeds is architecture — agreeing what Cognito Forms owns, what the CRM owns, how records are matched to avoid duplicates, and what happens when a submission fails to write. Everything after that is execution.
Across our implementations, straightforward projects typically run 6–10 weeks, and projects carrying multiple integrations, data migrations or multi-cloud builds typically run 10–16 weeks. Timelines are confirmed after discovery, not before it. What actually drives the number on a Cognito Forms project is the count of distinct document templates, whether entries must be matched against existing CRM records, whether historical data needs migrating, and how many approval stages the workflow carries — a single form with one template is a materially different project from a multi-form intake suite with conditional documents and bi-directional sync.
That is a large share of the work we take on. Typical findings are near-duplicate document templates that could be one conditional template, automations built by someone who has since left, conditional logic that has grown unmaintainable, field mappings that silently create duplicate CRM records, and plan usage running close to limits. We audit forms, templates, automations and usage, then fix in priority order — usually without rebuilding from scratch.
Cognito Forms states that it signs a Business Associate Agreement for HIPAA customers, completes ongoing SOC 2 Type 2 audits, publishes a Data Processing Addendum for GDPR, and encrypts sensitive data at rest, with an optional second layer of encryption. Features including HIPAA support, single sign-on and folder-level permissions sit on higher plan tiers. Whether that meets your obligations is a question for your compliance team against your own requirements — what we do is configure permissions, roles and encryption to match the decision they make, and verify current vendor terms at the time of implementation.
The main difference for Salesforce teams is the depth of the CRM connection. FormAssembly is built around a native Salesforce connector that can write to multiple related objects and prefill from Salesforce data; Cognito Forms reaches Salesforce through an automation platform, webhooks or its API. Cognito Forms is typically the more economical choice, and is strong on workflow, payments, calculations and document merge from entries. The decision usually comes down to how complex your Salesforce data model is and how much prefill from existing CRM records you need — we help clients make that call before they commit to a platform. Our online form builder comparison sets out the wider field, and we also deliver FormAssembly Salesforce consulting where that is the better fit.
Next Step
Tell us what you are trying to capture, and what should happen next
Bring us the process, not a feature list. We will tell you whether Cognito Forms is the right tool, what the integration should look like, and what it takes to build — before you commit to anything.
Talk to a specialist who has built the integration layer before
