Product Categorization

Product Categorization

Overview

A well-structured product taxonomy makes products findable and drives SEO through category pages. Every platform handles categorization differently: Shopify uses Collections and tags, WooCommerce uses hierarchical Categories and tags, and BigCommerce uses Categories with subcategories. Understanding the platform's native model and configuring it correctly is more impactful than building a custom taxonomy system.

When to Use This Skill

• When building a product catalog that needs a navigable category tree (clothing > women > dresses)
• When migrating a flat product list into a structured taxonomy
• When breadcrumb navigation is missing or generating wrong paths
• When category pages need SEO-optimized URLs and meta tags
• When ingesting large supplier catalogs that need automatic categorization

Core Instructions

Step 1: Understand how your platform handles categories

Choose a depth strategy before building:

• 2–3 levels is optimal for most stores (e.g., Clothing → Womens → Dresses)
• 4 levels maximum — deeper hierarchies confuse shoppers and dilute SEO
• Flat + tags works well for small catalogs (under 200 products)

---

Step 2: Platform-specific setup

---

Shopify

Shopify uses Collections as the primary categorization mechanism. Collections can be manual (hand-curated) or automated (rules-based).

Creating a collection hierarchy:

1. Go to Admin → Products → Collections → Create collection 2. For the "Women's Dresses" example:

• Create a parent collection: "Clothing" (manual, for navigation menu)
• Create a child collection: "Women's Dresses" (automated, rule: tag contains womens-dress)

3. Set the collection's SEO fields: Title, Meta description, and URL handle 4. Add a collection image and description — these improve SEO and conversion on the collection page

Automated collections (rule-based — recommended):

• Set rules like: Product type equals "Dress" AND tags contain "womens"
• Products matching the rules are automatically added — no manual curation needed
• Best for large catalogs where you can't manually assign every product

Manual collections:

• Best for curated edits (e.g., "Summer Picks", "Staff Favorites")
• Add products by hand from the collection edit page

Navigation menu hierarchy:

1. Go to Online Store → Navigation 2. Open the main menu 3. Add each collection as a menu item; nest items by dragging sub-items under parent items 4. This creates the visual hierarchy in your storefront's navigation even though Shopify collections are technically flat

Tags for additional filtering:

• Add product tags like color-red, size-M, material-cotton
• Use a faceted filtering app (Boost Commerce, Searchpie) to turn tags into filterable attributes on collection pages

Breadcrumbs: Most Shopify themes include breadcrumbs automatically. If not:

• Go to Online Store → Themes → Customize
• Search for "breadcrumb" in theme settings — many themes have a toggle
• For Dawn/Debut: breadcrumbs are theme-specific and may need liquid code changes

---

WooCommerce

WooCommerce has hierarchical product categories — the closest to a traditional category tree.

Create a category hierarchy:

1. Go to Products → Categories → Add New Category 2. Create your top-level category: "Clothing" 3. Create a child category: "Women's" — select "Clothing" as the Parent Category 4. Create a grandchild: "Dresses" — select "Women's" as the Parent

WooCommerce generates SEO-friendly URLs automatically:

• Clothing: /product-category/clothing/
• Women's: /product-category/clothing/womens/
• Dresses: /product-category/clothing/womens/dresses/

Assign products to categories:

1. Open a product and go to the Product Categories widget in the sidebar 2. Check all applicable categories (products can belong to multiple categories) 3. Check the Primary category for breadcrumb display (requires Yoast SEO)

Category page SEO:

1. Edit a category: Products → Categories → [Category] → Edit 2. Set a Description (unique text appears above the product grid — important for SEO) 3. Upload a Thumbnail image 4. With Yoast SEO: scroll to the Yoast section on the category edit page and set SEO title and Meta description for each category

Breadcrumbs:

• Install Yoast SEO (free) — it adds breadcrumb navigation automatically
• Or enable breadcrumbs in WooCommerce → Settings → Advanced → Breadcrumbs
• Configure the breadcrumb separator and home label

---

BigCommerce

BigCommerce has a nested category system with unlimited depth.

Create categories:

1. Go to Products → Product Categories → Add 2. Enter the category name, description, and URL (BigCommerce lets you customize the URL) 3. Select a Parent category to nest it 4. Upload a category image 5. Set SEO Title and Meta description for each category

