Anatomy of a Perfectly Optimised PDP

The H1 is the first thing Google and LLMs evaluate when deciding what a page is about. It sets the primary topic, anchors semantic relevance across the whole page, and determines whether your product is a candidate for a given query before any other element is considered.

Structure: primary attribute + product type + key differentiator. Lead with what users search for, not what the brand calls it internally.

• Include material, audience, or use case where it's a search signal: "Men's Merino Wool Jacket" beats "The Ridgefield Jacket"
• Don't repeat the exact same string as the title tag — they should complement each other, not duplicate
• One H1 per page, in server-rendered HTML — never injected via JS after load
• Keep it under ~70 characters so it renders cleanly in most SERP formats when Google uses it as the title

Google uses the H1 as a primary topical signal and cross-references it against the title tag. Significant mismatch between H1 and title tag can cause Google to rewrite your SERP title.

LLMs treat the H1 as the most authoritative label for the product. A query like "warm jacket for layering under a shell" will match "Men's Merino Wool Jacket — Premium Weight Winter Outerwear" far more reliably than "The Ridgefield" or "Style #MW-0042".

The <title> tag is the clickable blue link in SERPs. It's a direct ranking signal, a primary driver of click-through rate, and the text Google uses when it can't determine a better label from your H1 or page content. Google may rewrite it — but giving it a clean, well-structured title reduces rewrites significantly.

• Keep under 60 characters — beyond that, mobile SERPs truncate with an ellipsis
• Front-load the primary keyword: product type and key attribute first, brand last
• Format: Primary keyword | Secondary descriptor | Brand
• Don't use your brand as the first word unless users are specifically searching for you by name
• Avoid filler words: "Shop", "Buy", "Best", "Amazing" add nothing and waste characters

Example: Men's Merino Wool Jacket | Winter Outerwear | Brand outperforms Brand | Shop Premium Men's Jackets Online for every non-branded query.

Google uses the title tag as a direct ranking signal and displays it in SERPs. It also cross-checks it against H1 and body content — if they conflict significantly, Google rewrites the title using its own judgment.

LLMs don't parse title tags the way Google does, but pages with well-structured, keyword-relevant titles tend to rank better and therefore appear more often in training data and retrieval contexts.

On Shopify: By default, Shopify constructs title tags as "Product Name — Store Name". This puts the brand first and often leaves little room for descriptive keywords. You can override this in theme Liquid (product.title | append: ' | ' | append: shop.name) or via a third-party SEO app. The default template is rarely optimal for non-branded product searches.

Product images are crawlable content with multiple ranking surfaces: Google Image Search, Google Shopping panels, and Google's virtual try-on feature. The file name, alt text, and image format all carry signals. LLMs use alt text as the primary mechanism for "reading" a product's visual characteristics.

Background and format:

• Hero image: white or light-grey background — required for Google Shopping eligibility and Google's virtual try-on feature
• Virtual try-on additionally requires: straight-on front-facing shot, model or no-model (both accepted), no busy backgrounds, no text overlays
• WebP format preferred for page speed; provide width/height attributes to prevent layout shift

Multiple angles:

• Front view (hero — white bg)
• Back view
• Close-up of material/detail
• Lifestyle shot (worn in context)
• Scale reference where relevant (furniture, accessories)

File naming: mens-merino-wool-jacket-navy-front.jpg — not IMG_4823.jpg. Attribute first, colour second, angle third.

Alt text: Describe what's literally in the image. "Men's navy merino wool jacket, slim fit, front view" — not keyword lists, not empty, not "product image".

On Shopify: Shopify generates image URLs with a CDN hash, so file names are preserved in the URL path — name files correctly before uploading. Alt text is set per-image in the media editor, or via the Storefront API / bulk CSV. It does not inherit from the product title automatically.

Google uses images for Image Search ranking, Shopping product carousels, and virtual try-on. Image quality and background compliance directly affects Shopping feed approval.

LLMs cannot "see" images but read alt text and file names as proxies for visual content. Material type, colour, and fit language in alt text feeds directly into AI shopping agent recommendations when a user asks "what's a good warm navy jacket?"

Price and availability are the most time-sensitive signals on any PDP and the most common source of Shopping disapprovals. They feed Shopping ads, free listings, and LLM agent recommendations — all of which depend on exact, real-time accuracy across three sources simultaneously: the visible page, the schema markup, and the GMC feed.

On-page:

• Price must be in server-rendered HTML — not injected by JavaScript after load. Google's crawler may not execute JS that renders pricing.
• Display price prominently above the fold, in plain text with the currency symbol
• Stock status must also be human-readable HTML: "In stock", "Only 3 left", "Out of stock"

In schema:

• Use offers.price, offers.priceCurrency, offers.availability
• For sale pricing, set offers.priceValidUntil — without it, when the sale ends, Google may flag a price mismatch
• Availability values: use full schema.org URIs — https://schema.org/InStock, not just "InStock"

In GMC feed:

• Price must match the page exactly, including currency format: 189.00 USD
• Use sale_price alongside price for promotional pricing — don't just lower the price field
• Availability values: in_stock, out_of_stock, preorder — match what's on the page

On Shopify: Shopify's default theme and product JSON includes price in the page HTML, but uses JavaScript to update prices when variants are selected. The base price renders server-side; variant-specific prices may be JS-driven. If you're using a headless or heavily customised theme, verify with Google's Mobile-Friendly Test or a server-side render check that prices appear in the raw HTML.

