The short version
  • A contact form backend decides three things: where the record lives, who can see it, and how you prove it arrived. Most teams only think about the first.
  • Hosted endpoints (Web3Forms, Formspree) are the right default for a static marketing site. They're built to notify you, not to be your database.
  • Gravity Forms wins when the entries are the work: requests, applications and portals that staff search and act on inside WordPress.
  • HubSpot forms win when your team lives in HubSpot. The catch is that the CRM's own workflows can rename, relabel or overwrite what you send.
  • A function plus a blob store is for when you need custom logic and saved state. You get full control and you write every safeguard yourself.
  • Whatever you choose, canary-test it daily with a real browser, and make sure the canary can't count as a lead.

For a while, our own contact form showed "Thanks — we got it!" to everyone who pressed send, and delivered nothing. The endpoint in the page script was empty, the error handler showed the thank-you anyway, and every submission was saved only in the visitor's own browser. Nobody noticed, because a contact form backend that fails politely looks exactly like one that works.

We fixed it in May 2026, and since then we've been strict about one question for every form we build or inherit: where does the submission land, and how do we know it got there?

4
places a submission can land
1
real email our canary sends a day
15 / 15
scheduled canary runs green, 2–16 Nov
6
searchable tables on one Gravity Forms dashboard

The contact form backend is the part nobody tests

A form has a front end everyone looks at and a backend nobody does. The fields, the button and the thank-you message get reviewed in every design round. The thing that receives the POST gets configured once, at launch, by whoever was building the site that week.

Then it runs for years. Plugins update, a host changes a redirect, a CRM admin renames a property, a spam filter gets stricter. None of those changes touch the page, so none of them trigger a review. In our experience the backend is where forms actually fail, and it fails without telling anyone: a hosted service that refuses a request politely, a background queue that stops sending, a CRM that quietly merges two people into one contact.

So this comparison is about the receiving end, judged on four questions:

  1. Where does the record live, and is it somewhere you can count?
  2. What happens to spam, and does a dropped submission still look like success?
  3. Do attribution fields survive (UTMs and gclid) from the landing page to the record?
  4. How do you prove delivery tomorrow, without waiting for a customer to complain?

Four places a submission can land

Hosted endpoint Gravity Forms HubSpot forms Function + blob store
Example Web3Forms, Formspree WordPress plugin Embedded form or submission API Netlify function and Blobs
Record lives in Your inbox (Formspree also keeps a copy) Your WordPress database The CRM contact Your own store
Built-in spam control Server-side filtering, honeypot, captcha Honeypot, spam folder Depends on the form's settings Whatever you write
Attribution fields If you add them to the payload Hidden fields from the URL Properties, if they exist and are on the form Whatever you store
Who can see entries Whoever reads the inbox Site admins, plus views you build CRM users, by permission Whoever you give a key
Typical failure Request refused, nobody told Entry filed as spam, or a feed stalls Workflow overwrites the value A save that silently loses to an older one
Pricing model Free tier; paid tier adds captchas and extras Annual licence; the tier sets site count and add-ons Comes with your HubSpot account Plan with usage credits

Read the "typical failure" row twice. Every one of those is quiet.

A hosted endpoint, honestly

Our own site is static, and its forms post to Web3Forms: one endpoint, a public access key in the page, and each submission arrives as an email in our inbox. We haven't shipped on Formspree; if we ever swap, that's where we'd go, so its column here comes from its documentation.

Right when: the site is static or near enough, the volume is a contact form's worth, and you want no server, no plugin and no database to maintain.

Wrong when: the submission must start a workflow, land in a CRM with its attribution, or be searchable later. An email is a notification. It gets filtered, forwarded and deleted, and you can't query it.

What people underestimate: how browser-shaped Web3Forms is. Its API reference recommends calling it from the browser, and says server-side use needs a paid plan and server IP whitelisting. In practice it refuses headless and command-line user agents with a 403. That's sensible anti-spam, and it means a monitoring job that posts with curl gets refused, and a test run from a headless browser fails unless it presents a real Chrome user agent.

