diff --git a/.github/workflows/generate_matrix_page.yaml b/.github/workflows/generate_matrix_page.yaml
index 0b614398b..10b122508 100644
--- a/.github/workflows/generate_matrix_page.yaml
+++ b/.github/workflows/generate_matrix_page.yaml
@@ -32,8 +32,12 @@ jobs:
     steps:
       - name: Set dynamic env vars
         run: |
+          # GPU Operator dashboard paths
           echo "DASHBOARD_DATA_FILEPATH=${DASHBOARD_OUTPUT_DIR}/gpu_operator_matrix.json" >> "$GITHUB_ENV"
           echo "DASHBOARD_HTML_FILEPATH=${DASHBOARD_OUTPUT_DIR}/gpu_operator_matrix.html" >> "$GITHUB_ENV"
+          # Network Operator dashboard paths
+          echo "NNO_DASHBOARD_DATA_FILEPATH=${DASHBOARD_OUTPUT_DIR}/network_operator_matrix.json" >> "$GITHUB_ENV"
+          echo "NNO_DASHBOARD_HTML_FILEPATH=${DASHBOARD_OUTPUT_DIR}/network_operator_matrix.html" >> "$GITHUB_ENV"
           echo "GH_PAGES_BRANCH=${{ github.event.inputs.gh_pages_branch || 'gh-pages' }}" >> "$GITHUB_ENV"
         env:
           DASHBOARD_OUTPUT_DIR: ${{ env.DASHBOARD_OUTPUT_DIR }}
@@ -67,27 +71,62 @@ jobs:
       - name: Install Dependencies
         run: |
           pip install -r workflows/gpu_operator_dashboard/requirements.txt
+          pip install -r workflows/nno_dashboard/requirements.txt
 
       - name: Fetch CI Data
         run: |
           echo "Processing PR: ${{ steps.determine_pr.outputs.PR_NUMBER }}"
+          # GPU Operator
           python -m workflows.gpu_operator_dashboard.fetch_ci_data \
             --pr_number "${{ steps.determine_pr.outputs.PR_NUMBER }}" \
             --baseline_data_filepath "${{ env.DASHBOARD_DATA_FILEPATH }}" \
             --merged_data_filepath "${{ env.DASHBOARD_DATA_FILEPATH }}"
+          # Network Operator
+          python -m workflows.nno_dashboard.fetch_ci_data \
+            --pr_number "${{ steps.determine_pr.outputs.PR_NUMBER }}" \
+            --baseline_data_filepath "${{ env.NNO_DASHBOARD_DATA_FILEPATH }}" \
+            --merged_data_filepath "${{ env.NNO_DASHBOARD_DATA_FILEPATH }}"
 
 
       - name: Generate HTML Dashboard (only if JSON changed)
         run: |
           cd "${{ env.DASHBOARD_OUTPUT_DIR }}"
+          
+          # Check if GPU Operator JSON changed
+          GPU_CHANGED=false
           if [[ ${{ github.event_name }} == "pull_request_target" ]] && git diff --exit-code gpu_operator_matrix.json; then
-            echo "no changes"
+            echo "GPU Operator: no changes"
+          else
+            echo "GPU Operator: changes detected"
+            GPU_CHANGED=true
+          fi
+          
+          # Check if Network Operator JSON changed
+          NNO_CHANGED=false
+          if [[ ${{ github.event_name }} == "pull_request_target" ]] && git diff --exit-code network_operator_matrix.json; then
+            echo "Network Operator: no changes"
           else
-            cd "${{ github.workspace }}"
+            echo "Network Operator: changes detected"
+            NNO_CHANGED=true
+          fi
+          
+          cd "${{ github.workspace }}"
+          
+          # Generate GPU Operator dashboard if changed
+          if [ "$GPU_CHANGED" = true ]; then
+            echo "Generating GPU Operator dashboard..."
             python -m workflows.gpu_operator_dashboard.generate_ci_dashboard \
               --dashboard_data_filepath "${{ env.DASHBOARD_DATA_FILEPATH }}" \
               --dashboard_html_filepath "${{ env.DASHBOARD_HTML_FILEPATH }}"
           fi
+          
+          # Generate Network Operator dashboard if changed
+          if [ "$NNO_CHANGED" = true ]; then
+            echo "Generating Network Operator dashboard..."
+            python -m workflows.nno_dashboard.generate_ci_dashboard \
+              --dashboard_data_filepath "${{ env.NNO_DASHBOARD_DATA_FILEPATH }}" \
+              --dashboard_html_filepath "${{ env.NNO_DASHBOARD_HTML_FILEPATH }}"
+          fi
 
       - name: Deploy HTML to GitHub Pages
         uses: JamesIves/github-pages-deploy-action@v4
diff --git a/.gitignore b/.gitignore
index 06cf92b78..ac23b99e1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,5 @@
 __pycache__/
 venv/
 *.pyc
+.DS_Store
+.vscode/
\ No newline at end of file
diff --git a/workflows/README.md b/workflows/README.md
index 768d3978e..e84979d73 100644
--- a/workflows/README.md
+++ b/workflows/README.md
@@ -6,8 +6,9 @@ This directory contains multiple workflows for automating various aspects of the
 
 - [gpu_operator_versions/](./gpu_operator_versions/) — Automation for updating versions and triggering CI jobs
 - [gpu_operator_dashboard/](./gpu_operator_dashboard/) — CI dashboard generation for NVIDIA GPU Operator test results
+- [nno_dashboard/](./nno_dashboard/) — CI dashboard generation for NVIDIA Network Operator test results
 - [microshift_dashboard/](./microshift_dashboard/) — MicroShift NVIDIA Device Plugin testing dashboard
-- Shared modules: [utils.py](./utils.py), [templates.py](./templates.py)
+- [common/](./common/) — Shared utilities: logging, templates, GCS access, HTML builders, data structures
 
 See the individual README files in each subdirectory for detailed information.
 
