Skip to content

Website Design and Development

Performance-first build

Within Website Design and Development, this is the piece that make speed a constraint of the build rather than an optimisation after it.

Building and testing a website layout in code

What does performance-first build mean here?

Make speed a constraint of the build rather than an optimisation after it. In practice that means Performance budgets set per template and enforced in continuous integration, and then the harder half: image and font strategy decided at the start rather than retro-fitted.

Why this work exists

This is the piece teams assume somebody else is handling. Usually nobody is.

It sits inside Website Design and Development, which is the broader discipline, and it is the part people most often ask for by name.

The nearest piece of work to it is writing the error states that nobody designs until they happen. Where that is already handled, this moves faster than the estimate; where it is not, the two get done together or neither of them holds.

What good looks like

It is healthy when the people who disagreed with it still use it.

The gap between that and where most accounts start is why this is scoped as performance-first build rather than as a line inside something larger. Making the navigation survive a site three times the current size is the usual second step once it is in place.

When this is the right work

The signs that this is where the problem sits:

  • Performance work keeps getting deferred to a later phase
  • A tag manager has accumulated scripts nobody can account for
  • Each release makes the site slightly slower and nobody notices

If none of those is true, something else is probably the constraint, and the Website Design and Development overview maps the alternatives. The usual neighbours are giving images a size so the page stops jumping and planning the redirect map before the old site goes away.

What the work covers

The pieces of work inside it:

  • Performance budgets set per template and enforced in continuous integration, which changes often enough that a single pass has a shelf life.
  • Image and font strategy decided at the start rather than retro-fitted. Worth doing badly rather than not at all, if time is short.
  • Third-party script governance with a facade pattern for anything heavy. The output here is what everything after it is built from.
  • Field monitoring from launch so regressions are caught in days, done before anything downstream is committed to.

How it runs

It runs in three passes. The order is not interchangeable.

1

Deciding what not to do

A list of things deliberately left alone, with the reason for each. It saves the same conversation happening four times over the following year.

2

The second look

A fortnight after the first pass, the same ground gets covered again with fresh eyes. The second pass finds a different class of problem from the first.

3

Bringing in whoever owns the system

Developers, agency partners or whoever actually controls the platform get involved before recommendations are written, not after they are rejected.

What each part runs into

What each part actually contends with:

  • Performance budgets set per template and enforced in continuous integration: the Kota version of this has to deal with a reporting line that averages away the market in question
  • Image and font strategy decided at the start rather than retro-fitted, where a Mumbai engagement contends with a market where buyers qualify by area rather than by city
  • Third-party script governance with a facade pattern for anything heavy – working in Kolkata this means accounting for a competitive set that changes street by street
  • Field monitoring from launch so regressions are caught in days, and in Dubai the constraint on it is a decision made by somebody who never visits the site

The version that does not work

Optimising after launch. Performance built in costs a fraction of performance retro-fitted, and the architectural choices are made early.

It is worth stating because it is the version of this work that gets sold most often, and it fails in a way that looks like the discipline not working rather than the execution being wrong.

How it is measured

Field Core Web Vitals at the 75th percentile, and budget compliance per release. It is reported with the existing metrics rather than replacing them, because a new number nobody recognises persuades nobody.

Where the figure is estimated rather than counted, it says so on the report.

What you end up with

What gets handed over: a build with enforced performance budgets, a documented asset strategy and field monitoring in place.

Plain language throughout. Jargon gets defined where it is unavoidable.

How it differs by sector

The brief changes with the sector, not just the emphasis:

  • For Ecommerce and retail, margin per order decides everything, and the product feed is usually the weakest asset. and that shapes how far this can go.
  • Manufacturing and industrial brings its own limit: low volume, high value, and a specification sheet that decides the deal.
  • B2B services, constrained by the fact that a buying committee, a long cycle, and attribution that has to survive both.

The industry pages carry the rest of that detail. Ecommerce and retail and Manufacturing and industrial are the two where this piece of work most often decides the outcome.

Common questions

What is a reasonable performance budget?

Something the business can hold: a cap on HTML, CSS and JavaScript weight per template, a limit on render-blocking requests, and a field target for the Core Web Vitals. The numbers matter less than the enforcement, because an unenforced budget is a wish and every release erodes it.

How do you stop third-party scripts degrading a fast site?

Governance plus technique: a documented owner and business case for every tag, periodic review to remove the dead ones, and a facade pattern so chat widgets, maps and video load only on interaction. Most slow sites are fast sites with twelve tags on them.

What happens if it does not work?

We report that it did not, with the reason. Field Core Web Vitals at the 75th percentile, and budget compliance per release agreed before the work starts makes that an honest conversation rather than an argument. Worth a look before committing budget: Semantic search, then SERP features.

Who does the work on performance-first build?

A practitioner rather than an account manager, and the same person throughout. Field Core Web Vitals at the 75th percentile, and budget compliance per release is their number, which is the only arrangement under which the reporting stays honest. The evidence is in AI Platform Optimization for Education and training. The argument about what it means is in Analytics and Measurement for Education and training.

Is the work transferable to our team?

That is the intent. A build with enforced performance budgets, a documented asset strategy and field monitoring in place. Written for somebody who was not in the room, because the alternative is a dependency rather than a result. Most of the hard parts here are covered in Agentic Commerce in Austin, with the exceptions in AI Automation and Workflows in Austin.

Ask about performance-first build

One line on the goal and one on the obstacle. That is all the first exchange needs.

Start a conversation

Name, email and a line about the problem is enough to start.

What happens to what you send is set out in the privacy policy. We do not sell or share it.

Have someone senior look at the numbers

Tell us what you sell and what is not working. We will come back with the two or three things we would look at before anything else.

CallWhatsAppGet a quote