What people overestimate: the risk of the public key. It's in the page source by design; the service does its anti-abuse checks on the server.

Formspree's documentation says every submission is saved in your Formspree account as well as emailed, which answers part of the can't-query-it problem. It describes a _gotcha honeypot field, and says that when it's filled in, it silently ignores the submission. Web3Forms runs a server-side spam check on every submission and puts reCAPTCHA and Cloudflare Turnstile on its paid tier, alongside autoresponders, file uploads, webhooks and domain restriction, as of November 2026.

Gravity Forms on WordPress, honestly

Gravity Forms saves every submission as an entry in the site's own database. That sounds like a detail. It's the whole point.

For Seubert, a surety and insurance agency in Pittsburgh, bond requests from contractors are Gravity Forms entries, and the eBonds dashboard we maintain and extend is GravityView over those entries: six searchable tables on one page, each with its own search that survives a refresh. A "Convert to Bid Results" link carries a passthrough token, so the second form opens already holding the first entry's job title, obligee and bid date. The form isn't feeding an application. It is the application.

Right when: staff need to search, review and act on submissions, or one form leads into another. Also right when you want the record on infrastructure you already control.

Wrong when: the site isn't WordPress, or nobody will maintain the plugins. Gravity Forms is excellent and it is still a plugin on a self-hosted site.

What people underestimate: where the configuration lives. Forms, feeds and views sit in the database, not in your code repository. A change made in wp-admin doesn't travel with a deploy and never appears in a code review. And notification emails depend on the site's mail setup, so deliverability is only as good as the mailer behind it.

What people overestimate: the spam problem. Gravity Forms' Advanced Honeypot combines a hidden field with other checks, and flagged submissions are either discarded or saved as spam entries that don't send notifications or run add-on feeds. Choose "save as spam" and check the folder now and then; a real enquiry in there is recoverable.

HubSpot forms and the WordPress plugin, honestly

A family-law firm we work with runs its main site on WordPress with Gravity Forms passing entries to HubSpot, plus the HubSpot WordPress plugin. For its paid landing pages, we post each enquiry from the page straight to HubSpot's form submission endpoint, which accepts cross-origin requests from the browser.

Right when: your team works leads in HubSpot. The submission creates or updates a contact, enrols workflows, and lands next to the call-tracking and email history.

Wrong when: nobody owns the CRM's workflows. The form is the easy part. The workflows decide what your data means.

What people underestimate: that the CRM rewrites what you send. On this account we found a workflow that only marked a submission as a new lead if the form's name contained "form" (or one of a few call-tracking terms), labelling rules that overwrote any lead source they didn't recognise, and a rule that reset each contact's province from their phone number by matching area codes anywhere in the digits. A Calgary number could come out as Ontario. Read the workflows before you design the field map.

What people overestimate: how forgiving the API is. It isn't, and that's good. It rejects any field that isn't on the form with a FIELD_NOT_IN_FORM_DEFINITION error, which is a loud failure you can test for. The quiet one is identity: if you allow submissions without an email address, HubSpot deduplicates them by tracking cookie, so two people sharing a laptop can end up as one contact. The firm chose to require email on every path, which settled it.

One more trap for WordPress sites: HubSpot's tool for capturing other plugins' forms depends on the tracking code loading, skips forms bound to JavaScript, and does not collect hidden fields. If your UTMs ride in hidden fields, that route drops them.

A function and a blob store, honestly

The fourth option is to write the backend yourself: a serverless function receives the POST and writes to a store you control. We haven't used this for a public contact form. We use it, on Netlify, for client review pages where every answer must be saved and provably received, which is the same problem in a stricter form.

Right when: you need logic no form service offers, or several people writing to the same record.

Wrong when: you want spam filtering, notifications and a submissions inbox. You'll be writing all three.

What people underestimate: concurrency. Netlify Blobs is last-write-wins unless you use its conditional writes (onlyIfNew, onlyIfMatch). An audit of our first version found a change, sent as a tab closed, that sat in the device's queue and was re-sent on the next visit, overwriting a newer answer from another device. The fix was a random ID on every change and a store that skips IDs it has already seen.

