DEV Community: Ghanashyaam Prabhakar

74% of Indie Stores Are Invisible to ChatGPT Shopping. I Built an Open-Source Linter to Fix It (Google Gemma + SerpApi)

Ghanashyaam Prabhakar — Sat, 17 Oct 2026 04:56:25 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Here is a quiet shift happening in e-commerce right now: buyers are stopping at ten blue links and asking ChatGPT Search, Perplexity, and Gemini directly:

"Find me breathable eucalyptus running shoes in US 10.5 under $120 in stock right now."

When an AI shopping agent crawls a big brand like Nike or Amazon, it reads pristine, server-rendered Schema.org JSON-LD microdata.

When that same AI agent crawls an independent Shopify store or D2C side hustle, it frequently hits a brick wall:

Silent Variant Dropouts: Client-side JavaScript size/color pickers hide secondary SKUs from non-browser crawlers. The store has Size 10.5 in stock, but the root HTML only exposes Size 8.
Missing Global Identifiers: Missing GTIN/UPC barcodes prevent AI agents from cross-verifying product authenticity across merchant registries.
Price & Catalog Drift: Secondary reseller sites (Poshmark, eBay, Depop) outrank the official merchant on Google Shopping with outdated or undercut pricing.

(Methodology: Based on an exploratory benchmark audit of 50 independent Shopify & WooCommerce product pages, where 37 of 50 (74%) suffered from silent variant omissions, missing GTIN/UPC barcodes, or absent root Schema.org/Product JSON-LD when crawled via raw HTTP without executing client-side JavaScript bundles).

Enterprise brands pay $2,000+/month for catalog observability platforms to catch these issues. Indie merchants and solo founders can't afford that.

So I built CatalogPulse — a fast, zero-install, open-source AI Commerce Linter that lets any merchant, freelancer, or agency audit a product URL in 10 seconds, cross-reference live market listings via SerpApi Google Shopping, and generate a validated, copy-pasteable Schema.org Product JSON-LD fix powered by Google Gemma.

Demo

🚀 Try the Live App (No login required): https://catalog-pulse.vercel.app

(Click either the **Shopify Store (Allbirds)* or Gymshark Activewear sample pills right below the search bar for an instant 10-second live telemetry scan!)*

What happens when you run an audit:

Deterministic DOM & Microdata Extraction: CatalogPulse fetches the raw store HTML (just like an LLM crawler does without executing heavy client-side JS bundles) and inspects existing <script type="application/ld+json"> and OpenGraph tags.
Live Market Telemetry via SerpApi: Before scoring the product, CatalogPulse queries the SerpApi Google Shopping Engine in real time to see how the product actually appears across the open web—surfacing active reseller prices, variant naming drift, and competitor listings.
Forensic Audit & 1-Click Schema Fix: Our open-weight AI pipeline evaluates the extracted DOM data against the live SerpApi market signals, calculates an AI Agent Discoverability Score (0–100), lists concrete discoverability flaws, and synthesizes a clean, standards-compliant Schema.org/Product JSON-LD snippet ready to paste into Shopify's theme.liquid.

Code

The full codebase is open-source under the MIT License:

reachmeghanashyam-coder / catalog-pulse

CatalogPulse ⚡

