SKU Structure: Hyphen-Separated Component Architecture

This article explains how our SKU (Stock Keeping Unit) system uses a hyphen-separated structure to uniquely identify every product configuration while enabling powerful feature extraction and filtering.

The Problem: Identifying Product Configurations

A mini PC can have thousands of configurations:

  • Chassis: Treo, S, H (different form factors)

  • Board: N100, i5-1335U, i7-1355U (different processors)

  • RAM: 4GB, 8GB, 16GB, 32GB, 64GB

  • Flash: 128GB, 256GB, 512GB, 1TB, 2TB

  • Adapter: 2H (2 HDMI), 2D (2 DisplayPort), 1H1D (1 HDMI + 1 DisplayPort)

  • WiFi: W6 (WiFi 6), W6E (WiFi 6E), None

  • OS: 11P (Windows 11 Pro), U (Ubuntu), DOS (FreeDOS)

  • Accessories: Keyboard, mouse, VESA mount, etc.

With 3 chassis × 10 boards × 5 RAM × 5 flash × 5 adapters × 3 WiFi × 3 OS = 33,750 possible configurations, we need a systematic way to identify each one.

The Solution: Hyphen-Separated SKU

We use a hyphen-separated structure where each position represents a component category:

Treo-N100-8-256-2H-W6-11P

This creates a unique identifier for every configuration.

SKU Breakdown

graph LR
    SKU[Treo-N100-8-256-2H-W6-11P]
    SKU --> C[Treo
Chassis]
    SKU --> B[N100
Board/CPU]
    SKU --> R[8
RAM GB]
    SKU --> F[256
Flash GB]
    SKU --> A[2H
Adapter]
    SKU --> W[W6
WiFi 6]
    SKU --> O[11P
Windows 11 Pro]

Part Sequence

The SKU follows a fixed sequence defined in code:

part_sequence = [
    Categories.CHASSIS,      # Position 0
    Categories.BOARD,        # Position 1
# ... (implementation details omitted)

Every SKU must have at least the first 7 components (Chassis through OS). Accessories are optional.

Component Categories

1. Chassis

The physical enclosure and form factor:

  • Treo: Latest mini PC chassis (compact, modern design)

  • S: Small form factor (compact desktop)

  • H: Standard form factor (traditional desktop)

The chassis determines:

  • Physical dimensions

  • Mounting options (VESA, desktop)

  • Thermal design (fanless vs fan-cooled)

  • Port layout

2. Board

The motherboard with processor:

  • N100: Intel N100 (4 cores, 3.4GHz, 6W TDP)

  • N150: Intel N150 (4 cores, 3.6GHz, 6W TDP)

  • i5-1335U: Intel Core i5 13th Gen (10 cores, 4.6GHz, 15W TDP)

  • i7-1355U: Intel Core i7 13th Gen (10 cores, 5.0GHz, 15W TDP)

The board determines:

  • Processor generation, series, model

  • Core count

  • Max frequency

  • Cache size

  • Integrated graphics

3. RAM

Main memory capacity:

  • 4: 4GB DDR4

  • 8: 8GB DDR4

  • 16: 16GB DDR4

  • 32: 32GB DDR4

  • 64: 64GB DDR4

RAM is specified in GB without the unit.

4. Flash

SSD storage capacity:

  • 128: 128GB SSD

  • 256: 256GB SSD

  • 512: 512GB SSD

  • 1024: 1TB SSD (1024GB)

  • 2048: 2TB SSD (2048GB)

Flash is specified in GB without the unit.

5. Adapter

Display output configuration:

  • 2H: 2× HDMI ports

  • 2D: 2× DisplayPort

  • 1H1D: 1× HDMI + 1× DisplayPort

  • 1H1V: 1× HDMI + 1× VGA

  • 3H: 3× HDMI ports

The adapter determines available display outputs.

6. WiFi

Wireless connectivity:

  • W6: WiFi 6 (802.11ax) + Bluetooth 5.2

  • W6E: WiFi 6E (802.11ax 6GHz) + Bluetooth 5.2

  • None: No wireless (Ethernet only)

7. OS

Operating system:

  • 11P: Microsoft Windows 11 Pro

  • U: Ubuntu Linux 24.04 LTS

  • DOS: FreeDOS (no OS)

  • Thinux: Thinvent® Thinux™ Embedded Linux

8. Accessories (Optional)

Additional components:

  • KM: Keyboard + Mouse combo

  • MK: Mechanical Keyboard

  • VESA: VESA mount bracket

  • Stand: Adjustable stand

Multiple accessories can be combined: KM-VESA

SKU Validation

Not all combinations are valid. We validate SKUs using compatibility rules:

Check SKU Function

def check_sku(sku: str) -> bool:
    partids = sku.split("-")
    if len(partids) < len(part_sequence):
# ... (implementation details omitted)

Compatibility Constraints

Components can specify which other components they're compatible with:

Example: Treo chassis allows specific boards

{
  "Treo": {
    "allows": {
      "Board": ["N100", "N150", "i5-1335U"],
      "RAM": ["4", "8", "16", "32"],
      "Adapter": ["2H", "1H1D"]
    }
  }
}

This prevents invalid combinations like "Treo-i7-64-2048-3H" (Treo doesn't support i7 or 3H adapter).

SKU Expansion

We convert SKUs to human-readable names:

def expand_sku(sku: str) -> str:
    part_ids = sku.split("-")
    part_names = [
        productdb[part_sequence[i].value][part_id]["external"] 
# ... (implementation details omitted)        
    ]

Example:

Input:  Treo-N100-8-256-2H-W6-11P
Output: Treo Mini PC, Intel N100, 8GB DDR4, 256GB SSD, 2× HDMI, WiFi 6, Windows 11 Pro

The external field contains the customer-facing name for each component.

Feature Extraction

The SKU structure enables automatic feature extraction:

Feature Sequence

We define a sequence of features to extract:

feature_sequence = {
    "Generation": {"Unit": "", "Heading": "Processing"},
    "Series": {"Unit": "", "Heading": "Processing"},
# ... (implementation details omitted)

Each feature has:

  • Unit: Measurement unit (GB, GHz, Mbps)

  • Heading: Category for grouping (Processing, Display, Connectivity)

Extracting Features

For each component in the SKU, we extract its features:

# Board: N100
{
    "Generation": "12th",
# ... (implementation details omitted)

These features are aggregated across all components to create the product's complete feature set.

Benefits of This Structure

1. Unique Identification

Every configuration has a unique SKU. No ambiguity.

2. Human-Readable

The SKU is readable by humans:

  • Treo-N100-8-256-2H-W6-11P clearly shows the configuration

  • No need to look up a database to understand what it is

3. Sortable

SKUs sort naturally:

  • Treo-N100-8-256-2H-W6-11P

  • Treo-N100-16-512-2H-W6-11P

  • Treo-i5-16-512-2H-W6-11P

Sorting by SKU groups similar configurations together.

4. Filterable

We can filter by any component:

  • All Treo products: Treo-*

  • All N100 products: *-N100-*

  • All 16GB products: *-16-*

5. Feature Extraction

The structure enables automatic feature extraction for:

  • Product pages (display specifications)

  • Search filters (filter by RAM, storage, etc.)

  • Comparison tables (compare features side-by-side)

6. Cost Calculation

We can calculate cost by summing component costs:

def calculate_sku_cost(sku: str) -> float:
# ... (implementation details omitted)
    return total_cost

7. URL Generation

SKUs map directly to product URLs:

SKU:  Treo-N100-8-256-2H-W6-11P
URL:  /p/Treo-N100-8-256-2H-W6-11P

No separate URL slug needed.

Composite Items

Some components are composite (made of multiple parts):

Example: Board with integrated components

{
  "N100": {
    "external": "Intel N100",
# ... (implementation details omitted)

This enables:

  • Bill of Materials (BOM): List all components needed

  • Cost calculation: Sum costs of constituents

  • Inventory tracking: Track component usage

Single-Part SKUs

Not all SKUs are hyphenated. Single parts can be SKUs too:

  • N100 (just the board)

  • Treo (just the chassis)

  • KM (keyboard + mouse)

These are used for:

  • Spare parts

  • Upgrades

  • Accessories

The is_single_part() function checks if a SKU is a single part or a full product.

Integration with SEO Pipeline

The SKU structure powers the SEO pipeline:

  1. Feature extraction: Extract features for phrase mappings
  2. Filter generation: Create filters for filter extraction
  3. Product matching: Match queries to products by features
  4. Query pages: Generate pages for feature combinations

See SEO Pipeline Overview for details.

References

Technical Concepts

Related Articles

Summary

Our SKU system uses a hyphen-separated structure to uniquely identify product configurations:

  • Structure: Chassis-Board-RAM-Flash-Adapter-WiFi-OS-Accessories

  • Example: Treo-N100-8-256-2H-W6-11P

  • Benefits:

  • Unique identification (33,750+ configurations)

  • Human-readable (no lookup needed)

  • Sortable (natural ordering)

  • Filterable (by any component)

  • Feature extraction (automatic)

  • Cost calculation (sum of parts)

  • URL generation (direct mapping)

Validation:

  • Component existence check

  • Compatibility constraints

  • Minimum length requirement

Expansion:

  • SKU → Human-readable name

  • Component → Features

  • Features → Filters

This structure is the foundation of our product catalog, enabling powerful search, filtering, and SEO optimization.

← Back to Documentation Index