Assign products to categories: 1. Edit a product 2. Under Categories, check all applicable categories 3. BigCommerce supports assigning a product to multiple categories

Category sort order:

• Set sort order per category: manual, price ascending/descending, newest, bestselling
• Configure under the category edit page → Sort Products By

Breadcrumbs: BigCommerce themes include breadcrumbs by default, automatically following the nested category path. Customize the breadcrumb template in your theme's Stencil files if needed.

---

Custom / Headless

For headless storefronts, use a materialized path model for efficient breadcrumb queries:

// Category model with materialized path
interface Category {
  id: string;
  name: string;
  slug: string;
  parentId: string | null;
  path: string;       // e.g., "clothing/women/dresses" — ancestor slugs joined by /
  pathIds: string[];  // IDs for fast joins: ['cat_root', 'cat_clothing', 'cat_women', 'cat_dresses']
  depth: number;
  position: number;   // Sort order among siblings
  published: boolean;
  seoTitle?: string;
  seoDescription?: string;
}

// Get breadcrumbs in one query using materialized path
export async function getCategoryWithBreadcrumb(slug: string) {
  const category = await db.categories.findUnique({ where: { slug } });
  if (!category) return null;

  // Fetch all ancestors in one query using pathIds
  const ancestors = await db.categories.findMany({
    where: { id: { in: category.pathIds.slice(0, -1) } },
    orderBy: { depth: 'asc' },
  });

  return {
    ...category,
    breadcrumbs: [
      ...ancestors.map(a => ({ name: a.name, url: `/c/${a.path}` })),
      { name: category.name, url: `/c/${category.path}` },
    ],
  };
}

// Update materialized paths when a category is moved
export async function moveCategory(categoryId: string, newParentId: string | null) {
  const category = await db.categories.findUnique({ where: { id: categoryId } });
  const newParent = newParentId ? await db.categories.findUnique({ where: { id: newParentId } }) : null;

  const newPath = newParent ? `${newParent.path}/${category.slug}` : category.slug;
  const newPathIds = newParent ? [...newParent.pathIds, categoryId] : [categoryId];

  // Update this category and all descendants in a transaction
  const descendants = await db.categories.findMany({ where: { path: { startsWith: category.path + '/' } } });

  await db.$transaction([
    db.categories.update({
      where: { id: categoryId },
      data: { parentId: newParentId, path: newPath, pathIds: newPathIds, depth: newPath.split('/').length },
    }),
    ...descendants.map(desc => db.categories.update({
      where: { id: desc.id },
      data: {
        path: desc.path.replace(category.path, newPath),
        pathIds: [...newPathIds, ...desc.pathIds.slice(category.pathIds.length)],
        depth: desc.path.replace(category.path, newPath).split('/').length,
      },
    })),
  ]);
}

---

Step 3: Optimize category pages for SEO

Regardless of platform, every category page needs:

1. Unique description: 100–200 words of original text describing what's in this category. "Shop women's dresses" is not enough — describe the styles, materials, occasions. 2. Category image: A hero or banner image relevant to the category 3. SEO title: Format — [Category Name] | [Store Name] (e.g., "Women's Dresses | YourStore") 4. Meta description: 150–160 characters highlighting what makes your selection unique 5. Canonical URL: The category's clean URL without filter parameters (e.g., /clothing/womens/dresses, not /clothing/womens/dresses?color=red)

Canonical URLs for filtered pages:

• Shopify: themes handle this automatically for collection pages
• WooCommerce + Yoast SEO: Yoast sets the canonical automatically
• BigCommerce: set canonicals in category settings

---

Step 4: Bulk-assign categories for large catalogs

For catalogs with hundreds or thousands of products to categorize:

Shopify:

• In Admin → Products, select multiple products using the checkboxes
• Click Bulk actions → Add to collection to assign them all at once
• For automated collections, products are assigned automatically when they match the rules

WooCommerce:

• Use WP All Import to bulk-assign categories via CSV
• Or use the Products Bulk Edit in WooCommerce admin

AI-assisted categorization (any platform):

• Export your product catalog with titles and descriptions
• Use an AI tool to suggest categories based on product content
• Import the suggested categories back in bulk using Matrixify (Shopify) or WP All Import (WooCommerce)
• Always review AI suggestions for accuracy before publishing

Best Practices

