FormAssembly · Customization

Most of what you want does not need a developer.

Branding, multi-language content, calculations, conditional paths, repeatable sections and accessibility are configuration — no code, nothing to maintain, nothing that breaks on a platform update. Twopir Consulting builds those, and tells you plainly on the rare occasion a requirement genuinely needs custom JavaScript. Configure first. Code only when we can show you why.

What Can Be Changed, and Where
THE REQUIREMENT Brand & Experience It must look like us Logic & Language It must ask the right things Accessibility Standards Regulatory Wording Reporting Needs TWOPIR CUSTOMIZATION LAYER Presentation Themes · CSS Layout · Language Behaviour Logic · Formulas Validation · Sections Escape Hatch Custom JavaScript Only where needed THE LINE IS DRAWN BEFORE THE ESTIMATE, NOT DURING THE BUILD 2πr WHAT YOU GET On Brand Indistinguishable from your site Higher Completion Shorter paths, fewer dead ends Maintainable Your team can change it later BRAND · LOGIC · LANGUAGE · ACCESS · MAINTAIN
12+
Years CRM delivery
500+
Clients served
40+
Consultants
250+
Deployments

Trusted by 500+ organizations — including healthcare, higher education, nonprofit and financial services teams whose forms have to match a brand and a compliance standard at once.

Magnus Health
Ideal Health Consulting
Aventria
Social Justice Collaborative
LegalZoom

Built for Regulated Data Collection

  • Salesforce Partner
  • HubSpot Partner
  • Themes & Branding
  • Form Language
  • Formulas & Calculations
  • Conditional Logic
  • Section 508 & WCAG
  • Custom JavaScript
Where Forms Lose People

Six reasons a working form still gets abandoned

A form that submits correctly can still be the weakest point in a process. These are the failures that show up as low completion, bad data, or a complaint from someone who could not use it at all. Every one of them is a customization problem, not a platform problem.

It obviously is not your website

An unstyled form on a branded page reads as a third-party redirect. For payments, applications and anything asking for personal data, that mismatch costs completions before a single field is filled.

Everyone is asked everything

No conditional logic, so a form covering six scenarios shows all six to every respondent. Length is the most reliable predictor of abandonment, and most of that length is irrelevant to the person reading it.

The error message does not say what is wrong

A rejection with no explanation leaves people guessing, and most of them guess once and leave. Validation messages are content, and they are almost always left at the default.

People are asked to do arithmetic

Totals, fees, scores and eligibility worked out by the respondent on paper. Every one of those is a calculation the form could do, and every manual one is a data-quality risk you inherit.

It exists in one language only

For organizations serving multilingual populations this suppresses response from exactly the groups the programme is meant to reach — and in some jurisdictions the wording is a legal requirement, not a courtesy.

It cannot be completed with a keyboard or a screen reader

Unlabelled fields, a broken tab order, colour-only error states and conditional sections that appear without announcing themselves. For public sector, education and healthcare respondents this is a compliance failure, not a nice-to-have.

What This Covers

Customization is everything you can change without leaving the platform

FormAssembly customization covers how a form looks, what it asks, in what order, in which language, and what it works out for the respondent along the way: themes and custom CSS, conditional questions, field validation, formulas and calculations, repeatable sections, multi-language content, datasets and autosuggest for long controlled lists, and accessibility. Almost all of it is configuration — nothing deployed, nothing for your team to maintain, and nothing that needs regression testing when the platform updates.

Where this page stops. This page is about the form itself. What the form does to your CRM — mapping, lookups, deduplication — is FormAssembly Salesforce integration. Automating the lifecycle of a single submission, including notifications, signature and payment, is FormAssembly form automation. Routing a process across several forms and approvers is FormAssembly workflow automation. Building against the API or writing middleware is FormAssembly API and custom integrations.

What Twopir does, and what the product does. Themes, conditional logic, formulas, repeatable sections, datasets and the custom-JavaScript escape hatch are FormAssembly capabilities. What we contribute is judgement about which one a requirement should use, and an honest answer when the requirement has outgrown all of them. The documented limits are part of that judgement — calculations apply to text fields, formulas do not work inside connector repeating sections, repeatable aliases cannot be referenced in formulas, and JavaScript calculations do not carry into connectors. Product documentation is the FormAssembly Resource Center.

What We Customize

Six kinds of change, five of them without code

The sixth is the escape hatch, and we reach for it last. Everything above it is configuration your team can inherit and keep changing after we leave.

Themes, Branding & Layout