What people overestimate: isolation. Site-wide stores are shared across all deploys, previews included; Netlify's docs present that as a way to test previews against production data. So our test runs write to their own document, never the client's.

Spam: what gets dropped, and who finds out

Every backend here filters spam, and most of them do it silently. Formspree says so outright. Gravity Forms can discard flagged entries without saving them. Web3Forms' own docs now mark its botcheck honeypot as not recommended and point to captchas instead.

Silence is the right behaviour toward a bot and the wrong behaviour toward your reporting. If your conversion tag fires on the form's success response, a binned bot submission can look identical to a delivered lead. We wrote up how that inflates conversion counts and how to test for it.

Three rules we apply:

  • Prefer "save as spam" to "discard" wherever the backend offers it. A spam folder is recoverable; a discard isn't.
  • Show an honest failure message. Ours now tells the visitor plainly that the message didn't go through, and gives them our email address and the option to try again. Never a thank-you for a send that didn't happen.
  • Expect your own tests to be filed as spam. On one Gravity Forms site we maintain, a scripted POST without JavaScript is correctly classed as spam by the honeypot, and the reCAPTCHA add-on refuses command-line submissions because there's no browser token. Test in a browser, or in a sandbox copy with outgoing mail intercepted.

Attribution fields only survive if something carries them

A form can only record the UTMs and gclid it is given. Three things break that chain.

The landing page and the form page are different pages. Gravity Forms can populate a hidden field from the URL's query string, but only on the page the visitor arrived at with that query string. If they land on the homepage and fill the form on the contact page, the parameters are gone unless a script stored them on arrival, and that script has to load on every page, not just the ones with forms.

Paid search sends gclid, not UTMs. Google Ads auto-tagging adds a click ID called GCLID to the landing URL; UTM parameters only appear if someone adds them by hand. Our own first-party lead record was originally built for UTMs alone; it would have stored every paid lead with empty campaign fields. We added gclid end to end before it went live.

The CRM's fields may not mean what their names say. On the family-law account, the source, medium and campaign properties that looked like UTM fields belonged to call tracking. Web-form UTMs needed their own properties, which we added to the account. And the hosted endpoint on our own site doesn't record attribution at all; a separate beacon to our own endpoint does.

How to canary-test a contact form backend

Here is exactly what ours does. It's a GitHub Actions workflow, form-canary.yml, and a 174-line Playwright script it runs.

  • Schedule. Daily, set for 16:00 UTC, plus a manual trigger. GitHub has been starting it between about four and eight hours late; all 15 scheduled runs from 2 to 16 November 2026 passed. Check the scheduled runs, not a manual one.
  • A real browser with a real face. It installs Chromium and opens the live contact page with a real Chrome user agent, because the form service refuses headless ones.
  • Suppression first, or no submit. It loads the page with ?rwnotrack=1, then checks that our tracking script loaded and reports itself suppressed. If either check fails, the run fails and refuses to submit. Until July 2026 the canary fired a real GA4 and Google Ads conversion on every run, which is the story we told in GA4 vs Google Ads conversion tracking.
  • A marked message. It fills the form with a [CANARY] message, a date and the run ID, and presses send.
  • Inspect the request, then let it through. It intercepts the POST to the form service and asserts the method, a non-empty body, the right access key, the canary marker and the subject line, then lets the request continue.
  • Check the page's verdict. It asserts that the form's status element reached its success state. One real email lands in our inbox per run.

The same script runs in a second mode as a check on every deploy: it intercepts the POST and aborts it before it leaves the browser, so nothing is sent, and a wrong endpoint or key fails the check.

What it doesn't do is read the inbox. The service's success response proves the service accepted the submission; the daily email is the proof it was delivered, and a person is the one who'd notice it missing. If we were starting again we'd send it to a filtered address and alert on absence. For Gravity Forms or HubSpot, use the same shape: a real browser, a marked entry on a form with no downstream automation, and a cleanup step.

