Blog / Technical SEO /
Technical SEO: rendered HTML checks for JavaScript storefronts
The page looks perfect when you scroll through it.
Then a crawler reports a blank title, missing product copy, and links that don’t exist in the HTML it received. Same page. Two very different stories.
JavaScript storefronts can create exactly that gap between what you see and what a crawler can access. Search engines can render JavaScript, but rendering takes resources and won’t always behave like your local browser. So check the page twice: as delivered, and as rendered.
Compare the first response with the rendered page
Start with a URL inspection or crawler that shows the initial HTML response. Look for the page title, canonical, meta description, headings, product details and links. Then inspect the rendered HTML or screenshot after JavaScript runs.
If important content appears only after rendering, confirm that it loads reliably and does not require a user interaction such as clicking a tab or scrolling. A product description hidden behind a control can still be useful to people, but make sure the implementation exposes it in a way crawlers can process.
Check links and navigation
Links should be real, crawlable links with destinations, not only click handlers on generic elements. Test category pages, pagination and product cards. If the route changes only through client-side code, make sure direct visits to those URLs work too.
I also like to load the page with JavaScript disabled, as a quick debugging comparison. This is not a demand that every modern site function fully without scripts. It helps reveal whether the HTML contains a useful fallback or whether the entire page depends on a fragile render.
Look for common failure points
- API data arrives late or fails intermittently.
- A consent layer blocks scripts needed to populate content.
- The server returns the same empty shell for every URL.
- Internal links use non-standard interactions.
- Titles and canonical tags update inconsistently during navigation.
- Important text is inserted only after a button or tab is opened.
When you find a problem, isolate it to a page template or script. Fix the cause, then inspect more than one URL using the same template.
Verify after deployment
Test a representative product, collection and content page. Check status codes, canonical tags, robots directives, visible copy and links in both the initial response and the rendered output. Use Search Console URL Inspection for important pages, while remembering that a live test and indexing state answer different questions.
A rendered page isn’t a pass/fail checkbox. It’s evidence about what the crawler can access.
Compare a page before and after rendering
Choose a page where the important information appears to depend on JavaScript. Compare the initial HTML with the browser-rendered page. Is the product name available? Can a person and crawler reach the main content, links and navigation? Do buttons reveal content only after interaction, and is that content also available in a way that can be processed? Record what is missing rather than assuming that all client-side rendering is a problem.
A browser tool may show the page after scripts have run, but it can still differ from a search engine’s processing. Test with the available URL inspection features and review the rendered output when the issue affects an important page. If the difference is unclear, ask a developer to explain how the content is assembled.
Keep the test focused
Do not inspect every URL manually if many pages share a template. Select examples with different content states: a standard product, a long description, a missing optional field and a page with a variant selector. If the template behaves consistently, test a few more pages to check the pattern. If one record fails, investigate its data before changing the template.
Save the URL, device conditions, test time and what you expected to see. After a change, repeat the same test and confirm both content and user interactions still work.
If the crawler and browser show different content, save both outputs and share a short example with the developer. A reproducible difference is easier to investigate than a general claim that the site is “not rendered”. When I raise a rendering issue, I always send one URL and two screenshots, never a vague complaint.
What to do with a difference
If the initial HTML is sparse but the rendered page contains the essential information, record how the content becomes available and test whether the rendered version is stable. If both versions are missing a key product fact, the issue may be the CMS data or template rather than rendering. If links appear only after a user interaction, test whether the interaction is accessible and whether the destination is still discoverable through ordinary page links.
I’d never make a rendering change just to satisfy a tool screenshot. Confirm what a visitor sees, what the crawler can process and which page elements matter. Work with the developer on a narrow example and agree how success will be verified.
Trace the content back to its source
When a product title or description is absent, check whether the information exists in the page’s source data before investigating the rendering layer. A blank field in the catalogue and a script that fails to display a populated field can look similar in the final screenshot, but they need different fixes. Compare a page that works with one that fails, using the same template and the same testing conditions.
If the initial response contains only an application shell, record that as an implementation detail rather than immediately treating it as a ranking diagnosis. The next useful question is whether the important page content and links become consistently available to search systems, and whether users can still use the page when a request fails or takes time. A developer can then explain where server rendering, cached data or client-side code fits into the specific setup.
Related reading
If a test depends on scripts, repeat it after clearing the browser cache and note any consent or login state. These conditions can change what loads. Keep the test close to the real customer journey so a technical fix does not remove a feature people rely on.
Pick your most important template, usually the product page, and put the initial HTML and the rendered output side by side. What’s missing from the first one? That gap is where your investigation starts.