Forms that read as part of your site rather than a redirect to somewhere else — kept in themes and documented CSS so an update does not undo them.

  • Typography, colour and spacing matched to your brand
  • Reusable themes across a whole form estate
  • Documented custom CSS instead of scattered overrides
  • Mobile layouts tested on real screen sizes
  • Embedded and hosted presentations of the same form

Conditional Logic & Flow

Shorter forms for everyone, by asking each respondent only what applies to them. The single most effective change to completion rates.

  • Branching that hides irrelevant questions entirely
  • One consolidated form replacing near-identical variants
  • Dependent menus that narrow as answers are given
  • Page and section ordering designed around drop-off
  • Confirmation and redirect behaviour per path

Formulas & Calculations

The form does the arithmetic instead of the respondent. Totals, scores, fees and eligibility computed live, with the documented limits respected.

  • Spreadsheet-style functions for totals and derived values
  • Live scoring and eligibility indicators
  • Date arithmetic for deadlines and durations
  • Validation that rejects bad data at the point of entry
  • An explicit check against the connector and repeatable-section limits

Form Language & Content

Multi-language forms with a maintenance workflow, so a change to one question does not quietly leave the other languages behind.

  • Labels, help text, errors and confirmations per language
  • Regulator-specified wording carried exactly
  • A translation workflow set up as part of the build
  • Question wording rewritten for plain comprehension
  • Consent and disclosure language reviewed with your team

Accessibility

Tested with a keyboard and a screen reader, not asserted from the platform's certification. A customized theme can undo accessibility, so it is verified after the branding, not before.

  • Label association and logical keyboard order
  • Error states that do not rely on colour alone
  • Conditional sections that announce themselves
  • Contrast checked against the branded theme
  • Section 508 and WCAG considerations documented

Custom JavaScript — the Escape Hatch

Used when configuration genuinely cannot reach the requirement, and scoped so you know exactly what you are taking on.

  • Interactions the builder does not offer natively
  • Behaviour responding to something outside the form
  • Written to be readable and handed over documented
  • Flagged for retesting when the platform updates
  • Never relied on to shape what a connector writes
The Boundary

Where configuration stops and development starts

The difference decides cost, timeline and who maintains the result afterwards. We place a requirement on this table during scoping, before the estimate — not halfway through a build.

The limits in the right-hand column are the product's documented behaviour, not our preference. They are the usual reason a requirement crosses the line.
RequirementConfiguration handles itCrosses into development when
Match the form to our brandThemes and custom CSS cover typography, colour, spacing and layout.The design needs an interaction the builder has no equivalent for.
Show different questions to different peopleConditional logic and dependent menus, with no practical ceiling for most forms.The branch depends on data the form cannot see at the time it is answered.
Calculate a total or a scoreFormulas, using spreadsheet-style functions, computed live in the browser.The calculation must run inside a connector, where formulas do not apply.
Collect a variable number of itemsRepeatable sections, mapped to child records by the connector.A formula must reference the repeated values, which aliases do not support.
Offer a very long list of optionsDatasets with autosuggest, which scale far past a usable dropdown.The list must be filtered live against another system mid-form.
Offer the form in several languagesForm language content maintained per language.Translation must be generated at runtime rather than maintained.
Validate against an external sourceOnly where a connector or dynamic picklist can do the lookup.Any real-time check the platform has no connector for.
How We Deliver

Sort the requirements first, then build in one pass

Durations describe typical engagements and depend on how many forms are in scope. A single high-value form is usually two to three weeks end to end.

Stage 01

Requirement Sorting

Every request placed against the boundary table: configuration, configuration with a caveat, or development. You see the classification before the estimate. Three to five days.

Stage 02

Flow & Content Design

Question order, branching, wording, validation messages and language coverage designed together — because they are the same decision seen from different angles. One week.

Stage 03

Theme & Build

The reusable theme first, then the forms on top of it, so brand changes later are one change rather than one per form. One to three weeks.

Stage 04

Accessibility & Device Testing

Keyboard and screen-reader passes after the branding is applied, plus real mobile testing — because a customized theme is what usually breaks both. Three to five days.

Stage 05

Handover & Maintenance

Theme documentation, the translation workflow, and a note of anything custom that needs retesting on a platform update. Optional retainer for ongoing logic and wording changes.

Where This Lands

The forms where customization pays for itself fastest

High volume, high consequence, or both. These are the four sectors where we most often do this work, and the forms within them that repay the effort first.

Higher Education

Prospective-student applications and scholarship forms: long, conditional, seasonal, and completed by people with no reason to persevere. Branching and live eligibility feedback move completion more than anything else.

Healthcare

Patient intake forms, where accessibility and plain wording are the difference between a completed history and a partial one — and where a branded theme still has to survive a screen-reader test.

Nonprofit