• Use automated (rule-based) collections on Shopify for the main taxonomy — they self-update as products are added; manual collections are for curated editorial picks
• Write unique descriptions for every category page — pages without descriptions are thin content and rarely rank; even 100 words of original text makes a meaningful SEO difference
• Limit depth to 3 levels for most stores — the extra specificity of level 4 rarely helps SEO and creates navigation complexity
• Use tags for cross-cutting attributes (color, material, occasion) rather than categories — tags power faceted filtering without multiplying your category tree
• Update paths in a transaction when moving categories — a partially updated tree creates broken breadcrumbs; always update the category and all its descendants atomically

Common Pitfalls

Related Skills

• @product-data-modeling
• @product-content-enrichment
• @catalog-import-export

Category Reorganization and Breadcrumb Navigation

Problem/Feature Description

HomeGoods Co. recently acquired a competitor and is merging the two product catalogs. The combined store now needs a significant category restructuring: several sub-trees that were at the top-level in the acquired catalog must be moved under existing HomeGoods categories, and the navigation system must display correct breadcrumbs on every category page after the move.

The existing system stores categories in a relational database using a hierarchical data model. The development team is concerned about three things: (1) if a large sub-tree of categories is moved, they don't want to end up with a partially updated state if something fails mid-way; (2) breadcrumb generation currently requires one query per level, which is too slow; (3) the full category tree for the mega-menu must be rendered in a consistent order.

Your task is to implement the server-side functions that handle category reorganization and breadcrumb generation.

Output Specification

Produce the following files:

1. lib/categoryOps.js (or .ts) — A module containing:

• moveCategory(categoryId, newParentId) — moves a category and its entire sub-tree to a new parent
• getCategoryWithBreadcrumb(slug) — returns a category with its breadcrumb trail
• getCategoryTree(rootSlug?) — returns the full published category tree as a nested structure

2. test-scenario.md — A short walkthrough showing what the state of the database would look like for a sample move (e.g. moving "Kitchen > Cookware" under "Cooking & Baking"), demonstrating path values before and after.

The DB client can be mocked/stubbed — focus on the logic and data transformations. Show the data shapes clearly in the code.

Input Files

The following files are provided as inputs. Extract them before beginning.

=============== FILE: inputs/sample-categories.json =============== [ { "id": "cat_root", "name": "Root", "slug": "root", "parentId": null, "path": "root", "pathIds": ["cat_root"], "depth": 0, "position": 0, "published": true }, { "id": "cat_kitchen", "name": "Kitchen", "slug": "kitchen", "parentId": "cat_root", "path": "root/kitchen", "pathIds": ["cat_root","cat_kitchen"], "depth": 1, "position": 1, "published": true }, { "id": "cat_cookware", "name": "Cookware", "slug": "cookware", "parentId": "cat_kitchen", "path": "root/kitchen/cookware", "pathIds": ["cat_root","cat_kitchen","cat_cookware"], "depth": 2, "position": 1, "published": true }, { "id": "cat_pans", "name": "Pans", "slug": "pans", "parentId": "cat_cookware", "path": "root/kitchen/cookware/pans", "pathIds": ["cat_root","cat_kitchen","cat_cookware","cat_pans"], "depth": 3, "position": 1, "published": true }, { "id": "cat_baking", "name": "Baking", "slug": "baking", "parentId": "cat_root", "path": "root/baking", "pathIds": ["cat_root","cat_baking"], "depth": 1, "position": 2, "published": true } ]

Category System Foundation for a New Fashion Store

Problem/Feature Description

A new online fashion retailer, StyleHive, is launching a web store that will eventually carry tens of thousands of products across a deep hierarchy of clothing, accessories, and footwear. The tech lead needs a solid foundation for the product category system before the first product import next week.

The store has a relatively complex taxonomy: top-level divisions (Clothing, Footwear, Accessories), then gender or age groups, then product type, and sometimes a style sub-type — so paths like "clothing > women > dresses > evening" are expected. Navigation needs to be fast and SEO-friendly from day one, and the team wants to avoid painful data-migration work later if the hierarchy is reorganized.

Your job is to design and implement the core data model and category library that the rest of the application will depend on. The engineering team has heard of several approaches to storing hierarchical data in a relational database and wants you to pick the right one and justify it briefly. They are using a Node.js/TypeScript stack with Prisma as the ORM.

Output Specification

Produce the following files in your working directory:

