Skip to main content
.com domains from $2.99 — free WHOIS privacy on every name

Interaction brief · Broker Sites

Web hosting for insurance brokers — Your quote form is measured on taps, not on load time

The number that decides whether a commercial quote gets finished on a phone is how fast each field responds, and page-load tools never report it.

The short answer

A broker site lives or dies on Interaction to Next Paint, not on load time. INP measures how long the page takes to respond visibly after a tap, the published good threshold is 200 milliseconds at the 75th percentile, and a multi-step quote form is the most interaction-heavy thing most brokers publish. A page that loads in a second and then takes 400 milliseconds to acknowledge each field is the page people abandon two thirds of the way through.

That is a JavaScript and main-thread problem sitting on top of a platform that is not the constraint. HostingFast provides the platform — NVMe storage behind LiteSpeed caching from a couple of dollars a month, with free SSL, free migration, mailboxes on your domain and a human on support at any hour.

By the HostingFast team · Reviewed 24 August 2026

Free

Account move, engineer-handled

24/7

Hours we are reachable

Daily

Backups per day

$0

Setup fees

Broking is won on specialism, which means a broker site is a long tail of trade pages plus one very important form. The trade pages are cacheable prose and behave themselves. The form is where the engineering is, and it is measured differently from everything else on the site.

The reason load-time thinking fails here is that the expensive moment is not the first paint. It is the fortieth interaction: a validation rule running on every keystroke, a postcode lookup firing on blur, a conditional section re-rendering the whole form when a radio button changes. Each is a task on the main thread, and while it runs the interface is unresponsive.

So the instrument changes. You want INP from the field, long-task traces from the lab, and a real mid-range handset rather than the laptop you built the form on.

What INP is actually timing

INP measures the delay between a visitor's interaction and the next frame the browser paints, taking close to the worst interaction on the page rather than the average. The good boundary is 200 milliseconds at the 75th percentile of real visits, which means three quarters of your visitors must be inside it — the slow quarter is the quarter being graded.

Get it two ways. PageSpeed Insights reports the field figure from real Chrome users, which is the verdict. Then reproduce the cause in the lab: open the performance panel, record while you complete a few fields, and look for long tasks blocking the main thread. Those blocks are the milliseconds; everything else is inference.

Where brokers lose the interaction budget

Three patterns account for most of it. Validation that runs on every keystroke instead of on blur, so every character triggers work. A postcode or company lookup called synchronously, so the field freezes while an external API answers. And a conditionally-rendered form that rebuilds every section when one answer changes, rather than showing and hiding what is already there.

Fix them in that order and measure after each. Debouncing validation is usually the largest single win and takes minutes. Moving the lookup to a non-blocking call keeps the interface responsive while the answer arrives. Splitting a long form into steps helps too, but mainly because each step renders less — the abandonment benefit is a separate argument.

Trade pages are the easy half

Every specialist trade page is the same template with different prose, so budget the template once. Load the busiest one throttled to a mobile profile, note total transfer and identify the LCP element, and set a ceiling that keeps LCP at or under 2.5 seconds on that connection. WebP conversion is built into the platform, so what remains is serving images at display dimensions and keeping exactly one of them eager.

Confirm they are being cached, too. A quote-widget script embedded in the page footer sitewide can set a no-cache header that turns your entire cacheable long tail into full PHP renders — which is a caching finding, not a hosting one, and a large one.

The attachment path, measured separately

Schedules and proposal forms travel constantly, so mail is part of this site's performance story even though it is not part of any page metric. Send a real message with a representative attachment to an address you control, then read the received headers to confirm SPF and DKIM pass. Do it again after any DNS change.

Mailboxes on your own domain come with every plan, outbound goes through MailChannels, and every mailbox speaks IMAP, POP and SMTP alongside browser webmail. What you should verify yourself is the size limit you actually need and whether large schedules are better sent as a link than as an attachment — that is a deliverability decision as much as a performance one.

A team planning the next release of their business site

The platform, and the part that stays yours

Ours: NVMe storage on every tier, LiteSpeed caching in the web server, automatic WebP conversion, free SSL, and domain mailboxes with MailChannels handling outbound delivery.