Donation and volunteer forms, where the form is the transaction. Brand consistency and a calculated gift total are worth more here than anywhere else on this list.

Financial Services

Account applications and KYC collection, where regulator-specified wording must be carried exactly and validation at the point of entry saves a remediation cycle later.

FormAssembly Customer Story
We’ve started to use FormAssembly to assess impact of the program by collecting self-reported measurements on a set of capabilities before people undertake the program and after completion and comparing them. That’s been incredibly useful and quite groundbreaking.
Iga Wojtasik Program Coordinator, Clore Social Leadership — quoted in FormAssembly’s published case study, not a Twopir engagement
Twopir Case Studies

Adjacent Work — Capture to CRM

We have not published a FormAssembly-scoped case study, and we will not present one that does not exist. The closest published evidence of how we architect capture into Salesforce is this integration engagement.

100% Call attribution to campaign source
Auto Lead creation on every qualifying enquiry
Read the Capture-to-CRM Case Study
Why Twopir

We would rather configure it than be needed forever

We help growing and mid-market companies solve complex CRM, integration and business system challenges, and we work with enterprise organizations on the same problems at larger scale.

We classify before we quote

Every requirement is placed on the boundary table during scoping. You find out that something needs code before you are committed to it, not halfway through.

We know the documented limits

Formulas not reaching into connector repeating sections, repeatable aliases not usable in formulas, JavaScript calculations not carrying into connectors. Those specifics are what actually decide scope.

We build the theme before the forms

One reusable theme means a future brand change is one change. A form estate styled individually means a project every time the brand moves.

We test accessibility after the branding

Heavy visual customization is what usually breaks keyboard order and contrast. Testing before the theme is applied proves nothing about what respondents will meet.

We design so your team can keep changing it

Wording, options and branches change constantly. If every change needs us, the customization was built wrong — and we would rather be called for the hard ones.

Common Questions

How far can this actually be pushed

Far enough that most respondents will not register it as a third-party form. Themes control typography, colour, spacing and layout, and custom CSS covers the rest, so a form can be made consistent with your site rather than merely tinted to match it. Two constraints are worth knowing before you promise a pixel-perfect match: the form still has to stay accessible and usable on a phone, and heavy visual customization is the thing most likely to need revisiting when the platform updates. We keep brand work in themes and documented CSS rather than scattered overrides for exactly that reason.

Yes. Form content — labels, help text, error messages and confirmation wording — can be maintained in more than one language, which matters most for organizations serving multilingual populations or operating across jurisdictions where the wording is a legal requirement rather than a courtesy. The part teams underestimate is maintenance: every later change to a question has to be made in each language, so we set up the translation workflow as part of the build rather than treating it as a one-off pass.

They cover Excel-style calculation on the form: totals, scores, eligibility flags, date arithmetic and derived values, using functions that will be familiar to anyone who writes spreadsheet formulas. They run in the browser as the form is completed, so the respondent sees the result immediately. The documented limits matter as much as the capability — calculations apply to text fields, formulas cannot be used inside connector repeating sections, and aliases from repeatable fields and sections cannot be referenced in a formula. Those boundaries decide whether a requirement is configuration or development, so we check them during scoping rather than discovering them mid-build.

We use it when a requirement is genuinely past what themes, logic and formulas reach — an interaction the builder does not offer, or a behaviour that has to respond to something outside the form. It is not something to avoid on principle, but it is something to account for: custom script is code your organization now owns, it needs retesting when the platform updates, and it does not transfer into connectors, so a JavaScript calculation cannot be relied on to shape what gets written to Salesforce. We say which side of that line a requirement falls on before the estimate, not during the build.

Yes, and for public sector, education and healthcare respondents it is usually a requirement rather than an improvement. FormAssembly supports accessible form construction and Section 508 considerations, but accessibility is a property of how a specific form is built — label association, keyboard order, error messaging, colour contrast and how conditional sections announce themselves to a screen reader. A heavily customized theme can undo it, which is why we test with a keyboard and a screen reader rather than relying on the platform's certification alone.

Both, and it is worth being clear which you are buying. A branding and accessibility pass across an existing form estate is a bounded project with an end date. Logic, wording and calculation changes are continuous, because the processes behind them change — a new programme, a revised eligibility rule, a regulator's new wording. Most organizations take the first as a project and keep a small retained arrangement for the second, which is cheaper than re-engaging for each change and keeps the estate coherent instead of accumulating exceptions.

Next Step

Send the form you like least. We will tell you what it needs.

Usually your longest form, or the one with the worst completion rate. We will say which changes are configuration, which need code, and which are not worth doing at all — before there is an engagement to protect.

Or contact the team — configuration first, code only when we can show you why