diff --git a/workflows/common/__init__.py b/workflows/common/__init__.py
index e69de29bb..09661a8dd 100644
--- a/workflows/common/__init__.py
+++ b/workflows/common/__init__.py
@@ -0,0 +1,94 @@
+"""
+Common utilities shared across NVIDIA CI workflows.
+"""
+
+from workflows.common.utils import get_logger, logger
+from workflows.common.templates import load_template
+from workflows.common.data_structures import (
+    TestResult,
+    OCP_FULL_VERSION,
+    OPERATOR_VERSION,
+    GPU_OPERATOR_VERSION,
+    STATUS_SUCCESS,
+    STATUS_FAILURE,
+    STATUS_ABORTED,
+)
+from workflows.common.gcs_utils import (
+    http_get_json,
+    fetch_gcs_file_content,
+    build_prow_job_url,
+    fetch_filtered_files,
+    build_job_history_url,
+    GCS_API_BASE_URL,
+    GCS_MAX_RESULTS_PER_REQUEST,
+)
+from workflows.common.html_builders import (
+    build_toc,
+    build_notes,
+    build_history_bar,
+    build_last_updated_footer,
+    sanitize_id,
+)
+from workflows.common.validation import (
+    is_valid_ocp_version,
+    has_valid_semantic_versions,
+    is_infrastructure_type,
+)
+from workflows.common.data_fetching import (
+    build_version_lookups,
+    build_finished_lookup,
+    extract_test_status,
+    extract_timestamp,
+    determine_repo_from_job_name,
+    convert_sets_to_lists_recursive,
+    merge_job_history_links,
+    int_or_none,
+)
+
+__all__ = [
+    # Utils
+    "get_logger",
+    "logger",
+    "load_template",
+    
+    # Data structures
+    "TestResult",
+    "OCP_FULL_VERSION",
+    "OPERATOR_VERSION",
+    "GPU_OPERATOR_VERSION",
+    "STATUS_SUCCESS",
+    "STATUS_FAILURE",
+    "STATUS_ABORTED",
+    
+    # GCS utilities
+    "http_get_json",
+    "fetch_gcs_file_content",
+    "build_prow_job_url",
+    "fetch_filtered_files",
+    "build_job_history_url",
+    "GCS_API_BASE_URL",
+    "GCS_MAX_RESULTS_PER_REQUEST",
+    
+    # HTML builders
+    "build_toc",
+    "build_notes",
+    "build_history_bar",
+    "build_last_updated_footer",
+    "sanitize_id",
+    
+    # Validation
+    "is_valid_ocp_version",
+    "has_valid_semantic_versions",
+    "is_infrastructure_type",
+    
+    # Data fetching
+    "build_version_lookups",
+    "build_finished_lookup",
+    "extract_test_status",
+    "extract_timestamp",
+    "determine_repo_from_job_name",
+    "convert_sets_to_lists_recursive",
+    "merge_job_history_links",
+    "int_or_none",
+]
+
diff --git a/workflows/common/data_fetching.py b/workflows/common/data_fetching.py
new file mode 100644
index 000000000..e69484815
--- /dev/null
+++ b/workflows/common/data_fetching.py
@@ -0,0 +1,177 @@
+"""
+Common data fetching patterns for CI dashboards.
+Shared logic for building file lookups and processing builds.
+"""
+
+import json
+from typing import Dict, Any, List, Tuple, Optional
+from workflows.common.utils import logger
+from workflows.common.gcs_utils import fetch_gcs_file_content
+
+
+def build_version_lookups(
+    version_files_list: List[Tuple[str, List[Dict[str, Any]]]]
+) -> Dict[str, Dict[str, str]]:
+    """
+    Build lookup dictionaries for version files organized by build directory.
+    
+    Args:
+        version_files_list: List of tuples (file_type, file_items)
+                           e.g., [("ocp", ocp_files), ("operator", operator_files)]
+    
+    Returns:
+        Dict mapping file_type to {build_dir: content}
+        e.g., {"ocp": {build_dir: "4.17.16"}, "operator": {build_dir: "25.4.0"}}
+    """
+    version_lookups = {}
+    
+    for file_type, file_items in version_files_list:
+        lookup = {}
+        for file_item in file_items:
+            path = file_item["name"]
+            build_dir = path.rsplit("/", 1)[0]
+            try:
+                content = fetch_gcs_file_content(path)
+                lookup[build_dir] = content.strip()
+            except Exception as e:
+                logger.warning(f"Failed to fetch {file_type} from {path}: {e}")
+        version_lookups[file_type] = lookup
+    
+    return version_lookups
+
+
+def build_finished_lookup(
+    finished_files: List[Dict[str, Any]]
+) -> Dict[str, Dict[str, Any]]:
+    """
+    Build lookup dictionary for finished.json files by build directory.
+    
+    Args:
+        finished_files: List of finished.json file items from GCS
+    
+    Returns:
+        Dict mapping build_dir to parsed finished.json content
+    """
+    finished_lookup = {}
+    
+    for finished_item in finished_files:
+        finished_path = finished_item["name"]
+        build_dir = finished_path.rsplit("/", 1)[0]
+        try:
+            content = fetch_gcs_file_content(finished_path)
+            finished_lookup[build_dir] = json.loads(content)
+        except Exception as e:
+            logger.warning(f"Failed to fetch/parse finished.json from {finished_path}: {e}")
+    
+    return finished_lookup
+
+
+def extract_test_status(
+    finished_json: Dict[str, Any],
+    status_success: str,
+    status_failure: str,
+    status_aborted: str
+) -> str:
+    """
+    Extract and normalize test status from finished.json.
+    
+    Args:
+        finished_json: Parsed finished.json content
+        status_success: String constant for success status
+        status_failure: String constant for failure status
+        status_aborted: String constant for aborted status
+        
+    Returns:
+        Normalized test status string
+    """
+    result_str = finished_json.get("result", "UNKNOWN").upper()
+    if result_str in [status_success, status_failure, status_aborted]:
+        return result_str
+    return status_failure
+
+
+def extract_timestamp(finished_json: Dict[str, Any]) -> int:
+    """
+    Extract timestamp from finished.json.
+    
+    Args:
+        finished_json: Parsed finished.json content
+        
+    Returns:
+        Unix timestamp (defaults to 0 if not found)
+    """
+    return finished_json.get("timestamp", 0)
+
+
+def determine_repo_from_job_name(job_name: str) -> str:
+    """
+    Determine repository from job name pattern.
+    
+    Args:
+        job_name: Job name string
+        
+    Returns:
+        Repository identifier ('openshift_release' or 'rh-ecosystem-edge_nvidia-ci')
+    """
+    return "openshift_release" if job_name.startswith("rehearse-") else "rh-ecosystem-edge_nvidia-ci"
+
+
+def convert_sets_to_lists_recursive(data: Any) -> Any:
+    """
+    Recursively convert sets to sorted lists for JSON serialization.
+    
+    Args:
+        data: Any data structure that may contain sets
+        
+    Returns:
+        Data structure with sets converted to sorted lists
+    """
+    if isinstance(data, set):
+        return sorted(list(data))
+    elif isinstance(data, dict):
+        return {k: convert_sets_to_lists_recursive(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [convert_sets_to_lists_recursive(item) for item in data]
+    else:
+        return data
+
+
+def merge_job_history_links(
+    new_links: Any,
+    existing_links: Any
+) -> List[str]:
+    """
+    Merge and deduplicate job history links.
+    
+    Args:
+        new_links: New links (can be set or list)
+        existing_links: Existing links (can be set or list)
+        
+    Returns:
+        Sorted list of unique links
+    """
+    # Convert both to sets
+    new_set = set(new_links) if isinstance(new_links, (set, list)) else set()
+    existing_set = set(existing_links) if isinstance(existing_links, (set, list)) else set()
+    
+    # Merge and return sorted list
+    all_links = new_set | existing_set
+    return sorted(list(all_links))
+
+
+def int_or_none(value: Optional[str]) -> Optional[int]:
+    """
+    Convert string to int or None for unlimited.
+    
+    Args:
+        value: String value to convert
+        
+    Returns:
+        Integer or None
+    """
+    if value is None:
+        return None
+    if value.lower() in ('none', 'unlimited'):
+        return None
+    return int(value)
+
diff --git a/workflows/common/data_structures.py b/workflows/common/data_structures.py
new file mode 100644
index 000000000..6348d8b9e
--- /dev/null
+++ b/workflows/common/data_structures.py
@@ -0,0 +1,59 @@
+"""
+Shared data structures and constants for CI dashboards.
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+# Constants for version field names (shared across dashboards)
+OCP_FULL_VERSION = "ocp_full_version"
+OPERATOR_VERSION = "operator_version"  # Generic operator version field
+
+# GPU Operator specific (for backward compatibility)
+GPU_OPERATOR_VERSION = "gpu_operator_version"
+
+# Constants for job statuses
+STATUS_SUCCESS = "SUCCESS"
+STATUS_FAILURE = "FAILURE"
+STATUS_ABORTED = "ABORTED"
+
+
+@dataclass(frozen=True)
+class TestResult:
+    """Represents a single test run result (shared data structure)."""
+    ocp_full_version: str
+    operator_version: str  # Can be GPU or Network operator version
+    test_status: str
+    prow_job_url: str
+    job_timestamp: str
+    test_flavor: Optional[str] = None  # Optional: for dashboards with test flavors (NNO)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert TestResult to dictionary format for JSON serialization."""
+        result = {
+            OCP_FULL_VERSION: self.ocp_full_version,
+            "operator_version": self.operator_version,
+            "test_status": self.test_status,
+            "prow_job_url": self.prow_job_url,
+            "job_timestamp": self.job_timestamp,
+        }
+        # Include test_flavor only if it's set
+        if self.test_flavor is not None:
+            result["test_flavor"] = self.test_flavor
+        return result
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "TestResult":
+        """Create TestResult from dictionary."""
+        # Handle backward compatibility with GPU operator data
+        operator_version = data.get("operator_version") or data.get(GPU_OPERATOR_VERSION)
+        
+        return cls(
+            ocp_full_version=data[OCP_FULL_VERSION],
+            operator_version=operator_version,
+            test_status=data["test_status"],
+            prow_job_url=data["prow_job_url"],
+            job_timestamp=data["job_timestamp"],
+            test_flavor=data.get("test_flavor"),
+        )
+
diff --git a/workflows/common/gcs_utils.py b/workflows/common/gcs_utils.py
new file mode 100644
index 000000000..5e28d9494
--- /dev/null
+++ b/workflows/common/gcs_utils.py
@@ -0,0 +1,130 @@
+"""
+GCS (Google Cloud Storage) utilities for fetching CI test artifacts.
+Shared across GPU Operator and Network Operator dashboards.
+"""
+
+import re
+import urllib.parse
+from typing import Dict, Any
+
+import requests
+
+from workflows.common.utils import logger
+
+# GCS API base URL for test-platform-results bucket
+GCS_API_BASE_URL = "https://storage.googleapis.com/storage/v1/b/test-platform-results/o"
+
+# Maximum number of results per GCS API request for pagination
+GCS_MAX_RESULTS_PER_REQUEST = 1000
+
+
+def http_get_json(url: str, params: Dict[str, Any] = None, headers: Dict[str, str] = None) -> Dict[str, Any]:
+    """
+    Send an HTTP GET request and return the JSON response.
+    
+    Args:
+        url: URL to fetch
+        params: Optional query parameters
+        headers: Optional HTTP headers
+        
+    Returns:
+        Parsed JSON response
+        
+    Raises:
+        requests.HTTPError: If the request fails
+    """
+    response = requests.get(url, params=params, headers=headers, timeout=30)
+    response.raise_for_status()
+    return response.json()
+
+
+def fetch_gcs_file_content(file_path: str) -> str:
+    """
+    Fetch the raw text content from a file in GCS.
+    
+    Args:
+        file_path: Path to the file in GCS (e.g., "pr-logs/pull/...")
+        
+    Returns:
+        File content as string
+        
+    Raises:
+        requests.HTTPError: If the file cannot be fetched
+    """
+    logger.info(f"Fetching file content for {file_path}")
+    response = requests.get(
+        url=f"{GCS_API_BASE_URL}/{urllib.parse.quote_plus(file_path)}",
+        params={"alt": "media"},
+        timeout=30,
+    )
+    response.raise_for_status()
+    return response.content.decode("UTF-8")
+
+
+def build_prow_job_url(finished_json_path: str) -> str:
+    """
+    Build a Prow job URL from a finished.json file path.
+    
+    Args:
+        finished_json_path: Path to finished.json file (e.g., "pr-logs/pull/.../finished.json")
+        
+    Returns:
+        Full URL to the Prow job artifacts page
+    """
+    directory_path = finished_json_path[:-len('/finished.json')]
+    return f"https://gcsweb-ci.apps.ci.l2s4.p1.openshiftapps.com/gcs/test-platform-results/{directory_path}"
+
+
+def fetch_filtered_files(pr_number: str, glob_pattern: str) -> list[Dict[str, Any]]:
+    """
+    Fetch files from GCS matching a specific pattern for a PR.
+    
+    Args:
+        pr_number: Pull request number
+        glob_pattern: Glob pattern to match files (e.g., "*/finished.json", "*/ocp.version")
+        
+    Returns:
+        List of file metadata dictionaries from GCS API
+    """
+    all_items = []
+    
+    # Search in both possible PR locations
+    for prefix in [
+        f"pr-logs/pull/rh-ecosystem-edge_nvidia-ci/{pr_number}/",
+        f"pr-logs/pull/openshift_release/{pr_number}/"
+    ]:
+        page_token = None  # Reset pagination token for each prefix
+        while True:
+            params = {
+                "prefix": prefix,
+                "delimiter": "",
+                "matchGlob": glob_pattern,
+                "maxResults": GCS_MAX_RESULTS_PER_REQUEST,
+            }
+            if page_token:
+                params["pageToken"] = page_token
+                
+            data = http_get_json(GCS_API_BASE_URL, params=params)
+            items = data.get("items", [])
+            all_items.extend(items)
+            
+            page_token = data.get("nextPageToken")
+            if not page_token:
+                break
+                
+    logger.info(f"Found {len(all_items)} files matching pattern '{glob_pattern}' for PR #{pr_number}")
+    return all_items
+
+
+def build_job_history_url(job_name: str) -> str:
+    """
+    Build a Prow job history URL for a given job name.
+    
+    Args:
+        job_name: Name of the CI job
+        
+    Returns:
+        Full URL to the job history page
+    """
+    return f"https://prow.ci.openshift.org/job-history/gs/test-platform-results/pr-logs/directory/{job_name}"
+
diff --git a/workflows/common/html_builders.py b/workflows/common/html_builders.py
new file mode 100644
index 000000000..7c31b3605
--- /dev/null
+++ b/workflows/common/html_builders.py
@@ -0,0 +1,162 @@
+"""
+Shared HTML building utilities for CI dashboards.
+"""
+
+import html
+from typing import List, Dict, Any
+from datetime import datetime, timezone
+
+
+def build_toc(ocp_keys: List[str]) -> str:
+    """
+    Build a Table of Contents (TOC) for OpenShift versions.
+    
+    Args:
+        ocp_keys: List of OCP version strings to include in TOC
+        
+    Returns:
+        HTML string containing the TOC
+    """
+    toc_links = ", ".join(
+        f'<a href="#ocp-{ocp_version}">{ocp_version}</a>' for ocp_version in ocp_keys
+    )
+    return f"""
+<div class="toc">
+    <div class="ocp-version-header">OpenShift Versions</div>
+    {toc_links}
+</div>
+    """
+
+
+def build_notes(notes: List[str]) -> str:
+    """
+    Build an HTML snippet with manual notes for an OCP version.
+    
+    Args:
+        notes: List of note strings to display
+        
+    Returns:
+        HTML string containing the notes section, or empty string if no notes
+    """
+    if not notes:
+        return ""
+
+    # Escape HTML in notes for safety
+    escaped_notes = [html.escape(note) for note in notes]
+    items = "\n".join(f'<li class="note-item">{n}</li>' for n in escaped_notes)
+    return f"""
+  <div class="section-label">Notes</div>
+  <div class="note-items">
+    <ul>
+      {items}
+    </ul>
+  </div>
+    """
+
+
+def build_history_bar(
+    results: List[Dict[str, Any]],
+    title: str,
+    success_key: str = "test_status",
+    success_value: str = "SUCCESS"
+) -> str:
+    """
+    Build a history bar showing test result squares (success/failure/aborted).
+    
+    Args:
+        results: List of test result dictionaries
+        title: Title to display above the history bar
+        success_key: Key in result dict to check for status
+        success_value: Value that indicates success
+        
+    Returns:
+        HTML string containing the history bar
+    """
+    if not results:
+        return ""
+    
+    # Sort by timestamp, most recent first
+    sorted_results = sorted(
+        results, key=lambda r: int(r.get("job_timestamp", 0)), reverse=True
+    )
+    
+    leftmost_result = sorted_results[0]
+    last_date = datetime.fromtimestamp(
+        int(leftmost_result.get("job_timestamp", 0)), timezone.utc
+    ).strftime("%Y-%m-%d %H:%M:%S UTC")
+    
+    history_html = f"""
+  <div class="section-label">
+    <strong>{html.escape(title)}</strong>
+  </div>
+  <div class="history-bar-inner history-bar-outer">
+    <div style="margin-top: 5px;">
+      <strong>Last Job Date:</strong> {last_date}
+    </div>
+    """
+    
+    for result in sorted_results:
+        status = result.get(success_key, "Unknown").upper()
+        if status == success_value:
+            status_class = "history-success"
+        elif status == "FAILURE":
+            status_class = "history-failure"
+        else:
+            status_class = "history-aborted"
+            
+        timestamp_str = datetime.fromtimestamp(
+            int(result.get("job_timestamp", 0)), timezone.utc
+        ).strftime("%Y-%m-%d %H:%M:%S UTC")
+        
+        prow_url = result.get("prow_job_url", "#")
+        history_html += f"""
+    <div class='history-square {status_class}'
+         onclick='window.open("{prow_url}", "_blank")'>
+         <span class="history-square-tooltip">
+          Status: {status} | Timestamp: {timestamp_str}
+         </span>
+    </div>
+        """
+    
+    history_html += "</div>"
+    return history_html
+
+
+def build_last_updated_footer(timestamp: str = None) -> str:
+    """
+    Build a footer showing when the dashboard was last updated.
+    
+    Args:
+        timestamp: Optional timestamp string. If not provided, uses current time.
+        
+    Returns:
+        HTML string containing the footer
+    """
+    if timestamp is None:
+        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+    
+    return f"""
+  <div class="last-updated">
+    Last updated: {timestamp} UTC
+  </div>
+</body>
+</html>
+    """
+
+
+def sanitize_id(text: str) -> str:
+    """
+    Sanitize a string to be used as an HTML ID.
+    
+    Args:
+        text: String to sanitize
+        
+    Returns:
+        Sanitized string safe for use as HTML ID
+    """
+    # Replace spaces and special characters with hyphens
+    sanitized = text.lower().replace(" ", "-").replace("_", "-")
+    # Remove any characters that aren't alphanumeric or hyphens
+    sanitized = "".join(c for c in sanitized if c.isalnum() or c == "-")
+    return sanitized
+
diff --git a/workflows/common/validation.py b/workflows/common/validation.py
new file mode 100644
index 000000000..3d3a654ac
--- /dev/null
+++ b/workflows/common/validation.py
@@ -0,0 +1,90 @@
+"""
+Validation utilities for CI dashboards.
+Shared validation logic for GPU Operator and Network Operator dashboards.
+"""
+
+from typing import Dict, Any
+import semver
+
+
+def is_valid_ocp_version(version: str) -> bool:
+    """
+    Check if a version string is a valid OpenShift version (not an infrastructure type).
+    
+    Args:
+        version: Version string to validate
+        
+    Returns:
+        True if valid OCP version, False otherwise
+        
+    Examples:
+        >>> is_valid_ocp_version("4.17.16")
+        True
+        >>> is_valid_ocp_version("doca4")
+        False
+        >>> is_valid_ocp_version("bare-metal")
+        False
+    """
+    invalid_keys = ["doca4", "bare-metal", "hosted", "unknown"]
+    if version.lower() in invalid_keys:
+        return False
+    if not version or not version[0].isdigit():
+        return False
+    if '.' not in version:
+        return False
+    parts = version.split('.')
+    if len(parts) < 2:
+        return False
+    try:
+        int(parts[0])
+        int(parts[1])
+        return True
+    except (ValueError, IndexError):
+        return False
+
+
+def has_valid_semantic_versions(result: Dict[str, Any], ocp_key: str = "ocp_full_version", operator_key: str = "operator_version") -> bool:
+    """
+    Check if both OCP and operator versions contain valid semantic versions.
+    
+    Args:
+        result: Test result dictionary containing version fields
+        ocp_key: Key name for OCP version in result dict
+        operator_key: Key name for operator version in result dict
+        
+    Returns:
+        True if both versions are valid semantic versions, False otherwise
+    """
+    try:
+        ocp_version = result.get(ocp_key, "")
+        operator_version = result.get(operator_key, "")
+        
+        if not ocp_version or not operator_version:
+            return False
+        
+        # Parse OCP version (should be like "4.14.1")
+        semver.VersionInfo.parse(ocp_version)
+        
+        # Parse operator version (may have suffix like "23.9.0(bundle)" - extract version part)
+        operator_version_clean = operator_version.split("(")[0].strip()
+        semver.VersionInfo.parse(operator_version_clean)
+        
+    except (ValueError, TypeError):
+        return False
+    else:
+        return True
+
+
+def is_infrastructure_type(value: str) -> bool:
+    """
+    Check if a string is an infrastructure type rather than a version.
+    
+    Args:
+        value: String to check
+        
+    Returns:
+        True if it's an infrastructure type, False otherwise
+    """
+    infrastructure_types = ["doca4", "bare-metal", "hosted", "unknown"]
+    return value.lower() in infrastructure_types
+
diff --git a/workflows/gpu_operator_dashboard/fetch_ci_data.py b/workflows/gpu_operator_dashboard/fetch_ci_data.py
index d2e1f823b..b91be2157 100644
--- a/workflows/gpu_operator_dashboard/fetch_ci_data.py
+++ b/workflows/gpu_operator_dashboard/fetch_ci_data.py
@@ -11,6 +11,18 @@
 import semver
 
 from workflows.common.utils import logger
+from workflows.common.gcs_utils import (
+    GCS_API_BASE_URL,
+    GCS_MAX_RESULTS_PER_REQUEST,
+    http_get_json,
+    fetch_gcs_file_content,
+    build_prow_job_url,
+    fetch_filtered_files,
+)
+from workflows.common.data_fetching import (
+    int_or_none,
+    merge_job_history_links,
+)
 
 
 # Constants for version field names
@@ -22,13 +34,6 @@
 STATUS_FAILURE = "FAILURE"
 STATUS_ABORTED = "ABORTED"
 
-
-# =============================================================================
-# Constants
-# =============================================================================
-
-GCS_API_BASE_URL = "https://storage.googleapis.com/storage/v1/b/test-platform-results/o"
-
 # Regular expression to match test result paths.
 TEST_RESULT_PATH_REGEX = re.compile(
     r"pr-logs/pull/(?P<repo>[^/]+)/(?P<pr_number>\d+)/"
@@ -37,37 +42,11 @@
     r"(?P<build_id>[^/]+)"
 )
 
-# Maximum number of results per GCS API request for pagination
-GCS_MAX_RESULTS_PER_REQUEST = 1000
-
 
 # =============================================================================
 # Data Fetching & JSON Update Functions
 # =============================================================================
 
-def http_get_json(url: str, params: Dict[str, Any] = None, headers: Dict[str, str] = None) -> Dict[str, Any]:
-    """Send an HTTP GET request and return the JSON response."""
-    response = requests.get(url, params=params, headers=headers, timeout=30)
-    response.raise_for_status()
-    return response.json()
-
-
-def fetch_gcs_file_content(file_path: str) -> str:
-    """Fetch the raw text content from a file in GCS."""
-    logger.info(f"Fetching file content for {file_path}")
-    response = requests.get(
-        url=f"{GCS_API_BASE_URL}/{urllib.parse.quote_plus(file_path)}",
-        params={"alt": "media"},
-        timeout=30,
-    )
-    response.raise_for_status()
-    return response.content.decode("UTF-8")
-
-
-def build_prow_job_url(finished_json_path: str) -> str:
-    directory_path = finished_json_path[:-len('/finished.json')]
-    return f"https://gcsweb-ci.apps.ci.l2s4.p1.openshiftapps.com/gcs/test-platform-results/{directory_path}"
-
 
 # --- Pydantic Model and Domain Model for Test Results ---
 
@@ -131,40 +110,6 @@ def has_exact_versions(self) -> bool:
             return True
 
 
-def fetch_filtered_files(pr_number: str, glob_pattern: str) -> List[Dict[str, Any]]:
-    """Fetch files matching a specific glob pattern for a PR."""
-    logger.info(f"Fetching files matching pattern: {glob_pattern}")
-
-    params = {
-        "prefix": f"pr-logs/pull/rh-ecosystem-edge_nvidia-ci/{pr_number}/",
-        "alt": "json",
-        "matchGlob": glob_pattern,
-        "maxResults": str(GCS_MAX_RESULTS_PER_REQUEST),
-        "projection": "noAcl",
-    }
-    headers = {"Accept": "application/json"}
-
-    all_items = []
-    next_page_token = None
-
-    # Handle pagination
-    while True:
-        if next_page_token:
-            params["pageToken"] = next_page_token
-
-        response_data = http_get_json(
-            GCS_API_BASE_URL, params=params, headers=headers)
-        items = response_data.get("items", [])
-        all_items.extend(items)
-
-        next_page_token = response_data.get("nextPageToken")
-        if not next_page_token:
-            break
-
-    logger.info(f"Found {len(all_items)} files matching {glob_pattern}")
-    return all_items
-
-
 def fetch_pr_files(pr_number: str) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]], List[Dict[str, Any]]]:
     """Fetch all required file types for a PR using targeted filtering."""
     logger.info(f"Fetching files for PR #{pr_number}")