Yours: the main thread. No hosting decision makes a keystroke handler cheaper, so staging copies and SSH with Git and Composer are there to let you change it and measure the result properly.

  • NVMe storage on every tier in the range
  • LiteSpeed sitting in front of PHP rather than inside it
  • Domain mailboxes with IMAP, POP and SMTP
  • Outbound mail routed through MailChannels

Why HostingFast

Standard on every plan

A platform that is not the bottleneck

Cached trade pages off LiteSpeed and NVMe return quickly enough that the remaining problem is unambiguously the form's JavaScript.

Staging for interaction work

Debouncing validation is a change you want to measure twice. A clone lets you record a performance trace before and after without a broker's client in the way.

Mail built for attachments

Domain mailboxes with IMAP, POP and SMTP, spam and virus screening as standard, and MailChannels getting outbound messages delivered.

Format work already done

Automatic WebP conversion means the trade-page template's image budget is about dimensions, which is the part you can control precisely.

Deploys that behave like commits

SSH with Git and Composer, so a form change is deployed and reverted as a commit rather than as an upload nobody recorded.

Support at any hour

Humans on shift who will look at a slow request with you, and PHP X-Ray on CloudLinux Pro on Nitro when the cause needs a function name.

Quick Start

From order to online

  1. 1

    Read INP from the field first

    PageSpeed Insights, field block, on the quote page. That is the number being graded; anything you measure in the lab is a hypothesis about why.

  2. 2

    Record a trace while you type

    Performance panel, complete a few fields, look for long tasks on the main thread. This is where a keystroke validator becomes visible as a cause.

  3. 3

    Fix one pattern and re-measure on a phone

    Debounce, then de-block the lookup, then split the steps. Measure on a mid-range handset each time — desktop INP tells you almost nothing here.

Built In

Loaded onto every plan

  • INP read from the field block on the quote page, not from a lab score
  • A performance trace recorded while actually completing form fields
  • Long tasks on the main thread identified rather than inferred
  • Validation debounced or moved to blur instead of firing on every keystroke
  • Postcode and company lookups made non-blocking
  • Conditional sections shown and hidden rather than re-rendered wholesale
  • Trade-page template given a byte budget on a throttled mobile profile
  • Cache status confirmed on trade pages, with the quote widget checked for no-cache
  • A real attachment delivered to a mailbox you control, with SPF and DKIM passing
  • Every measurement repeated on a mid-range handset, not a desktop

Frequently Asked

What people ask us most often

What is INP and why has it replaced the old responsiveness metric?

Interaction to Next Paint measures the delay between an interaction and the next painted frame, and it looks at close to the worst interaction on the page rather than only the first one. That matters for forms specifically: the first tap on a quote form is usually fine and the fortieth is not. The published good threshold is 200 milliseconds at the 75th percentile of real visits.

Why does the quote form feel fine on my desktop?

Because a desktop CPU absorbs a long main-thread task that a mid-range phone does not. Interaction cost scales with the device, and the field data is dominated by phones. Test on a real handset, or at minimum with CPU throttling enabled in DevTools, or you will keep shipping changes that measure well on the machine nobody buys insurance on.

Would splitting the form into steps make it faster?

Usually yes, but for a specific reason: each step renders and validates less, so there is less work per interaction. It is not magic — a single step that still runs a validator on every keystroke will be just as unresponsive. Fix the interaction handlers first, then split the form for the abandonment benefit, and measure INP after each change separately.

Do large attachments belong in email at all?

Often not. A schedule that pushes against a mailbox size limit is also the message most likely to be rejected or filtered somewhere along the way. Sending a link to the document, hosted on your own domain, is more reliable and easier to revoke. Whichever route you choose, test it to a mailbox you control and read the headers to confirm SPF and DKIM pass.

Keep reading

Changing hosts? Run through our checklist first.

A straightforward sequence for a switch your visitors never feel: which files move first, how to shift email across without losing a single message, the right moment to repoint DNS, and the two mistakes behind almost all the downtime we get asked to rescue.

You'll get the checklist email, then occasional pointers on keeping a site running fast. Unsubscribe the moment you want out — the privacy policy covers the rest.

Measure the taps, not the load.

NVMe and LiteSpeed under the pages, staging and SSH for the form, and domain mailboxes with MailChannels behind the correspondence.

View Dedicated Servers — Built for Insurance Brokers plans