Commerce Performance Optimization Checklist

Summary

A technical audit framework for identifying performance bottlenecks in commerce platforms. Use this to structure performance discovery work and prioritize fixes that actually move conversion metrics.

Most Performance Audits Mistake Activity for Progress

Performance work gets stuck in one of two places: teams chase Lighthouse scores without connecting them to business impact, or they fix surface-level issues while ignoring the architectural problems underneath.

A useful performance audit answers three questions:

What's actually slow, and for which users?
What's causing it at the infrastructure, application, and third-party layers?
What's the cost of fixing it versus the cost of leaving it?

This checklist is structured around those layers. Skip the items you've already validated. Spend time on the ones where you don't have clear answers.

Core Web Vitals Baseline

Largest Contentful Paint (LCP)

What is LCP at the 75th percentile for your highest-traffic templates (PDP, PLP, homepage)?
Is LCP different for mobile vs. desktop, and by how much?
What element is triggering LCP on each template type, hero image, product image, or something else?
Are LCP images served in next-gen formats (WebP, AVIF) with proper sizing?
Is there render-blocking CSS or JavaScript delaying the LCP element?
What's the delta between lab data (Lighthouse) and field data (CrUX)? If it's large, why?

Cumulative Layout Shift (CLS)

Which page templates have the worst CLS scores, and what's causing the shift?
Are above-the-fold images and embeds using explicit width/height or aspect-ratio CSS?
Are web fonts causing layout shifts on load? What's the font-display strategy?
Are late-loading ads, banners, or personalization blocks pushing content down?
Does CLS get worse on slow connections or specific device types?

Interaction to Next Paint (INP)

What's the INP at the 75th percentile on key interaction pages (PDP add-to-cart, checkout)?
Which interactions are slowest, add to cart, filter selection, form submission?
Is the main thread blocked during critical interactions? For how long?
Are there long tasks (>50ms) tied to analytics, personalization, or third-party scripts?

Server and Infrastructure

Time to First Byte (TTFB)

What's TTFB at the 75th percentile across key entry pages?
Is TTFB consistent across regions, or are some geographies significantly slower?
What's the breakdown: DNS, connection, TLS, server processing, network transfer?
Is full-page caching enabled? What's the cache hit rate?
For uncached requests, what's the backend response time from the commerce platform?
Are there slow database queries, external API calls, or middleware bottlenecks on critical paths?

CDN and Edge

Is static content (images, JS, CSS) served from a CDN with edge caching?
Are cache headers configured correctly? What's the TTL strategy?
Is the CDN doing edge optimization (image compression, minification)?
Is HTML being cached at the edge, or is every request hitting origin?
For headless setups: is the frontend deployed at the edge, or centralized?

Hosting and Scaling

What's the infrastructure setup, traditional hosting, cloud, PaaS, or headless with serverless?
Is auto-scaling configured, and has it been tested under load?
What's the failover strategy if the primary region or instance goes down?
Are there performance SLAs with the hosting provider? What do they actually guarantee?

Third-Party Scripts

Inventory and Impact

How many third-party scripts are loading on key pages? List them.
What's the total JavaScript payload from third parties vs. first-party code?
Which third-party scripts are render-blocking or blocking the main thread?
Are any scripts loading synchronously that could be deferred or async?
What's the cost of each third-party script in terms of load time and main thread time?

Tag Management

Is a tag manager in use? Which one, and who controls it?
Are there scripts in the tag manager that were added for campaigns that ended months ago?
Is there a governance process for adding new tags?
Are tags firing on pages where they're not needed?

Critical Third Parties

For payment providers: what's the load time impact of their scripts on checkout?
For personalization tools: are they blocking render, or loading asynchronously?
For analytics: is there redundancy (multiple analytics tools tracking the same events)?
For chat widgets: are they lazy-loaded or blocking initial render?

Frontend Architecture

JavaScript

What's the total JS bundle size on key pages? What's the breakdown by module?
Is code splitting implemented? Are chunks being loaded efficiently?
Is there unused JavaScript being shipped? What percentage?
Are polyfills being served to browsers that don't need them?
Is JavaScript hydration blocking interactivity on initial load?

CSS

What's the total CSS payload? Is critical CSS inlined?
Is there unused CSS being shipped? What percentage?
Are CSS files render-blocking?
Is CSS being duplicated across chunks or components?

Images and Media

Are images lazy-loaded below the fold?
Are responsive images being served with srcset, or is one size being scaled?
What's the image optimization pipeline, manual, automated, or via CDN?
Are there oversized images being served (e.g., 2000px images in 300px containers)?
For video: is it lazy-loaded, and is the initial poster image optimized?

Commerce-Specific Performance

Product Pages

How long does it take for the "Add to Cart" button to become interactive?
Are product images preloaded or loaded on-demand?
Is variant selection (size, color) causing full page reloads or excessive API calls?
Are reviews loading synchronously and blocking the rest of the page?

Category and Search

What's the response time for filtering and sorting on PLPs?
Is search using autocomplete? What's the latency?
Are search results being cached, or hitting the search index fresh every time?
On infinite scroll: what's the performance impact as the user loads more products?

Cart and Checkout

What's the time from clicking "Add to Cart" to cart confirmation?
Is the cart using optimistic UI updates, or waiting for API confirmation?
What's the total page weight of the checkout page?
Are there third-party scripts on checkout that could be deferred until after purchase?
What's the latency on each checkout step, including payment processing?

Measurement and Monitoring

Real User Monitoring

Is RUM implemented? Which tool?
Are Core Web Vitals being tracked with real user data, segmented by page type?
Are you measuring performance by device, connection speed, and geography?
Can you tie performance data to conversion metrics (bounce rate, cart abandonment)?

Synthetic Monitoring

Is synthetic monitoring running against key pages from multiple regions?
Are alerts configured for performance regressions?
What's the frequency of synthetic checks?

Regression Prevention

Is performance budgeting in place in the CI/CD pipeline?
Do performance tests run before code merges?
Is there a process for reviewing performance impact of new features before launch?

Prioritize by Revenue Impact, Not Score Improvement

Start with the areas where you have the least visibility. If you can't answer a question, that's a gap worth investigating.

Prioritize fixes based on:

Traffic impact (which pages get the most visits)
Conversion proximity (checkout and cart matter more than the about page)
Fix complexity vs. expected gain

Don't chase perfect scores. Chase measurable improvements on pages that drive revenue.

How DigitalStack Connects Performance to Decisions

Performance work treated as a standalone audit produces reports that sit in folders. DigitalStack ties performance findings directly to the discovery process:

Business objectives: If checkout takes 8 seconds on mobile and you're losing 12% of mobile users at that step, that's a revenue calculation, not a Lighthouse score.
Technical requirements: A slow TTFB caused by uncached API calls becomes a specific requirement for edge caching or backend optimization, with defined acceptance criteria.
Stakeholder alignment: Performance trade-offs (speed vs. personalization features, for example) get surfaced during discovery, not discovered post-launch.

The output isn't a PDF of findings. It's performance issues mapped to requirements, architecture decisions, and prioritized backlog items.

Next Step

If you're structuring performance discovery as part of a larger replatform or optimization engagement, DigitalStack helps you connect the findings to requirements and architecture decisions.

Request access to see how it works.