@@ -593,11 +538,10 @@ def merge_ocp_version_results(
     new_job_history_links = new_version_data.get("job_history_links", set())
     existing_job_history_links = merged_version_data.get("job_history_links", [])
 
-    # Convert existing list back to set, then merge with new set
-    all_job_history_links = set(existing_job_history_links)
-    all_job_history_links.update(new_job_history_links)
-    # Convert back to sorted list for JSON serialization
-    merged_version_data["job_history_links"] = sorted(list(all_job_history_links))
+    # Use common merge function
+    merged_version_data["job_history_links"] = merge_job_history_links(
+        new_job_history_links, existing_job_history_links
+    )
 
     return merged_version_data
 
@@ -628,20 +572,10 @@ def merge_and_save_results(
 
     logger.info(f"Results saved to {output_file}")
 
-
-
 # =============================================================================
 # Main Workflow: Update JSON
 # =============================================================================
 
-def int_or_none(value: Optional[str]) -> Optional[int]:
-    """Convert string to int or None for unlimited."""
-    if value is None:
-        return None
-    if value.lower() in ('none', 'unlimited'):
-        return None
-    return int(value)
-
 
 def main() -> None:
     parser = argparse.ArgumentParser(description="Test Matrix Utility")
diff --git a/workflows/gpu_operator_dashboard/generate_ci_dashboard.py b/workflows/gpu_operator_dashboard/generate_ci_dashboard.py
index c55d6c819..6c52d4f04 100644
--- a/workflows/gpu_operator_dashboard/generate_ci_dashboard.py
+++ b/workflows/gpu_operator_dashboard/generate_ci_dashboard.py
@@ -8,41 +8,11 @@
 
 from workflows.common.utils import logger
 from workflows.common.templates import load_template
+from workflows.common.validation import has_valid_semantic_versions
 from workflows.gpu_operator_dashboard.fetch_ci_data import (
     OCP_FULL_VERSION, GPU_OPERATOR_VERSION, STATUS_ABORTED)
 
 
-def has_valid_semantic_versions(result: Dict[str, Any]) -> bool:
-    """
-    Check if both ocp_full_version and gpu_operator_version contain valid semantic versions.
-
-    Args:
-        result: Test result dictionary containing version fields
-
-    Returns:
-        True if both versions are valid semantic versions, False otherwise
-    """
-    try:
-        ocp_version = result.get(OCP_FULL_VERSION, "")
-        gpu_version = result.get(GPU_OPERATOR_VERSION, "")
-
-        if not ocp_version or not gpu_version:
-            return False
-
-        # Parse OCP version (should be like "4.14.1")
-        semver.VersionInfo.parse(ocp_version)
-
-        # Parse GPU operator version (may have suffix like "23.9.0(bundle)" - extract version part)
-        gpu_version_clean = gpu_version.split("(")[0].strip()
-        semver.VersionInfo.parse(gpu_version_clean)
-
-    except (ValueError, TypeError):
-        logger.warning(f"Invalid semantic version in result: ocp={result.get(OCP_FULL_VERSION)}, gpu={result.get(GPU_OPERATOR_VERSION)}")
-        return False
-    else:
-        return True
-
-
 def generate_test_matrix(ocp_data: Dict[str, Dict[str, Any]]) -> str:
     """
     Build the final HTML report by:
@@ -67,7 +37,7 @@ def generate_test_matrix(ocp_data: Dict[str, Dict[str, Any]]) -> str:
         for r in release_results:
             # Only include entries with valid semantic versions
             # Ignore ABORTED results for regular (non-bundle) results
-            if has_valid_semantic_versions(r) and r.get("test_status") != STATUS_ABORTED:
+            if has_valid_semantic_versions(r, OCP_FULL_VERSION, GPU_OPERATOR_VERSION) and r.get("test_status") != STATUS_ABORTED:
                 regular_results.append(r)
         notes_html = build_notes(notes)
         table_rows_html = build_catalog_table_rows(regular_results)
diff --git a/workflows/nno_dashboard/README.md b/workflows/nno_dashboard/README.md
new file mode 100644
index 000000000..7a2dd8788
--- /dev/null
+++ b/workflows/nno_dashboard/README.md
@@ -0,0 +1,182 @@
+# NVIDIA Network Operator CI Dashboard
+
+This module generates an HTML dashboard displaying CI test results for NVIDIA Network Operator on Red Hat OpenShift.
+
+## Overview
+
+The dashboard fetches test results from OpenShift CI (Prow) stored in Google Cloud Storage and generates an interactive HTML page showing:
+
+- Test results organized by OpenShift version
+- Multiple test flavors (infrastructure types, RDMA configurations, GPU tests)
+- Success/failure status with links to detailed test logs
+- Historical test data
+
+## Test Flavors
+
+Network Operator tests run across multiple configurations:
+
+### Infrastructure Types
+- **DOCA4**: Tests on DOCA4 infrastructure
+- **Bare Metal**: Tests on bare metal servers
+- **Hosted**: Tests in hosted environments
+
+### Test Types
+- **RDMA Legacy SR-IOV**: Legacy SR-IOV RDMA testing
+- **RDMA Shared Device**: Shared device RDMA testing  
+- **RDMA SR-IOV**: SR-IOV with RDMA
+- **E2E**: End-to-end integration tests
+
+### GPU Support
+Tests can run with or without GPU:
+- **with GPU**: Tests including GPU/GPUDirect functionality
+- **(no suffix)**: Tests without GPU
+
+### Example Flavors
+- `DOCA4 - RDMA Legacy SR-IOV`
+- `Bare Metal - E2E`
+- `Hosted - RDMA SR-IOV with GPU`
+- `DOCA4 - RDMA Shared Device`
+
+## Data Structure
+
+The dashboard uses a JSON file with this structure:
+
+```json
+{
+  "4.17.16": {
+    "notes": [],
+    "bundle_tests": [],
+    "release_tests": [],
+    "job_history_links": [...],
+    "test_flavors": {
+      "DOCA4 - RDMA Legacy SR-IOV": {
+        "results": [
+          {
+            "ocp_full_version": "4.17.16",
+            "operator_version": "25.4.0",
+            "test_status": "SUCCESS",
+            "prow_job_url": "https://...",
+            "job_timestamp": 1756406663,
+            "test_flavor": "DOCA4 - RDMA Legacy SR-IOV"
+          }
+        ],
+        "job_history_links": [...]
+      }
+    }
+  }
+}
+```
+
+## Scripts
+
+### fetch_ci_data.py
+
+Fetches test results from GCS for a specific PR.
+
+```bash
+python -m workflows.nno_dashboard.fetch_ci_data \
+  --pr_number 67673 \
+  --baseline_data_filepath output/network_operator_matrix.json \
+  --merged_data_filepath output/network_operator_matrix.json
+```
+
+**What it does:**
+1. Fetches `finished.json`, `ocp.version`, and `operator.version` files from GCS
+2. Extracts test flavor from job name (infrastructure + test type + GPU)
+3. Validates OpenShift versions (filters out infrastructure types)
+4. Organizes results by OCP version and test flavor
+5. Merges with existing data
+
+### generate_ci_dashboard.py
+
+Generates HTML dashboard from JSON data.
+
+```bash
+python -m workflows.nno_dashboard.generate_ci_dashboard \
+  --dashboard_data_filepath output/network_operator_matrix.json \
+  --dashboard_html_filepath output/network_operator_matrix.html
+```
+
+**What it does:**
+1. Loads JSON data
+2. Filters valid OCP versions
+3. Builds HTML sections for each test flavor
+4. Groups results by OCP and operator versions
+5. Creates clickable links with success/failure styling
+
+## Shared Utilities
+
+This module uses shared utilities from `workflows/common/`:
+
+- **gcs_utils**: GCS API access (fetch files, build URLs)
+- **html_builders**: HTML generation (TOC, notes, footers)
+- **data_structures**: `TestResult` dataclass and constants
+- **templates**: Template loading utilities
+- **utils**: Logging
+
+## Example Job Names
+
+Network Operator CI jobs follow this pattern:
+
+```
+pull-ci-rh-ecosystem-edge-nvidia-ci-main-{infrastructure}-nvidia-network-operator-{test-type}
+```
+
+Examples:
+- `pull-ci-...-doca4-nvidia-network-operator-legacy-sriov-rdma`
+- `pull-ci-...-bare-metal-nvidia-network-operator-bare-metal-e2e-doca4-latest`
+- `pull-ci-...-hosted-nvidia-network-operator-sriov-rdma-gpu`
+
+## Dashboard Output
+
+The generated HTML includes:
+
+- **Table of Contents**: Quick navigation to OCP versions
+- **OCP Version Sections**: One per OpenShift version
+- **Test Flavor Tables**: One table per flavor showing:
+  - OpenShift version
+  - Network Operator version (clickable to test logs)
+  - Color-coded success/failure status
+
+## Development
+
+### Adding New Test Flavors
+
+1. Update `extract_test_flavor_from_job_name()` in `fetch_ci_data.py`
+2. Add pattern matching for the new flavor
+3. Test with actual PR data
+
+### Modifying HTML Layout
+
+1. Edit templates in `templates/`:
+   - `header.html`: Page header and scripts
+   - `main_table.html`: OCP version container
+   - `test_flavor_section.html`: Individual flavor tables
+2. Use `{placeholders}` for dynamic content
+3. Regenerate dashboard to test changes
+
+## Integration
+
+This module is called by the GitHub Actions workflow in `.github/workflows/generate_matrix_page.yaml`:
+
+```yaml
+- name: Fetch Network Operator CI Data
+  run: |
+    python -m workflows.nno_dashboard.fetch_ci_data \
+      --pr_number "${{ steps.determine_pr.outputs.PR_NUMBER }}" \
+      --baseline_data_filepath "${{ env.NNO_DASHBOARD_DATA_FILEPATH }}" \
+      --merged_data_filepath "${{ env.NNO_DASHBOARD_DATA_FILEPATH }}"
+
+- name: Generate Network Operator HTML Dashboard
+  run: |
+    python -m workflows.nno_dashboard.generate_ci_dashboard \
+      --dashboard_data_filepath "${{ env.NNO_DASHBOARD_DATA_FILEPATH }}" \
+      --dashboard_html_filepath "${{ env.NNO_DASHBOARD_HTML_FILEPATH }}"
+```
+
+## See Also
+
+- [GPU Operator Dashboard](../gpu_operator_dashboard/) - Similar dashboard for GPU Operator
+- [Common Utilities](../common/) - Shared code across dashboards
+- [GitHub Actions Workflow](../../.github/workflows/generate_matrix_page.yaml) - CI automation
+
diff --git a/workflows/nno_dashboard/__init__.py b/workflows/nno_dashboard/__init__.py
new file mode 100644
index 000000000..feb024a42
--- /dev/null
+++ b/workflows/nno_dashboard/__init__.py
@@ -0,0 +1,3 @@
+"""
+NVIDIA Network Operator CI Dashboard generation tools.
+"""
diff --git a/workflows/nno_dashboard/fetch_ci_data.py b/workflows/nno_dashboard/fetch_ci_data.py
new file mode 100644
index 000000000..18d098f55
--- /dev/null
+++ b/workflows/nno_dashboard/fetch_ci_data.py
@@ -0,0 +1,445 @@
+#!/usr/bin/env python3
+"""
+Fetch Network Operator CI data from OpenShift CI (Prow) and store results.
+
+This script fetches test results for NVIDIA Network Operator from Google Cloud Storage
+where OpenShift CI stores Prow job artifacts.
+"""
+
+import argparse
+import json
+import re
+from typing import Dict, Any, List, Tuple
+
+from workflows.common import (
+    logger,
+    fetch_gcs_file_content,
+    fetch_filtered_files,
+    build_prow_job_url,
+    build_job_history_url,
+    TestResult,
+    OCP_FULL_VERSION,
+    OPERATOR_VERSION,
+    STATUS_SUCCESS,
+    STATUS_FAILURE,
+    STATUS_ABORTED,
+    is_valid_ocp_version,
+)
+
+
+# Regular expression to match Network Operator test result paths
+# Example: pr-logs/pull/openshift_release/67673/rehearse-67673-pull-ci-rh-ecosystem-edge-nvidia-ci-main-doca4-nvidia-network-operator-legacy-sriov-rdma/1961127149603655680
+NNO_TEST_PATH_REGEX = re.compile(
+    r"pr-logs/pull/(?P<repo>[^/]+)/(?P<pr_number>\d+)/"
+    r"(?P<job_name>(?:rehearse-\d+-)?pull-ci-rh-ecosystem-edge-nvidia-ci-main-"
+    r"(?P<infrastructure>[^-]+)-nvidia-network-operator-(?P<test_type>.+))/"
+    r"(?P<build_id>[^/]+)"
+)
+
+
+def extract_test_flavor_from_job_name(job_name: str) -> str:
+    """
+    Extract test flavor from Network Operator job name.
+    
+    Test flavors combine:
+    - Infrastructure: DOCA4, Bare Metal, Hosted
+    - Test type: Legacy SR-IOV RDMA, Shared Device RDMA, E2E, etc.
+    - GPU presence: with GPU or without
+    
+    Examples:
+        - "pull-ci-...-doca4-nvidia-network-operator-legacy-sriov-rdma" -> "DOCA4 - RDMA Legacy SR-IOV"
+        - "pull-ci-...-bare-metal-nvidia-network-operator-bare-metal-e2e-doca4-latest" -> "Bare Metal - E2E"
+        - "pull-ci-...-hosted-nvidia-network-operator-sriov-rdma-gpu" -> "Hosted - RDMA SR-IOV with GPU"
+    
+    Args:
+        job_name: Full job name from Prow
+        
+    Returns:
+        Human-readable test flavor string
+    """
+    job_lower = job_name.lower()
+    
+    # Identify infrastructure type
+    infrastructure = None
+    if "doca4" in job_lower and "bare-metal" not in job_lower:
+        infrastructure = "DOCA4"
+    elif "bare-metal" in job_lower:
+        infrastructure = "Bare Metal"
+    elif "hosted" in job_lower:
+        infrastructure = "Hosted"
+    
+    # Identify RDMA/test type
+    rdma_type = None
+    if "legacy-sriov-rdma" in job_lower or "rdma-legacy-sriov" in job_lower:
+        rdma_type = "RDMA Legacy SR-IOV"
+    elif "shared-device-rdma" in job_lower or "rdma-shared-dev" in job_lower:
+        rdma_type = "RDMA Shared Device"
+    elif "sriov" in job_lower and "rdma" in job_lower:
+        rdma_type = "RDMA SR-IOV"
+    elif "rdma" in job_lower:
+        rdma_type = "RDMA"
+    
+    # Identify test type if not RDMA
+    test_type = None
+    if not rdma_type:
+        if "bare-metal-e2e" in job_lower:
+            test_type = "E2E"
+        elif "nvidia-network-operator-e2e" in job_lower or "-e2e" in job_lower:
+            test_type = "E2E"
+    
+    # Check for GPU
+    has_gpu = "gpu" in job_lower or "gpudirect" in job_lower
+    
+    # Build flavor string
+    parts = []
+    
+    if infrastructure:
+        parts.append(infrastructure)
+    
+    if rdma_type:
+        if has_gpu:
+            parts.append(f"{rdma_type} with GPU")
+        else:
+            parts.append(rdma_type)
+    elif test_type:
+        if has_gpu:
+            parts.append(f"{test_type} with GPU")
+        else:
+            parts.append(test_type)
+    elif has_gpu:
+        parts.append("with GPU")
+    
+    if not parts:
+        if infrastructure:
+            return infrastructure
+        return "Standard"
+    
+    return " - ".join(parts)
+
+
+def process_single_nno_build(
+    pr_number: str,
+    job_name: str,
+    build_id: str,
+    finished_file: Dict[str, Any],
+    ocp_file: str,
+    operator_file: str
+) -> TestResult:
+    """
+    Process a single Network Operator build and create a TestResult.
+    
+    Args:
+        pr_number: PR number
+        job_name: Job name
+        build_id: Build ID
+        finished_file: Parsed finished.json dict
+        ocp_file: ocp.version content string
+        operator_file: operator.version content string
+        
+    Returns:
+        TestResult object containing the build information
+    """
+    from workflows.common.data_fetching import extract_test_status, extract_timestamp, determine_repo_from_job_name
+    
+    # Extract test flavor from job name
+    test_flavor = extract_test_flavor_from_job_name(job_name)
+    
+    # Get OCP version
+    ocp_version = ocp_file if ocp_file else "Unknown"
+    
+    # Get operator version
+    operator_version = operator_file if operator_file else "Unknown"
+    
+    # Get test status using common function
+    test_status = extract_test_status(finished_file, STATUS_SUCCESS, STATUS_FAILURE, STATUS_ABORTED)
+    
+    # Get timestamp using common function
+    timestamp = extract_timestamp(finished_file)
+    
+    # Build Prow URL (construct the finished.json path)
+    repo = determine_repo_from_job_name(job_name)
+    finished_path = f"pr-logs/pull/{repo}/{pr_number}/{job_name}/{build_id}/finished.json"
+    prow_url = build_prow_job_url(finished_path)
+    
+    return TestResult(
+        ocp_full_version=ocp_version,
+        operator_version=operator_version,
+        test_status=test_status,
+        prow_job_url=prow_url,
+        job_timestamp=str(timestamp),
+        test_flavor=test_flavor
+    )
+
+
+def process_tests_for_pr(pr_number: str, results_by_ocp: Dict[str, Dict[str, Any]]) -> None:
+    from workflows.common.data_fetching import build_version_lookups
+    
+    logger.info(f"Fetching Network Operator test data for PR #{pr_number}")
+    
+    # Fetch all finished.json files, then filter for network operator jobs
+    # Network operator finished.json files are at the build root, so we need to:
+    # 1. Fetch all finished.json files
+    # 2. Filter for paths containing "nvidia-network-operator" in the job name
+    all_finished_files = fetch_filtered_files(pr_number, "**/finished.json")
+    
+    # Filter for Network Operator jobs by checking if job name contains "nvidia-network-operator"
+    finished_files = []
+    for file_item in all_finished_files:
+        path = file_item.get("name", "")
+        # Check if this is a network operator job by looking for the pattern in the path
+        if "nvidia-network-operator" in path and path.endswith("/finished.json"):
+            # Additional check: must be at build root, not nested in artifacts
+            # Path should look like: .../rehearse-X-...-nvidia-network-operator-.../BUILD_ID/finished.json
+            if path.count("/finished.json") == 1 and "/artifacts/" not in path.split("/finished.json")[0]:
+                finished_files.append(file_item)
+    
+    # Now fetch version files - try multiple possible artifact paths
+    # Network Operator artifacts can be in different locations depending on test type
+    ocp_version_files = []
+    operator_version_files = []
+    
+    # Try common artifact patterns
+    version_patterns = [
+        "**/network-operator-e2e/ocp.version",
+        "**/artifacts/ocp.version",
+        "**/nvidia-network-operator*/ocp.version",
+    ]
+    
+    for pattern in version_patterns:
+        files = fetch_filtered_files(pr_number, pattern)
+        for file_item in files:
+            path = file_item.get("name", "")
+            # Only include if it's part of a network operator job
+            if "nvidia-network-operator" in path:
+                ocp_version_files.append(file_item)
+    
+    for pattern in version_patterns:
+        operator_pattern = pattern.replace("ocp.version", "operator.version")
+        files = fetch_filtered_files(pr_number, operator_pattern)
+        for file_item in files:
+            path = file_item.get("name", "")
+            if "nvidia-network-operator" in path:
+                operator_version_files.append(file_item)
+    
+    logger.info(f"Found {len(finished_files)} finished.json files")
+    
+    # Build lookup dictionaries by BUILD_ID only (simplest approach)
+    # Extract build_id from the known path structure:
+    # pr-logs/pull/{repo}/{pr}/{job_name}/{build_id}/...
+    ocp_lookup = {}
+    operator_lookup = {}
+    
+    for file_item in ocp_version_files:
+        path = file_item["name"]
+        # Extract build_id from the 6th path segment (0-indexed: 0=pr-logs, 1=pull, 2=repo, 3=pr, 4=job_name, 5=build_id)
+        parts = path.split("/")
+        if len(parts) >= 6:
+            build_id = parts[5]
+            try:
+                content = fetch_gcs_file_content(path)
+                ocp_lookup[build_id] = content.strip()
+                logger.info(f"Added OCP version for build {build_id}")
+            except Exception as e:
+                logger.warning(f"Failed to fetch OCP version from {path}: {e}")
+    
+    for file_item in operator_version_files:
+        path = file_item["name"]
+        parts = path.split("/")
+        if len(parts) >= 6:
+            build_id = parts[5]
+            try:
+                content = fetch_gcs_file_content(path)
+                operator_lookup[build_id] = content.strip()
+                logger.info(f"Added Operator version for build {build_id}")
+            except Exception as e:
+                logger.warning(f"Failed to fetch operator version from {path}: {e}")
+    
+    # Process each finished.json file
+    processed_count = 0
+    for finished_item in finished_files:
+        finished_path = finished_item["name"]
+        
+        # Remove /finished.json from path before parsing (regex expects path without filename)
+        path_without_file = finished_path.rsplit("/finished.json", 1)[0] if finished_path.endswith("/finished.json") else finished_path
+        
+        # Parse the path to extract job information
+        match = NNO_TEST_PATH_REGEX.search(path_without_file)
+        if not match:
+            logger.warning(f"Could not parse path: {finished_path}")
+            continue
+        
+        job_name = match.group("job_name")
+        build_id = match.group("build_id")
+        pr_num = match.group("pr_number")
+        repo = match.group("repo")
+        
+        logger.info(f"Processing build {build_id} for job {job_name}")
+        
+        # Fetch finished.json content
+        try:
+            finished_content_str = fetch_gcs_file_content(finished_path)
+            finished_json = json.loads(finished_content_str)
+        except Exception as e:
+            logger.warning(f"Failed to fetch/parse finished.json from {finished_path}: {e}")
+            continue
+        
+        # Get OCP and operator versions using the build_id
+        ocp_content = ocp_lookup.get(build_id)
+        operator_content = operator_lookup.get(build_id)
+        
+        if not ocp_content:
+            logger.warning(f"Missing ocp.version for build {build_id}")
+            continue
+        if not operator_content:
+            logger.warning(f"Missing operator.version for build {build_id}")
+            continue
+        
+        # Create TestResult
+        try:
+            result = process_single_nno_build(
+                pr_number,
+                job_name,
+                build_id,
+                finished_json,
+                ocp_content,
+                operator_content
+            )
+        except Exception as e:
+            logger.error(f"Failed to process build {build_id}: {e}")
+            continue
+        
+        # Validate OCP version
+        if not is_valid_ocp_version(result.ocp_full_version):
+            logger.warning(f"Skipping result - invalid OCP version '{result.ocp_full_version}' for job {job_name}")
+            continue
+        
+        # Initialize OCP version structure if needed
+        ocp_version = result.ocp_full_version
+        if ocp_version not in results_by_ocp:
+            results_by_ocp[ocp_version] = {
+                "notes": [],
+                "bundle_tests": [],
+                "release_tests": [],
+                "job_history_links": set(),
+                "test_flavors": {}
+            }
+        
+        # Add job history link
+        job_history_url = build_job_history_url(job_name)
+        results_by_ocp[ocp_version]["job_history_links"].add(job_history_url)
+        
+        # Add result to appropriate test flavor
+        test_flavor = result.test_flavor
+        if test_flavor not in results_by_ocp[ocp_version]["test_flavors"]:
+            results_by_ocp[ocp_version]["test_flavors"][test_flavor] = {
+                "results": [],
+                "job_history_links": set()
+            }
+        
+        results_by_ocp[ocp_version]["test_flavors"][test_flavor]["results"].append(result.to_dict())
+        results_by_ocp[ocp_version]["test_flavors"][test_flavor]["job_history_links"].add(job_history_url)
+        
+        processed_count += 1
+    
+    logger.info(f"Processed {processed_count} builds for PR #{pr_number}")
+
+
+def merge_and_save_results(
+    new_results: Dict[str, Dict[str, Any]],
+    output_filepath: str,
+    existing_results: Dict[str, Dict[str, Any]] = None
+) -> None:
+    """
+    Merge new results with existing results and save to file.
+    
+    Args:
+        new_results: New test results to add
+        output_filepath: Path to save merged results
+        existing_results: Existing results to merge with (optional)
+    """
+    from workflows.common.data_fetching import merge_job_history_links, convert_sets_to_lists_recursive
+    
+    if existing_results is None:
+        existing_results = {}
+    
+    # Merge results
+    merged = dict(existing_results)
+    for ocp_version, version_data in new_results.items():
+        if ocp_version not in merged:
+            merged[ocp_version] = version_data
+            # Convert sets to lists for JSON serialization
+            merged[ocp_version]["job_history_links"] = merge_job_history_links(
+                version_data.get("job_history_links", set()), []
+            )
+            for flavor, flavor_data in merged[ocp_version].get("test_flavors", {}).items():
+                flavor_data["job_history_links"] = merge_job_history_links(
+                    flavor_data.get("job_history_links", set()), []
+                )
+        else:
+            # Merge test flavors
+            existing_flavors = merged[ocp_version].get("test_flavors", {})
+            new_flavors = version_data.get("test_flavors", {})
+            
+            for flavor, flavor_data in new_flavors.items():
+                if flavor not in existing_flavors:
+                    existing_flavors[flavor] = flavor_data
+                    existing_flavors[flavor]["job_history_links"] = merge_job_history_links(
+                        flavor_data.get("job_history_links", set()), []
+                    )
+                else:
+                    # Merge results
+                    existing_flavors[flavor]["results"].extend(flavor_data["results"])
+                    
+                    # Merge job history links using common function
+                    existing_flavors[flavor]["job_history_links"] = merge_job_history_links(
+                        flavor_data.get("job_history_links", set()),
+                        existing_flavors[flavor].get("job_history_links", [])
+                    )
+            
+            merged[ocp_version]["test_flavors"] = existing_flavors
+            
+            # Merge global job history links using common function
+            merged[ocp_version]["job_history_links"] = merge_job_history_links(
+                version_data.get("job_history_links", set()),
+                merged[ocp_version].get("job_history_links", [])
+            )
+    
+    # Save to file
+    with open(output_filepath, 'w') as f:
+        json.dump(merged, f, indent=2)
+    
+    logger.info(f"Saved merged results to {output_filepath}")
+
+
+def main() -> None:
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Fetch Network Operator CI data")
+    parser.add_argument("--pr_number", required=True, help="PR number to process")
+    parser.add_argument("--baseline_data_filepath", help="Path to existing JSON data")
+    parser.add_argument("--merged_data_filepath", required=True, help="Path to save merged data")
+    
+    args = parser.parse_args()
+    
+    # Load existing data if available
+    existing_data = {}
+    if args.baseline_data_filepath:
+        try:
+            with open(args.baseline_data_filepath, 'r') as f:
+                existing_data = json.load(f)
+            logger.info(f"Loaded existing data from {args.baseline_data_filepath}")
+        except FileNotFoundError:
+            logger.info("No existing data file found, starting fresh")
+        except json.JSONDecodeError as e:
+            logger.warning(f"Failed to parse existing data: {e}, starting fresh")
+    
+    # Fetch new data
+    new_data = {}
+    process_tests_for_pr(args.pr_number, new_data)
+    
+    # Merge and save
+    merge_and_save_results(new_data, args.merged_data_filepath, existing_data)
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/workflows/nno_dashboard/generate_ci_dashboard.py b/workflows/nno_dashboard/generate_ci_dashboard.py
new file mode 100644
index 000000000..52b34c8eb
--- /dev/null
+++ b/workflows/nno_dashboard/generate_ci_dashboard.py
@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+"""
+Generate Network Operator HTML dashboard from JSON data.
+Matrix-style layout organized by Network Operator version.
+"""
+
+import argparse
+import json
+import semver
+from typing import Dict, List, Any, Set
+from datetime import datetime, timezone
+from collections import defaultdict
+
+from workflows.common import (
+    logger,
+    load_template,
+    OCP_FULL_VERSION,
+    OPERATOR_VERSION,
+    is_valid_ocp_version,
+    sanitize_id,
+)
+
+
+# Map test flavors from job names to display columns
+FLAVOR_COLUMN_MAP = {
+    "DOCA4 - RDMA Legacy SR-IOV": "Legacy SR-IOV Ethernet",
+    "Bare Metal - RDMA Legacy SR-IOV": "Legacy SR-IOV Ethernet",
+    "Hosted - RDMA Legacy SR-IOV": "Legacy SR-IOV Ethernet",
+    
+    "DOCA4 - RDMA Legacy SR-IOV with GPU": "Legacy SR-IOV Ethernet + GPU Direct",
+    "Bare Metal - RDMA Legacy SR-IOV with GPU": "Legacy SR-IOV Ethernet + GPU Direct",
+    
+    "DOCA4 - RDMA": "Shared InfiniBand",
+    "Bare Metal - RDMA": "Shared InfiniBand",
+    "Hosted - RDMA": "Shared InfiniBand",
+    
+    "DOCA4 - RDMA with GPU": "Shared InfiniBand + GPU Direct",
+    "Bare Metal - RDMA with GPU": "Shared InfiniBand + GPU Direct",
+    
+    "DOCA4 - RDMA Shared Device": "Shared Ethernet",
+    "Bare Metal - RDMA Shared Device": "Shared Ethernet",
+    "Hosted - RDMA Shared Device": "Shared Ethernet",
+    
+    "DOCA4 - RDMA Shared Device with GPU": "Shared Ethernet + GPU Direct",
+    "Bare Metal - RDMA Shared Device with GPU": "Shared Ethernet + GPU Direct",
+    
+    "DOCA4 - E2E": "Legacy SR-IOV Ethernet",
+    "Bare Metal - E2E": "Legacy SR-IOV Ethernet",
+    "Hosted - E2E": "Legacy SR-IOV Ethernet",
+}
+
+# Column order for the matrix table
+COLUMN_ORDER = [
+    "GPU Operator",
+    "Shared Ethernet",
+    "Shared Ethernet + GPU Direct",
+    "Shared InfiniBand",
+    "Shared InfiniBand + GPU Direct",
+    "Legacy SR-IOV Ethernet",
+    "Legacy SR-IOV Ethernet + GPU Direct",
+]
+
+
+def restructure_data_by_nno_version(ocp_data: Dict[str, Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+    """
+    Restructure data from OCP-centric to NNO-centric.
+    
+    Input structure (OCP-centric):
+    {
+      "4.17.16": {
+        "test_flavors": {
+          "DOCA4 - RDMA Legacy SR-IOV": {
+            "results": [{operator_version: "25.4.0", ...}]
+          }
+        }
+      }
+    }
+    
+    Output structure (NNO-centric):
+    {
+      "25.4.0": {
+        "ocp_versions": {
+          "4.17": {
+            "gpu_operators": {
+              "25.10.0": {
+                "Legacy SR-IOV Ethernet": {
+                  "status": "SUCCESS",
+                  "url": "...",
+                  "hardware": "ConnectX-5 Ex"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    """
+    nno_data = defaultdict(lambda: {"ocp_versions": defaultdict(lambda: {"gpu_operators": defaultdict(dict)})})
+    
+    for ocp_full, ocp_info in ocp_data.items():
+        if not is_valid_ocp_version(ocp_full):
+            continue
+        
+        # Get major.minor OCP version (e.g., "4.17.16" -> "4.17")
+        ocp_parts = ocp_full.split('.')
+        ocp_major_minor = f"{ocp_parts[0]}.{ocp_parts[1]}"
+        
+        test_flavors = ocp_info.get("test_flavors", {})
+        
+        for flavor_name, flavor_data in test_flavors.items():
+            # Map flavor to column
+            column = FLAVOR_COLUMN_MAP.get(flavor_name, "Other")
+            
+            for result in flavor_data.get("results", []):
+                nno_version = result.get("operator_version") or result.get("gpu_operator_version", "Unknown")
+                gpu_operator_version = "master-latest"  # TODO: Extract from test data if available
+                
+                status = result.get("test_status", "UNKNOWN")
+                url = result.get("prow_job_url", "#")
+                
+                # Store result
+                if column not in nno_data[nno_version]["ocp_versions"][ocp_major_minor]["gpu_operators"][gpu_operator_version]:
+                    nno_data[nno_version]["ocp_versions"][ocp_major_minor]["gpu_operators"][gpu_operator_version][column] = {
+                        "status": status,
+                        "url": url,
+                        "hardware": "ConnectX-6 Dx"  # TODO: Extract from test data if available
+                    }
+    
+    return dict(nno_data)
+
+
+def build_matrix_table(ocp_version: str, gpu_operators_data: Dict[str, Dict[str, Any]]) -> str:
+    """
+    Build a matrix table for a specific OCP version.
+    Only includes columns that have actual data (removes empty columns).
+    
+    Args:
+        ocp_version: OCP version (e.g., "4.20")
+        gpu_operators_data: Dictionary of GPU operator versions and their test results
+        
+    Returns:
+        HTML table string
+    """
+    if not gpu_operators_data:
+        return ""
+    
+    # Sort GPU operator versions
+    sorted_gpu_ops = sorted(gpu_operators_data.keys())
+    
+    # Determine which columns have data (not all empty)
+    columns_with_data = set()
+    for gpu_op_version in sorted_gpu_ops:
+        test_results = gpu_operators_data[gpu_op_version]
+        for column in COLUMN_ORDER[1:]:  # Skip "GPU Operator" column
+            if column in test_results:
+                columns_with_data.add(column)
+    
+    # Build list of columns to display (in order)
+    active_columns = ["GPU Operator"]  # Always include first column
+    for column in COLUMN_ORDER[1:]:
+        if column in columns_with_data:
+            active_columns.append(column)
+    
+    # If no data columns, don't build table
+    if len(active_columns) == 1:
+        return ""
+    
+    # Build table header
+    table_html = f"""
+    <div class="section-label">OpenShift {ocp_version} Compatibility</div>
+    <table id="table-nno-{sanitize_id(ocp_version)}">
+      <thead>
+        <tr>
+"""
+    
+    for column in active_columns:
+        table_html += f"          <th>{column}</th>\n"
+    
+    table_html += """        </tr>
+      </thead>
+      <tbody>
+"""
+    
+    # Build table rows (one per GPU operator version)
+    for gpu_op_version in sorted_gpu_ops:
+        test_results = gpu_operators_data[gpu_op_version]
+        
+        table_html += f"""        <tr>
+          <td class="version-cell">{gpu_op_version}</td>
+"""
+        
+        # Add cells for each active test flavor column
+        for column in active_columns[1:]:  # Skip "GPU Operator" column
+            if column in test_results:
+                result = test_results[column]
+                status = result.get("status", "UNKNOWN")
+                url = result.get("url", "#")
+                hardware = result.get("hardware", "")
+                
+                if status == "SUCCESS":
+                    icon = "✓"
+                    css_class = "success-link"
+                elif status == "FAILURE":
+                    icon = "✗"
+                    css_class = "failed-link"
+                else:
+                    icon = "⚬"
+                    css_class = "pending"
+                
+                if status in ["SUCCESS", "FAILURE"]:
+                    table_html += f'          <td><a href="{url}" target="_blank" class="{css_class}">{icon}</a>'
+                else:
+                    table_html += f'          <td><span class="{css_class}">{icon}</span>'
+                
+                if hardware:
+                    table_html += f'<br><small>{hardware}</small>'
+                table_html += '</td>\n'
+            else:
+                # This shouldn't happen since we filtered columns, but keep as fallback
+                table_html += '          <td class="empty-cell"></td>\n'
+        
+        table_html += "        </tr>\n"
+    
+    table_html += """      </tbody>
+    </table>
+"""
+    
+    return table_html
+
+
+def generate_test_matrix(ocp_data: Dict[str, Dict[str, Any]], templates_dir: str) -> str:
+    """
+    Generate the complete HTML dashboard.
+    
+    Args:
+        ocp_data: Dictionary of OCP versions and their test data (OCP-centric format)
+        templates_dir: Path to templates directory
+        
+    Returns:
+        Complete HTML string
+    """
+    # Load header template
+    header_template = load_template("header.html", templates_dir)
+    html_content = header_template
+    
+    # Restructure data to be NNO-centric
+    nno_data = restructure_data_by_nno_version(ocp_data)
+    
+    if not nno_data:
+        html_content += "<p>No valid test data found.</p>"
+        html_content += """
+  <div class="last-updated">
+    Last updated: """ + datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S") + """ UTC
+  </div>
+</body>
+</html>"""
+        return html_content
+    
+    # Sort NNO versions
+    sorted_nno_versions = sorted(nno_data.keys(), reverse=True)
+    
+    # Build TOC
+    toc_links = []
+    for nno_version in sorted_nno_versions:
+        version_id = sanitize_id(nno_version)
+        toc_links.append(f'<a href="#nno-{version_id}">{nno_version}</a>')
+    
+    html_content += f"""
+<div class="toc">
+    <div class="ocp-version-header">Network Operator Versions</div>
+    {", ".join(toc_links)}
+</div>
+"""
+    
+    # Build sections for each NNO version
+    for nno_version in sorted_nno_versions:
+        nno_info = nno_data[nno_version]
+        version_id = sanitize_id(nno_version)
+        
+        html_content += f"""      <a id="nno-{version_id}"></a>
+  <div class="ocp-version-container">
+    <div class="ocp-version-header">
+      Network Operator {nno_version}
+    </div>
+"""
+        
+        # Sort OCP versions
+        ocp_versions = nno_info.get("ocp_versions", {})
+        sorted_ocp_versions = sorted(ocp_versions.keys(), reverse=True)
+        
+        # Build matrix table for each OCP version
+        for ocp_version in sorted_ocp_versions:
+            gpu_operators_data = ocp_versions[ocp_version].get("gpu_operators", {})
+            table_html = build_matrix_table(ocp_version, gpu_operators_data)
+            html_content += table_html
+        
+        html_content += "  </div>\n\n"
+    
+    # Add footer
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+    html_content += f"""  <div class="last-updated">
+    Last updated: {timestamp} UTC
+  </div>
+</body>
+</html>
+"""
+    
+    return html_content
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Generate Network Operator CI Dashboard HTML")
+    parser.add_argument("--dashboard_data_filepath", required=True, help="Path to JSON data file")
+    parser.add_argument("--dashboard_html_filepath", required=True, help="Path to output HTML file")
+    
+    args = parser.parse_args()
+    
+    # Load JSON data
+    logger.info(f"Loading data from {args.dashboard_data_filepath}")
+    with open(args.dashboard_data_filepath, 'r') as f:
+        ocp_data = json.load(f)
+    
+    # Get templates directory
+    import os
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    templates_dir = os.path.join(script_dir, "templates")
+    
+    # Generate HTML
+    logger.info("Generating HTML dashboard")
+    html_content = generate_test_matrix(ocp_data, templates_dir)
+    
+    # Save HTML
+    logger.info(f"Saving HTML to {args.dashboard_html_filepath}")
+    with open(args.dashboard_html_filepath, 'w') as f:
+        f.write(html_content)
+    
+    logger.info("Dashboard generation complete")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/workflows/nno_dashboard/requirements.txt b/workflows/nno_dashboard/requirements.txt
new file mode 100644
index 000000000..826f7b1da
--- /dev/null
+++ b/workflows/nno_dashboard/requirements.txt
@@ -0,0 +1,4 @@
+requests>=2.31.0
+semver>=3.0.0
+pydantic>=2.0.0
+
diff --git a/workflows/nno_dashboard/templates/header.html b/workflows/nno_dashboard/templates/header.html
new file mode 100644
index 000000000..2df235b42
--- /dev/null
+++ b/workflows/nno_dashboard/templates/header.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Test Matrix: NVIDIA Network Operator on Red Hat OpenShift</title>
+  <link rel="stylesheet" href="styles.css">
+</head>
+
+<body>
+  <h2>Test Matrix: NVIDIA Network Operator on Red Hat OpenShift</h2>
diff --git a/workflows/nno_dashboard/templates/main_table.html b/workflows/nno_dashboard/templates/main_table.html
new file mode 100644
index 000000000..61a430d0c
--- /dev/null
+++ b/workflows/nno_dashboard/templates/main_table.html
@@ -0,0 +1,9 @@
+  <a id="ocp-{ocp_key}"></a>
+  <div class="ocp-version-container">
+    <div class="ocp-version-header">
+      OpenShift {ocp_key}
+    </div>
+    {notes}
+    {test_flavors_sections}
+  </div>
+
diff --git a/workflows/nno_dashboard/templates/test_flavor_section.html b/workflows/nno_dashboard/templates/test_flavor_section.html
new file mode 100644
index 000000000..f4fe7c649
--- /dev/null
+++ b/workflows/nno_dashboard/templates/test_flavor_section.html
@@ -0,0 +1,15 @@
+    <div class="test-flavor-section">
+      <div class="section-label">{test_flavor}</div>
+      <table id="table-{ocp_key}-{flavor_id}">
+        <thead>
+          <tr>
+            <th>OpenShift</th>
+            <th>NVIDIA Network Operator</th>
+          </tr>
+        </thead>
+        <tbody>
+          {flavor_table_rows}
+        </tbody>
+      </table>
+    </div>
+
diff --git a/workflows/test_matrix_dashboard/output/network_operator_matrix.json b/workflows/test_matrix_dashboard/output/network_operator_matrix.json
new file mode 100644
index 000000000..9e26dfeeb
--- /dev/null
+++ b/workflows/test_matrix_dashboard/output/network_operator_matrix.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file