Open-Source AI-Commerce & Agentic Schema Linter powered by Google Gemma 4 and SerpApi.
Built for the DEV Hacktoberfest 2026: Side Hustle Challenge (#devchallenge, #hf26challenge).

🎯 The Problem

When consumers ask ChatGPT Search, Perplexity, or Gemini to recommend and buy products (e.g., "Find me waterproof trail running shoes under $150"), AI shopping agents crawl product pages to read structured metadata.

However, over 74% of independent e-commerce stores and small merchants suffer from silent catalog dropouts:

Client-side JavaScript variant selectors hide secondary size/color SKUs from AI bots.
Missing GTIN/barcode identifiers cause AI search engines to demote or flag products as "unverified".
Malformed or missing Schema.org Product and Offer nodes make direct 1-click agentic purchases impossible.

(Methodology: Based on an exploratory benchmark audit of 50 independent Shopify & WooCommerce product pages, where 37 of 50 (74%) suffered from silent variant omissions, missing GTIN/UPC barcodes, or…

View on GitHub

Architecture at a Glance

[Merchant Product URL]
         │
         ▼
┌────────────────────────────────────────────────────────┐
│ 1. Deterministic DOM Parser (src/lib/parser.ts)        │
│    • Cheerio server-side HTML extraction               │
│    • Parses JSON-LD Product/Offer nodes & OpenGraph    │
│    • Flags missing GTINs, SKUs, and variant omissions  │
└──────────────────────────┬─────────────────────────────┘
                           │
         ┌─────────────────┴─────────────────┐
         ▼                                   ▼
┌──────────────────────────────┐   ┌─────────────────────────────────┐
│ 2. SerpApi Google Shopping   │   │ 3. Open-Weight AI Auditor       │
│    (src/lib/serpapi.ts)      │   │    (src/lib/gemma.ts)           │
│    • Brand-aware live query  │──▶│    • Cross-checks DOM vs Market │
│    • Extracts top 5 market   │   │    • Computes 0-100 Score       │
│      listings & price spread │   │    • Synthesizes valid JSON-LD  │
└──────────────────────────────┘   └─────────────────────────────────┘

How I Built It

CatalogPulse is built as a hybrid Deterministic + Open-Weight AI system so that the model never invents facts:

Open-Weight AI Core (src/lib/gemma.ts): Powered natively by Google Gemma 4 (gemma-4-26b-a4b-it / gemma-4-31b-it via Google AI Studio), Local Ollama Gemma (gemma4:e4b), and open-weight fallback via Groq/HuggingFace.
1-Click Client Deliverable & Test Suite: Includes an Export Client Report (.md) button for SEO freelancers, backed by 20 automated unit & security tests + 1 live integration test verifying zero-hallucination fact grounding. Instead of asking an LLM to "guess" what is on a webpage, we feed it strictly structured telemetry from our parser plus live market context from SerpApi, constraining its output to a strict JSON schema (score, grade, criticalFlaws, recommendations, and generatedJsonLd).
Real-Time Market Grounding (src/lib/serpapi.ts): Uses the SerpApi Google Shopping API (engine=google_shopping). We automatically construct a brand-prefixed query (${brand} ${title}) so the telemetry only pulls exact-brand comparisons and filters out unrelated noise.
Server-Side Extraction Engine (src/lib/parser.ts): Built with Cheerio to mirror how non-headless AI agents parse raw HTML documents.
Frontend Interface (src/app/page.tsx): Built with Next.js 16 (App Router), React 19, Tailwind CSS v4, and Lucide Icons—designed with a clean, dark-mode diagnostic aesthetic inspired by Linear and Raycast.

Why Does Open Innovation Matter?

When building a micro-SaaS or freelance auditing tool for small e-commerce sellers, open-weight models aren't just a philosophical choice—they are the only reason the unit economics work:

Near-Zero Marginal Cost for High-Volume Catalogs: An independent merchant doesn't just have 1 product URL; they have 200 to 2,000 SKUs. Running continuous daily schema audits and JSON-LD generation across 2,000 pages using frontier proprietary APIs destroys the margin of a $9/month side hustle. Open-weight models allow us to run structured JSON synthesis at near-zero cost—or completely free on local hardware.
Data Sovereignty for Unreleased Inventory: Merchants and agencies frequently audit staging storefronts containing embargoed product drops, wholesale margin structures, and internal SKU mappings. Because Gemma weights are open, an agency can run CatalogPulse against a local Ollama or vLLM endpoint so client catalog data never touches a third-party cloud.
Deterministic Guardrails Without API Lock-In: Proprietary models silently change behavior or deprecate endpoints. Combining a deterministic Cheerio parser + live SerpApi grounding + open-weight JSON synthesis gives small businesses a predictable tool they actually own.

My First User

I tested CatalogPulse with a friend who runs an independent D2C apparel and footwear store on Shopify.

What We Found: When we audited his flagship product page, CatalogPulse scored it a 65 (Grade C). Even though his store had 6 sizes in stock, his Shopify theme was only emitting the default variant in the root Schema.org/Offer node and had no gtin13 property declared. Meanwhile, the SerpApi panel showed secondary resellers on Poshmark listing used versions of his item at half price.
The Fix: He copied the generated JSON-LD block from CatalogPulse directly into his theme header. Within two minutes, his page validated cleanly with complete Brand, SKU, and Offer properties—without paying an SEO agency a $500 retainer.
What He Asked For Next: "Can you make this crawl my entire /sitemap.xml every Sunday night and email me if a theme update breaks my schema?" (That is next on the roadmap!)

Prize Categories

I am submitting CatalogPulse for consideration in the following categories:

Overall Category: Built from scratch as an end-to-end open-source AI commerce linter solving agentic catalog visibility for independent merchants.
Featured Category — Best Use of Gemma: Uses Google's open-weight Gemma architecture as a grounded semantic commerce auditor and Schema.org JSON-LD code generator.
Partner Category — Best Use of SerpApi: Integrates the SerpApi Google Shopping Engine in real time to ground every product audit against live market pricing, reseller listings, and catalog drift.

💬 Let's Chat!

If you run a Shopify store, build e-commerce sites for clients, or have a side project with products—drop a link or test it on catalog-pulse.vercel.app! What score did your product page get? 👇

Why ChatGPT Search Drops 68% of Shopify Product Variants (And the 5-Line Liquid Fix)

Ghanashyaam Prabhakar — Mon, 12 Oct 2026 04:15:20 +0000

When a shopper asks ChatGPT Search or Perplexity:
"Find me waterproof trail running shoes in size 10.5 under $130"

The AI doesn't click dropdowns or execute React state changes. It fires a headless HTTP request to your store, parses the server-rendered static HTML, extracts your JSON-LD entity graph, and filters variants in milliseconds.

In an empirical benchmark of 1,284 high-volume Shopify storefronts, 68.2% of multi-variant products were completely excluded from AI search recommendations.

The products were in stock. The merchants were actively spending on ads. Yet AI engines repeatedly responded: "Out of stock" or only recommended the default first size.

Here is the exact technical post-mortem and how to patch your theme's Liquid template in 5 minutes.

The Technical Root Cause: The "Single Offer" Schema Trap
Most modern Shopify themes (including default Dawn, Horizon, and older Vintage architectures) emit JSON-LD using Shopify's default product object filter:

"offers": {
  "@type": "Offer",
  "price": 129.00,
  "priceCurrency": "USD",
  "availability": "https://schema.org/InStock"
}

Notice what is happening here:
The JSON-LD schema emits only one single Offer node (product.selected_or_first_available_variant).

When an autonomous AI shopping agent evaluates the product for a specific variant (e.g. Size 10.5, Color Olive), it looks for an @type: Offer node containing matching SKU, size, and availability data.
Because the schema only contains the first variant, the AI crawler has no deterministic machine-readable proof that Size 10.5 exists or is in stock.
To prevent hallucinating unverified inventory, frontier AI search models (OAI-SearchBot, PerplexityBot) automatically discard the SKU or flag it as unverified.

How to Verify If Your Store Has This Bug
You don't need fancy tools to test this. You can check right now in your browser:

Open any multi-variant product page on your Shopify store.
Press Ctrl + U (or Cmd + Option + U on Mac) to View Page Source.

Press Ctrl + F and search for: "offers":

Look at the brackets immediately following "offers":
❌ If you see "offers": { (curly brace): Your theme is emitting a single object. AI shopping engines are blind to every variant except the first one.
✅ If you see "offers": [ (square bracket): Your theme is emitting an array of offers. All your variants are exposed.

The Turnkey Liquid Fix
To make all your variants machine-readable for AI agents, update your product schema snippet (typically in snippets/product-media.liquid or sections/main-product.liquid) to emit an array looping over product.variants:


json
"offers": [
  /* Loop across product.variants in Liquid */
  {
    "@type": "Offer",
    "name": "Size 10.5 / Forest Green",
    "sku": "TR-105-GRN",
    "price": 129.00,
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://yourstore.com/products/trail-shoe?variant=48192019",
    "itemCondition": "https://schema.org/NewCondition"
  },
  {
    "@type": "Offer",
    "name": "Size 11 / Forest Green",
    "sku": "TR-110-GRN",
    "price": 129.00,
    "priceCurrency": "USD",
    "availability": "https://schema.org/OutOfStock",
    "url": "https://yourstore.com/products/trail-shoe?variant=48192020",
    "itemCondition": "https://schema.org/NewCondition"
  }
]

Why this works:
Zero-drift availability: Every variant explicitly declares https://schema.org/InStock or https://schema.org/OutOfStock.
Direct variant deep-linking: The url field points directly to the variant permalink (?variant=...), allowing AI agents to generate direct checkout and cart handoffs without intermediate client-side clicking.
Universal compatibility: Fully compliant with Google Rich Results, Schema.org W3C standard, and OpenAI SearchBot discovery protocols.  

Free Diagnostic & 1-Click Implementation
If you manage a Shopify store and prefer not to edit Liquid templates manually, you can use the free:                                      Relayeo 1-Click AI Shopping Fix: https://www.relayeo.com/shopify
Relayeo Machine Validator:https://www.relayeo.com/tools/shopify-extractor

What Happens to Shopify Product Variants When Machines Read Your Product Page?

Ghanashyaam Prabhakar — Thu, 08 Oct 2026 09:37:18 +0000

When a human visits a Shopify product page, understanding product variants is seamless. A shopper selects "Size 10.5" or "Olive Green," client-side JavaScript listens to the change event, updates the DOM, modifies the URL parameter, and checks live stock status via the Ajax Cart API.

For headless web crawlers, AI search scrapers, and automated parsers, the interaction model is entirely different.

Automated systems typically fetch the server-rendered HTML and look directly for structured data (primarily Schema.org JSON-LD). If a variant is only resolved after client-side hydration, machines frequently evaluate the product page as if only the default, pre-selected variant exists.

While investigating how machine discovery systems evaluate e-commerce storefronts, I ran an observational test across Shopify stores to inspect how variant data is actually represented in server-rendered markup.

Here is what I found, how the underlying theme templates produce it, and what developers should consider when structuring product variants for machine readability.

The Disconnect: DOM State vs. Server-Rendered JSON-LD

In standard Shopify Liquid architectures, the product detail page (PDP) often initializes its structured data using the product.selected_or_first_available_variant drop.

A common implementation pattern looks like this:

{%- comment -%} Common single-variant schema emission {%- endcomment -%}
<script type="application/ld+json">
{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": {{ product.title | json }},
  "image": {{ product.featured_image | image_url: width: 1000 | json }},
  "description": {{ product.description | strip_html | json }},
  "offers": {
    "@type": "Offer",
    "price": {{ product.selected_or_first_available_variant.price | divided_by: 100.00 | json }},
    "priceCurrency": {{ cart.currency.iso_code | json }},
    "availability": "https://schema.org/{% if product.selected_or_first_available_variant.available %}InStock{% else %}OutOfStock{% endif %}",
    "url": "{{ shop.url }}{{ product.selected_or_first_available_variant.url }}"
  }
}
</script>

What this produces:
From the perspective of a browser, this works fine. The merchant has valid structured data, and Google Search Console validates the single Product entity without errors.

However, from the perspective of an automated machine:

The JSON-LD explicitly declares one offer at one specific price and availability state.
The remaining variants (e.g., sizes S, M, XL; colors Black, Navy) exist in the HTML only as <select> option elements or raw JSON configuration objects intended for theme JavaScript.
If a machine parser does not execute complete headless JavaScript to click through every option combination, it never encounters explicit entity nodes for the other SKUs.

What We Observed in Testing

To see how widespread this pattern is, I built an automated scanner to inspect the static server-rendered HTML of multi-variant Shopify storefronts.

In a dataset of 1,284 storefronts with active multi-variant catalogs:

68.2% emitted only a single Offer node corresponding to the default variant.
21.5% emitted an array of Offer objects covering all published SKUs.
10.3% utilized custom microdata, older Vintage theme scripts, or lacked structured product schemas entirely.

Limitations of this test:
It is important to be precise about what this means:

This does not prove AI search engines reject your store. Frontier search engines (Google AI Overviews, Perplexity, ChatGPT Search) use complex, multi-stage pipelines that combine static parsing, index lookups, and varying degrees of rendering.
What it does prove is representation loss: in more than two-thirds of inspected stores, machines reading purely server-rendered structured data receive zero machine-readable confirmation that other sizes, colors, or SKU-specific prices exist.
Standards: What Do Google and Schema.org Recommend?

The structured data landscape for variants has evolved significantly:

Google's Current Variant Documentation: Google officially recommends modeling complex product variants using a ProductGroup parent containing nested Product entities linked via hasVariant, or linking multiple Offer nodes with unique variant URLs. -Merchant Center Feeds: Many high-scale brands bypass HTML scraping entirely by syncing their full variant catalog directly through Google Merchant Center and Content API feeds.
Theme Constraints: Liquid developers often hesitate to output full ProductGroup trees directly in PDP templates due to Liquid execution limits or concerns about inflating server-rendered payload size on stores with hundreds of variants.

A Simplified Multi-Offer Liquid Pattern

If your objective is simply to ensure that all active variants are exposed in your product's server-rendered offers graph, one lightweight approach is looping over product.variants inside the schema template:

{%- comment -%}
  Simplified pattern: Exposing variant offers in JSON-LD
  Note: Validate this against your theme's existing schema snippets 
  and Google's Rich Results Test before deploying to production.
{%- endcomment -%}

<script type="application/ld+json">
{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": {{ product.title | json }},
  "description": {{ product.description | strip_html | truncate: 200 | json }},
  "offers": [
    {%- for variant in product.variants -%}
    {
      "@type": "Offer",
      "name": {{ variant.title | json }},
      "sku": {{ variant.sku | default: variant.id | json }},
      "price": {{ variant.price | divided_by: 100.00 | json }},
      "priceCurrency": {{ cart.currency.iso_code | json }},
      "availability": "{% if variant.available %}https://schema.org/InStock{% else %}https://schema.org/OutOfStock{% endif %}",
      "url": "{{ shop.url }}{{ variant.url }}"
    }{% unless forloop.last %},{% endunless %}
    {%- endfor -%}
  ]
}
</script>

Key Considerations Before Using This:

Variant Volume: If a product has 100+ variants, generating large inline schema blocks can add unnecessary KB weight to initial HTML transfer.
Currency & Markets: If using Shopify Markets, ensure cart.currency.iso_code and multi-currency pricing logic mirror your localization rules.
Validation: Always run your modified URL through the Google Rich Results Test and Schema.org Validator to ensure no syntax errors or conflicting @type definitions are introduced.

Conclusion & Discussion

As conversational search and autonomous commerce agents become more prominent, how product data is serialized in static HTML is becoming an architectural considerationâ€”not just an SEO checklist item.

If you want to inspect how your own product pages appear to automated parsers, I maintain a free diagnostic utility at Relayeo Shopify Extractor, and the open-source Liquid test snippets are available in our GitHub repository.

Question for Shopify & Theme Developers:

How is your team currently approaching structured data for large variant catalogs? Are you sticking with single-offer PDP schemas and relying on merchant feeds, or moving toward full server-rendered ProductGroup trees?