diff --git a/templates/product.html b/templates/product.html
new file mode 100644
index 0000000..27fecbd
--- /dev/null
+++ b/templates/product.html
@@ -0,0 +1,42 @@
+{#
+SPDX-FileCopyrightText: &copy; 2020 Open Networking Foundation <support@opennetworking.org>
+SPDX-License-Identifier: Apache-2.0
+#}
+{% extends "base.html" %}
+{% block title %}ONF Continuous Certification - {{ product_name }}{% endblock %}
+{% block header %}ONF Continuous Certification - {{ product_name }}{% endblock %}
+{% block content %}
+
+<p>
+<em>Certification Program:</em> {{ onf_project }}<br/>
+<em>Product Name:</em> <a href="{{ product_link }}">{{ product_name }}</a>
+</p>
+
+<div class="ccresults">
+{% for group_name, jobs in groups.items() %}
+<strong>Version: {{ group_name }}</strong><br/>
+{% for job_name, builds in jobs.items() %}
+<em>Job: {{ job_name }}</em><br/>
+{% set timebox = builds | timebox(24,10) %}
+<ul>
+{% for tb in timebox %}
+<li class="{{ tb.result }}">
+  {{ tb.box_start | tsdate }} - {{ tb.outcome }}<br/>
+  {% for build in tb.builds %}
+  {% if "build_url" in build %}
+  <a href="{{ build.build_url }}" class="{{ build.result }}">{{ build.id }}</a>
+  {% else %}
+  <span class="{{ build.result }}">{{ build.id }}</span>
+  {% endif %}
+  {% else %}
+  No Builds
+  {% endfor %}
+</li>
+{% endfor %}
+</ul>
+{% endfor %}
+{% else %}
+No Tests Currently Available
+{% endfor %}
+</div>
+{% endblock %}
