How-To Guide 8 min read

How to Find Every Page a Shopify Template Actually Touches

You QAโ€™d the product page. There are four product templates and six hundred products, and one of those templates is on a single SKU that happens to be the bestseller.

TS
ThemeSync Team
ThemeSync template mapping listing six store URLs and their alternate templates
Every mapped URL and the template it renders.

Why template coverage is usually wrong

Shopify QA tends to be organised around page types: check the homepage, a product page, a collection page, the cart. That's the right instinct and it produces a coverage gap, because a store doesn't have "a product page." It has however many product templates someone has created over the years.

Alternate templates are invisible from the storefront. Nothing on a product URL indicates it renders product.bundle rather than product. The assignment lives on the product record, so the only way to know is to look product by product โ€” which nobody does for six hundred products.

So templates go untested. And there's a nasty asymmetry: alternate templates are usually assigned to the commercially unusual products โ€” bundles, pre-orders, gift cards, subscription items. Low record counts, disproportionate revenue.

The worst version: a template assigned to exactly one product, and that product is the bestseller. It's statistically invisible in any sampling approach and it's the page that matters most.

Step one: enumerate the templates

Start from the theme, which is the one place the full list definitely exists:

Every template in the theme
ls templates/

# index.json
# product.json
# product.bundle.json
# product.preorder.json
# collection.json
# collection.sale.json
# page.json
# page.contact.json
# page.lookbook.json
# ...

Anything with a suffix โ€” product.bundle, collection.sale, page.lookbook โ€” is an alternate template that renders only where it's been assigned or forced with ?view=.

That's your denominator. If your QA pass covered fewer URLs than there are templates here, you have gaps, and now you know how many.

Do this before quoting a QA pass. "Test the theme" on a store with thirty-two templates is a materially different job from one with fifteen. This is a five-second check that protects a fixed-price estimate.

Step two: find a real URL for each

Knowing product.bundle exists doesn't tell you where to look at it. You need a representative live URL per template, and there are three ways to get them.

Three routes to a real url per template
  1. Admin APImost reliable

    List products, collections and pages with their template suffix. Exact and fast.

  2. Sitemap crawlfallback

    Enumerate live URLs when API access is limited. Good coverage, no assignment data.

  3. Ask the merchantcontext

    "Which products are bundles?" They know their catalogue better than any query.

Record the mapping once. Reuse it for every QA pass.

The API route

Products carry their template assignment, so you can list everything and group by template:

Products with their assigned template
GET /admin/api/2024-10/products.json?limit=250&fields=id,title,handle,template_suffix

# Group by template_suffix:
#   ""         -> product.json          (540 products)
#   "bundle"   -> product.bundle.json   (38 products)
#   "preorder" -> product.preorder.json (15 products)

An empty template_suffix means the default template. Pages and collections work the same way, so a handful of requests gives you complete assignment data for the store.

The sitemap route

When you only have theme access, /sitemap.xml enumerates every indexable URL. It won't tell you which template each uses, but it does tell you the store has 600 products, 40 collections and 12 pages โ€” which is enough to know whether the six URLs you tested were representative.

Ask the merchant

Undervalued and often fastest. "Which products use a different layout?" gets you the answer in one message, plus context no query provides โ€” which ones matter commercially, which are seasonal, which are about to be retired.

Step three: prioritise by revenue, not by count

Full coverage isn't always the goal. Deliberate coverage is. Once you know templates and assignments, rank by what a defect would cost.

PriorityTemplatesWhy
AlwaysHome, default product, default collection, cartHighest traffic, and the cart is where a bug costs money directly
AlwaysAny template on a top-ten productLow record count, high revenue โ€” the asymmetry that catches people
UsuallySearch, 404, account, passwordFrequently skipped, and visibly broken when they are
UsuallyAlternate collection templatesOften used for campaigns with paid traffic pointed at them
Scope itLong-tail page templatesLegitimate to defer โ€” but say so, don't just skip it
Confirm firstTemplates with zero assignmentsDead template, or one that's about to be used?
Make the coverage list a deliverable. "We tested these 14 of 32 templates, chosen by traffic and revenue; these 18 are out of scope" is a professional position. Silent partial coverage that surfaces as a bug report is not.

Step four: record it once, reuse it forever

The expensive part of all this is discovery, and most teams throw it away. Next sprint, someone works out which product is a bundle all over again.

New scan dialog with mapped pages selected
The same page list feeds QA screenshots.

Written down, the mapping becomes reusable infrastructure:

  • Every QA pass starts from a complete list. No rediscovery, no accidental gaps.
  • Screenshot runs cover the store. Automated capture is only as good as the URL list you hand it.
  • Client reviews are scoped. The same list becomes what the client is asked to look at.
  • New templates are visible. If the theme has a template your mapping doesn't, someone added one โ€” worth knowing.
Re-run discovery each project, not each sprint. Catalogues change; a bundle product may have been unpublished. A quick re-check at project start catches templates that have quietly become unused, or newly used.

How ThemeSync handles this

  • Template mapping is the core of it. Each template in the theme is paired with the real store URL it should be previewed on, so the mapping is recorded once and reused.
  • Real records come from read-only Admin API access. Products, collections, pages, blogs and articles are listed from the store, so you pick an actual bundle product rather than guessing a handle.
  • A sitemap fallback covers limited access. When API scopes aren't available, URLs can be discovered from the store's sitemap instead, and those entries are marked so you know how they were found.
  • Custom URLs handle the edge cases. Templates that don't map cleanly to a catalogue record can be pointed at any URL you specify.
  • Screenshot runs use the mapping directly. One capture covers every mapped template across desktop, tablet and phone, so coverage matches the list rather than whatever someone remembered.
  • The client review portal uses the same list. What you QA and what the client is asked to approve are the same set of pages.

Takeaways

  • A store doesn't have "a product page" โ€” it has as many product templates as someone has created.
  • Template assignment lives on the record, not the URL, so alternates are invisible from the storefront.
  • Alternate templates cluster on commercially unusual products: bundles, pre-orders, gift cards. Low counts, high revenue.
  • ls templates/ gives you the denominator in five seconds. Do it before quoting.
  • Get assignments from the Admin API, fall back to the sitemap, and ask the merchant โ€” they know which products matter.
  • Prioritise by revenue, not record count, and make your coverage list a stated deliverable.
  • Record the mapping once. Rediscovering it every sprint is where the time actually goes.

Know every page your theme renders

ThemeSync maps each template to a real store URL using read-only catalogue access, with a sitemap fallback โ€” then captures the whole set across devices in one run.

Try ThemeSync Free →