A catalog can look complete in your browser while returning an empty page before JavaScript loads. For example, the server renders a heading and a container, and then a client component fetches all products through useEffect. This does not prove that a search engine will never see the product cards, but it does add a dependency on scripts running and a successful client-side request.
We’ll show a custom example catalog built with Next.js 15 and the App Router: the server fetches published products, and the page renders their names and regular links. Cart buttons and interactive filters can remain client-side. This is an example of how to structure a page, not a ready-made store template with all the rules for selling products.
Check what is returned before the client loads
Choose a category URL with known products. Open the HTML source and find the name of one product card and its URL. Then disable JavaScript in a separate test browser and open the URL directly again. Compare the same URL, region, language, and authentication state.
If the server returns only “Loading,” look for where the catalog data is fetched. It may be in useEffect, a button handler, an external widget, or a request that depends on a browser token. Distinguish this from normal server-side loading that simply takes a while to return the completed HTML.
Google can process JavaScript, but it describes page fetching and rendering as separate stages. Seeing a polished catalog in your session does not confirm what a search crawler will process. For diagnosis, the availability of resources and the actual response content matter. Google’s JavaScript SEO basics.
Define a safe response for the catalog API
In this example, the source returns only data for the public catalog: slug, title, and the published indicator. A real store may have different fields and rules. Ask the developer to specify separately which products visitors are allowed to see and where that restriction is enforced.
Don’t send the entire internal ERP response to the browser and then hide unnecessary data with a filter. It may contain purchase prices, drafts, restricted descriptions, and internal identifiers. The server page should render only the necessary public data. The source’s authentication remains on the server and does not appear in the HTML.
Check how the application behaves when the API fails. An empty catalog returned successfully and a failure to load the list are different states. If the application displays “There are no products in this category” instead of an error message, visitors may think the assortment has run out. The source should have clear conditions for an empty response and for an error.
Fetch products in a Server Component
By default, a page.tsx App Router page is a Server Component unless you move it across a client boundary. The example page app/catalog/page.tsx could look like this. CATALOG_API_ORIGIN is set in the server configuration; you need to implement the /public/products route and fields in your own source.
import Link from 'next/link'
type ProductCard = { slug: string; title: string }
async function publishedCards(): Promise<ProductCard[]> {
const origin = process.env.CATALOG_API_ORIGIN
if (!origin) throw new Error('Catalog source is not configured')
const response = await fetch(new URL('/public/products', origin), {
cache: 'no-store',
signal: AbortSignal.timeout(5000),
})
if (!response.ok) throw new Error('Catalog is temporarily unavailable')
const rows: unknown = await response.json()
if (!Array.isArray(rows)) throw new Error('Unexpected catalog format')
return rows.flatMap((row) => {
if (!row || typeof row !== 'object'
|| typeof row.published !== 'boolean') {
throw new Error('Unexpected product record')
}
if (!row.published) return []
if (typeof row.slug !== 'string' || typeof row.title !== 'string'
|| !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(row.slug)
|| !row.title.trim()) {
throw new Error('Invalid published product')
}
return [{ slug: row.slug, title: row.title }]
})
}
export default async function CatalogPage() {
const products = await publishedCards()
return <main>
<h1>Каталог кружек</h1>
{products.length === 0 ? <p>В этом разделе пока нет товаров.</p> :
<ul>{products.map((product) => <li key={product.slug}>
<Link href={`/catalog/${encodeURIComponent(product.slug)}`}>
{product.title}
</Link>
</li>)}</ul>}
</main>
}The example uses no-store to rule out the effect of the server cache during the initial check. This is not a recommendation to disable caching throughout the store. Once correctness is confirmed, choose an appropriate data freshness policy. The ability to fetch data in a server component is described in the Next.js documentation 15.
Keep navigation as real links
A product card should have a link with a URL in href. A click handler onClick that changes state or triggers navigation solves an interface problem, but does not replace a clear link to a standalone URL.
The Next.js Link component is used to navigate between application routes. Its settings do not remove the need to check the result: inspect the DOM and find the a element with the correct href. Details about the component’s behavior are available in the Link reference for version 15.
The link text should explain where it leads. If the entire card is clickable, check the nested favorites and cart buttons: do not nest one link inside another. Don’t make clicking “Add to cart” open the product at the same time. Keyboard users should still have separate, accessible actions.
Provide access to the next catalog pages
If there are many products, you don’t have to return the entire assortment in one response. The important thing is that subsequent pages have accessible URLs and links, rather than appearing only after scrolling and running a script. Determine how your API returns the page number, total count, and product order.
For example, a category could use /catalog?page=2. Opening this URL directly should return the second part of the list. Don’t return the first part for every page number or rely on the client to correct it after loading. Check the empty last page, a negative number, and a value beyond the available range.
A sitemap supplements navigation, but does not fix missing links between catalog pages. It can contain the URLs of all published product pages, even if only a few are visible on the first page. For a large assortment, see splitting a sitemap in Next.js.
How to check the result and hand over the task
Check an existing category, an empty category, and a simulated source failure. The name of the selected product and its link should be present in the completed server response. With JavaScript disabled, visitors should be able to read the catalog and navigate to a product page; test optional interactive actions separately.
Be sure to compare opening the URL directly with navigating within the application. Then open the adjacent pagination page. Check that the set of cards differs as expected and that each link leads to the same product whose name is shown. If streaming or loading.tsx is used, include it in the test: a temporary loading screen must not remain the only available content.
Run a technical audit of the catalog page. It helps inspect the response and identify issues, but does not confirm that every product is indexed or test every client-side filter scenario. The structure of server and client components is covered in more detail in the Next.js guide 15.
In the task for the developer, list the products to check, permitted fields, publication rules, URLs for subsequent pages, and the failure scenario. Accept the work based on the response content and navigation behavior. Assess any traffic increase after the change separately using search data: fixing how the page loads removes a specific dependency, but does not by itself guarantee rankings.