Performance

Compress text resources (HTML, CSS, JS) using Gzip or Brotli to reduce data transfer size.

HTTP requests are minimized by combining files, using sprites, and HTTP/2.

Total page weight including all resources is under 1500KB (ideally under 500KB).

Videos are compressed, resized per device, and served in efficient codecs (H.264, HEVC, VP9/AV1) to reduce page weight and bandwidth use.

Keep individual CSS files small and remove unused styles to accelerate the critical rendering path.

Checks for JavaScript files that exceed recommended size limits to ensure fast interaction

Cache-Control and ETag headers are properly configured for static resources.

Static assets are served from a CDN for reduced latency and faster delivery.

Defer JavaScript modules, widgets, and third-party code until the user signals intent through a click, focus, hover, or similar interaction.

Use viewport-aware loading to fetch components, embeds, and feature code shortly before they become visible instead of shipping them on first load.

Images and heavy resources below the fold are lazy loaded to improve initial performance.

Loading indicators provide feedback during asynchronous operations to keep users informed of progress.

Implement preload, prefetch, and preconnect hints to optimize resource loading priority.

Load third-party scripts asynchronously to prevent blocking the main thread and improve page performance.

The fetchpriority attribute is applied to critical images, scripts, and preload links to help the browser prioritise the most important resources and defer lower-priority ones.

Detects lazy loading on likely above-fold images to improve Largest Contentful Paint (LCP)

A service worker is registered to intercept network requests, cache critical assets, and enable offline functionality for your web application.

When the network is unavailable, users are shown a custom offline fallback page rather than the browser's generic error screen.

The Speculation Rules API is used to declaratively prefetch or prerender likely next pages, making navigation feel near-instant without the overhead of a full client-side router.

Page performance is analyzed with WebPageTest to identify loading bottlenecks and optimization opportunities.

Adjust Google Tag behavior based on user consent to comply with privacy regulations and maintain data insights.

Reduce the number and depth of dependent resource requests that block the initial rendering of the page.

Use efficient font formats and loading strategies to prevent layout shifts and invisible text.

Use modern HTTP protocols to enable request multiplexing and reduce network latency.

Large animated GIFs are replaced with more efficient video formats like MP4 or WebM to reduce page weight.

Conduct performance audits in a full browser environment to capture accurate runtime metrics and layout shifts.

Keep the DOM tree small and shallow to improve memory usage and rendering performance.

Detect and consolidate duplicate JavaScript libraries to reduce bundle size and prevent version conflicts.

Configure Google Tag Manager efficiently to minimize its impact on page load speed and main-thread blocking.

Detects JavaScript libraries and checks for known vulnerabilities

Detects JavaScript resources that return 3XX redirects to reduce latency

Detects ES5 polyfills and legacy JavaScript code to reduce bundle size and improve execution

Checks for preconnect hints to critical third-party origins to reduce connection latency

Checks for render-blocking CSS and JavaScript that prevent the initial page render

Checks for source map availability and configuration to ensure easier debugging

Measures and optimizes server response time (TTFB) to ensure a fast initial response

Pages avoid back/forward cache blockers such as unload listeners and restore state correctly when a browser resumes them from memory.

Render only the visible subset of rows or cards in large collections to reduce DOM size, memory usage, and scroll-time rendering work.

Use HTTP chunked transfer encoding and React renderToPipeableStream (or ReadableStream) to begin delivering HTML to the browser as soon as the first bytes are available, reducing Time to First Byte and First Contentful Paint.

The largest content element loads within 2.5 seconds for a good user experience.

Page maintains visual stability with a CLS score below 0.1, preventing unexpected content shifts during load.

First content renders within 1.8 seconds, providing quick visual feedback that the page is loading.

Page responds to user interactions within 200ms, ensuring good responsiveness.

Page fully loads in under 3 seconds on a standard connection.