Google cross-checks page price, schema price, and feed price. Any conflict — even a currency formatting difference — can trigger a Shopping disapproval. It also checks price against competitor pages to detect unrealistic pricing claims.

LLMs (ChatGPT Shopping, Perplexity, Google's AI Mode) draw product data from feeds and indexed pages. A stale feed means AI agents surface the wrong price to users in an active buying moment — potentially sending them to a competitor when they see the correct price on your page.

The product description is the primary body content Google indexes for long-tail query matching and the main signal LLMs use to understand use case, fit, and audience. Most descriptions fail because they're either copied from manufacturers (duplicate content) or written as keyword lists (unreadable to humans and machines alike).

Write to answer five questions a buyer actually has:

• What is it made of? Material, construction, origin — specific, not vague ("100% ZQ-certified merino wool, 280gsm", not "premium fabric")
• Who is it for? Use case and audience — "for cold-weather commuting and weekend wear", not "for everyone"
• What does it do? Functional benefits — "moisture-wicking, temperature-regulating, machine washable"
• What does it pair with? Named product links — "pairs well with the Merino Rollneck or the Waterproof Overshell" — this is both useful UX and a product-relationship signal for LLMs
• What makes it different? The one thing your competitors' descriptions don't say

Format matters: a short opening paragraph (2–3 sentences) followed by a bulleted feature list performs better for both readability and LLM parsing than a wall of prose.

On Shopify: The description field accepts rich HTML. Use the native editor or Liquid to structure it properly — opening paragraph, then a <ul> for features. Avoid using heading tags (H2/H3) inside the description field; they can create duplicate heading structure issues depending on your theme.

Google uses description content for topical relevance and long-tail query matching. Unique, specific descriptions improve the chance of ranking for queries like "merino wool jacket machine washable slim fit" — queries that generic descriptions can't match.

LLMs use the description as the primary source for intent matching. A query like "warm jacket I can layer under a shell and also machine wash" will match a rich description and fail to match a generic one. The more specific the language about use cases, the better LLM agents can recommend your product for real-world queries.

Structured specifications are the machine-readable layer of product data. Where the description answers "what is it for", specs answer "exactly what is it". They map directly to schema.org Product properties, GMC feed attributes, and LLM comparison queries — and they only work when they're consistent across a catalogue.

Format:

• Use a table or definition list (<dl>/<dt>/<dd>) — not specs buried in prose
• Label names must be consistent across the entire catalogue — "Material" everywhere, not "Fabric" on some, "Composition" on others, "Made from" on a third
• Values should be precise and unambiguous: "280gsm" not "medium weight", "machine wash 30°C" not "easy care"

Key fields to include (where applicable):

• Material / composition
• Weight / dimensions
• Fit / sizing notes (e.g. "runs true to size", "slim through torso")
• Care instructions
• Country of manufacture
• GTIN / barcode — include this visibly on the page where possible; it strengthens feed and schema alignment

On Shopify: Product metafields are the correct place for structured specs. Use Shopify's native metafield definitions (available in the admin since 2022) to create typed metafields (e.g. single_line_text_field, number_decimal) and surface them in your theme via product.metafields. This keeps spec data structured and reusable across feeds, apps, and schema generation — far better than putting everything in the description body.

Google extracts structured product attributes from spec tables and maps them to schema.org properties. Consistent structured data across a catalogue improves eligibility for product-specific rich results.

LLMs use spec data to answer comparative queries: "which jacket is warmest?", "is this machine washable?", "what's the weight of this fabric?" — queries that require structured, numeric, or categorical data. A prose description cannot answer these reliably. A spec table can.

Ratings and reviews serve three jobs simultaneously: social proof for users deciding whether to buy, structured quality signals for Google's Shopping and SERP ranking systems, and real-world sentiment data for LLMs building product recommendations. The aggregate rating drives star snippets in SERPs. Individual review text teaches LLMs what this product is actually like to own.

• Display the aggregate rating in server-rendered HTML above the fold — the number must be visible in the raw page source, not injected by JavaScript
• Mark up with AggregateRating schema: ratingValue and reviewCount are required. The value in schema must match the value on the page — not a rounded version, not a different scale
• Include at least a few individual review bodies in server-rendered HTML. Review apps that load entirely via JavaScript (AJAX after DOM ready) may not be crawled by Google
• Individual reviews should use Review schema with author, reviewRating, and reviewBody

On Shopify: Shopify's native Product Reviews app (now deprecated in favour of native review metafields in some themes) and most third-party review apps (Judge.me, Yotpo, Okendo, Stamped) render reviews via JavaScript by default. Check whether your reviews are in the server-rendered HTML using "View Page Source" — not Inspect, which shows the rendered DOM. If reviews only appear in the rendered DOM, Google may not consistently crawl them.

Google shows star ratings in SERPs when AggregateRating schema is present and valid, the rating value appears on the page, and the page isn't on a blocked category (Google restricts star snippets on certain product types). Stars in SERPs typically improve CTR by 15–20% on product pages.

LLMs use review text to understand product nuance that specs and descriptions don't capture: "runs small — size up", "warm but not bulky, good for layering", "the zip sticks after six months". This context feeds directly into LLM shopping recommendations for users asking "what do people say about this jacket?"