1. schema.prisma (or schema.sql) — The Prisma schema (or SQL DDL) for the Category model, with all fields the team will need for navigation, sorting, SEO, and publishing workflow. 2. lib/categories.js (or .ts) — A module with at least:

• A function to fetch a single category by slug (including breadcrumb data)
• A function to retrieve the full published category tree

3. DESIGN.md — A short (1–2 page) design document explaining the chosen data storage approach, how breadcrumb retrieval works, and any constraints enforced in the schema.

You do not need to set up a real database connection — stub or comment out DB calls where needed, but make sure the logic and data structures are clearly shown.

SEO Boost and Bulk Catalog Import for an Outdoor Gear Store

Problem/Feature Description

TrailPeak is an outdoor gear retailer that has seen its organic search traffic plateau. A web performance audit found two root causes: (1) category pages lack proper structured data and have inconsistent meta tags that cause Google to generate its own titles and descriptions; (2) a recent partnership with a large equipment supplier added 4,000 raw products that are still sitting unorganized in a staging table because manually assigning them to categories would take weeks.

The engineering team wants to fix both problems in a single sprint. For SEO, every category page needs a well-structured meta tag set including an explicit canonical URL, Open Graph tags, and JSON-LD structured data that search engines can parse for rich results. For the bulk import, they want an automated first pass that places each raw product into the most likely categories, with a lightweight review step so the merchandising team can spot-check edge cases before they go live.

Output Specification

Produce the following files:

1. lib/categorySeo.js (or .ts) — A function getCategoryMeta(category, productCount) that returns an object with meta title, description, canonical URL, openGraph tags, and JSON-LD structured data for a given category.

2. lib/autoCategorize.js (or .ts) — A function suggestCategories(product, categoryTree) that uses an LLM to suggest the most appropriate categories for a product given the available category tree.

3. categorize-batch.js (or .ts) — A runnable script that:

• Reads products from the provided inputs/products.json
• For each product, calls suggestCategories and records the results
• Writes output/categorization-results.json with each product's suggested category IDs and a field indicating whether human review is needed
• Includes inline comments explaining the review criteria

You do not need to make live API calls — stub or mock the LLM calls. The logic, prompts, parameters, and data structures should be clearly visible in the code.

Input Files

The following files are provided as inputs. Extract them before beginning.

=============== FILE: inputs/products.json =============== [ { "id": "prod_001", "title": "Merino Wool Base Layer Top", "description": "Lightweight 150gsm merino wool long-sleeve top, ideal for hiking and backpacking in variable conditions. Odor-resistant, moisture-wicking, machine washable." }, { "id": "prod_002", "title": "10L Ultralight Daypack", "description": "Minimalist 10-liter pack for day hikes and trail running. Includes hydration sleeve, trekking pole loops, and reflective strips. Weighs 280g." }, { "id": "prod_003", "title": "Titanium Camping Cookset", "description": "Two-piece titanium pot and pan set with folding handles. Suitable for backpacking stoves. Total weight 220g, fits 2 persons." } ]

=============== FILE: inputs/category-tree.json =============== [ { "id": "cat_clothing", "name": "Clothing", "slug": "clothing", "path": "clothing", "depth": 0, "children": [ { "id": "cat_base", "name": "Base Layers", "slug": "base-layers", "path": "clothing/base-layers", "depth": 1, "children": [] }, { "id": "cat_mid", "name": "Mid Layers", "slug": "mid-layers", "path": "clothing/mid-layers", "depth": 1, "children": [] } ] }, { "id": "cat_packs", "name": "Packs & Bags", "slug": "packs-bags", "path": "packs-bags", "depth": 0, "children": [ { "id": "cat_daypacks", "name": "Daypacks", "slug": "daypacks", "path": "packs-bags/daypacks", "depth": 1, "children": [] }, { "id": "cat_overnight", "name": "Overnight Packs", "slug": "overnight-packs", "path": "packs-bags/overnight-packs", "depth": 1, "children": [] } ] }, { "id": "cat_camp", "name": "Camp & Hike", "slug": "camp-hike", "path": "camp-hike", "depth": 0, "children": [ { "id": "cat_cooking", "name": "Cooking & Nutrition", "slug": "cooking-nutrition", "path": "camp-hike/cooking-nutrition", "depth": 1, "children": [] } ] } ]