Our defaults

  • Static marketing site, ordinary volume → a hosted endpoint, a daily browser canary, and an honest failure message. If paid traffic matters, add a second record you own.
  • WordPress site where submissions are the work → Gravity Forms, with "save as spam", real SMTP for notifications, and the form configuration written down somewhere outside the database.
  • The team lives in HubSpot → HubSpot forms, or the submission API from your own markup, with email required and a field map built from the CRM's workflows rather than the property names.
  • Custom logic or shared saved state → a function and a store, with conditional writes, change IDs and a separate test document.
  • Changing platform → forms are in the rebuild column of any migration, so budget for rebuilding and re-testing every one.

The backend you pick matters less than whether you can prove, tomorrow morning, that it still delivers. If you can't, that's the first thing to fix.

Related comparisons: Zapier vs webhooks: when a custom lead pipe pays off · Uptime monitoring vs synthetic monitoring: what a 200 hides

If you'd like a second pair of eyes on where your forms actually send, or you're planning a WordPress build around them, tell us what you're running.

Common questions

What is a contact form backend?

It's whatever receives the submission when someone presses send. On a static site that's usually a hosted endpoint that emails the entry to you. On WordPress it's often a form plugin such as Gravity Forms that saves an entry in the site's database. A CRM like HubSpot can be the backend directly, or a small serverless function can receive the data and store it. The choice decides where the record lives, who can see it, and how you prove it arrived.

Is Web3Forms or Formspree better for a static website?

We run Web3Forms on our own static site and haven't shipped on Formspree, so take the comparison from their documentation. Both take a plain HTML form pointed at their endpoint and can email you the result, and both document a honeypot field. Formspree also saves every submission in its dashboard; Web3Forms keeps reCAPTCHA and Turnstile for its paid tier. The deciding questions are which spam controls you need, whether you need to send from a server rather than a browser, and how you'll test it. Either is fine for a low-volume contact form, provided you canary-test it.

Should I use Gravity Forms or HubSpot forms on WordPress?

Use Gravity Forms when the entries are the work: applications, requests and portals where staff search, review and act on submissions inside WordPress. Use HubSpot forms when your team lives in HubSpot and the submission must start a contact record, workflows and attribution there. Many sites run both: a family-law firm we work with has Gravity Forms on its main site, with the HubSpot add-on passing entries to the CRM. Whichever you choose, map fields to the exact properties your CRM workflows read.

How do I test that my contact form still works?

Submit it the way a person would, on a schedule, and check that it arrives. We run a headless browser with a real Chrome user agent against our live contact page every day. It fills the form with a marked test message, inspects the outgoing request, lets it through, and checks for the success state. One real email lands in our inbox per run. Make sure the test can't fire your conversion tags, or your canary becomes your best-performing lead source.

Why does my form say thank you but the email never arrives?

Either the backend accepted the submission and the email failed afterwards, or the page shows a thank-you message whatever happens. Before we fixed our own forms, the page script caught every error and showed a thank-you anyway, and submissions were saved only in the visitor's own browser. Check the network request in your browser's developer tools, check the backend's spam handling, and make the failure message honest: tell visitors to email you directly if the send fails.

Do hidden UTM fields work in HubSpot forms?

They work when you submit to a HubSpot form that includes those fields, through the embedded form or the forms submission API, and the matching contact properties exist. They do not work through HubSpot's tool for collecting non-HubSpot forms, which its documentation says does not collect hidden fields. Also check what each property means before writing to it. On one CRM we found source and campaign fields that belonged to call tracking, and web-form UTMs had to go into separate properties.

Where should form submissions be stored?

Somewhere you can count them independently of the email they generate. An inbox is a notification, not a record: messages get filtered, deleted and forwarded. Gravity Forms stores entries in your WordPress database. HubSpot stores them on the contact. A hosted endpoint mostly emails you (Formspree also keeps a copy in its dashboard), so pair it with a second record if leads matter. That can be a CRM, a spreadsheet integration or a small endpoint you own. Then reconcile the two counts now and then.