diff --git a/database/src/lib.rs b/database/src/lib.rs
index b7e7e8d66..f96df1184 100644
--- a/database/src/lib.rs
+++ b/database/src/lib.rs
@@ -1238,6 +1238,16 @@ impl CollectorConfig {
     }
 }
 
+/// Mapping of a request to its parent along with all jobs
+#[derive(Debug, PartialEq)]
+pub struct InProgressRequestWithJobs {
+    /// In progress requests along with their associated jobs
+    pub request: (BenchmarkRequest, Vec<BenchmarkJob>),
+    /// Optionally the parent of the above request with _all_ their associated
+    /// jobs
+    pub parent: Option<(BenchmarkRequest, Vec<BenchmarkJob>)>,
+}
+
 /// The data that can be retrived from the database directly to populate the
 /// status page
 #[derive(Debug, PartialEq)]
@@ -1245,5 +1255,5 @@ pub struct PartialStatusPageData {
     /// A Vector of; completed requests with any associated errors
     pub completed_requests: Vec<(BenchmarkRequest, Vec<String>)>,
     /// In progress requests along with their associated jobs
-    pub in_progress: Vec<(BenchmarkRequest, Vec<BenchmarkJob>)>,
+    pub in_progress: Vec<InProgressRequestWithJobs>,
 }
diff --git a/database/src/pool.rs b/database/src/pool.rs
index c21b1bd5c..1f5587407 100644
--- a/database/src/pool.rs
+++ b/database/src/pool.rs
@@ -1098,54 +1098,54 @@ mod tests {
 
             assert!(status_page_data.in_progress.len() == 1);
             // we should have 2 jobs
-            assert!(status_page_data.in_progress[0].1.len() == 2);
+            assert!(status_page_data.in_progress[0].request.1.len() == 2);
             // the request should be in progress
             assert!(matches!(
-                status_page_data.in_progress[0].0.status(),
+                status_page_data.in_progress[0].request.0.status(),
                 BenchmarkRequestStatus::InProgress
             ));
 
             // Test the first job
             assert!(matches!(
-                status_page_data.in_progress[0].1[0].target(),
+                status_page_data.in_progress[0].request.1[0].target(),
                 Target::X86_64UnknownLinuxGnu
             ));
             assert!(matches!(
-                status_page_data.in_progress[0].1[0].status(),
+                status_page_data.in_progress[0].request.1[0].status(),
                 BenchmarkJobStatus::Queued
             ));
             assert!(matches!(
-                status_page_data.in_progress[0].1[0].backend(),
+                status_page_data.in_progress[0].request.1[0].backend(),
                 CodegenBackend::Llvm
             ));
             assert!(matches!(
-                status_page_data.in_progress[0].1[0].profile(),
+                status_page_data.in_progress[0].request.1[0].profile(),
                 Profile::Opt
             ));
             assert_eq!(
-                status_page_data.in_progress[0].1[0].benchmark_set(),
+                status_page_data.in_progress[0].request.1[0].benchmark_set(),
                 benchmark_set
             );
 
             // test the second job
             assert!(matches!(
-                status_page_data.in_progress[0].1[1].target(),
+                status_page_data.in_progress[0].request.1[1].target(),
                 Target::X86_64UnknownLinuxGnu
             ));
             assert!(matches!(
-                status_page_data.in_progress[0].1[1].status(),
+                status_page_data.in_progress[0].request.1[1].status(),
                 BenchmarkJobStatus::Queued
             ));
             assert!(matches!(
-                status_page_data.in_progress[0].1[1].backend(),
+                status_page_data.in_progress[0].request.1[1].backend(),
                 CodegenBackend::Llvm
             ));
             assert!(matches!(
-                status_page_data.in_progress[0].1[1].profile(),
+                status_page_data.in_progress[0].request.1[1].profile(),
                 Profile::Debug
             ));
             assert_eq!(
-                status_page_data.in_progress[0].1[1].benchmark_set(),
+                status_page_data.in_progress[0].request.1[1].benchmark_set(),
                 benchmark_set
             );
 
diff --git a/database/src/pool/postgres.rs b/database/src/pool/postgres.rs
index e72ea8911..1bb6adbf1 100644
--- a/database/src/pool/postgres.rs
+++ b/database/src/pool/postgres.rs
@@ -4,10 +4,11 @@ use crate::{
     ArtifactCollection, ArtifactId, ArtifactIdNumber, Benchmark, BenchmarkJob,
     BenchmarkJobConclusion, BenchmarkJobStatus, BenchmarkRequest, BenchmarkRequestIndex,
     BenchmarkRequestStatus, BenchmarkRequestType, BenchmarkSet, CodegenBackend, CollectionId,
-    CollectorConfig, Commit, CommitType, CompileBenchmark, Date, Index, PartialStatusPageData,
-    Profile, QueuedCommit, Scenario, Target, BENCHMARK_JOB_STATUS_FAILURE_STR,
-    BENCHMARK_JOB_STATUS_IN_PROGRESS_STR, BENCHMARK_JOB_STATUS_QUEUED_STR,
-    BENCHMARK_JOB_STATUS_SUCCESS_STR, BENCHMARK_REQUEST_MASTER_STR, BENCHMARK_REQUEST_RELEASE_STR,
+    CollectorConfig, Commit, CommitType, CompileBenchmark, Date, InProgressRequestWithJobs, Index,
+    PartialStatusPageData, Profile, QueuedCommit, Scenario, Target,
+    BENCHMARK_JOB_STATUS_FAILURE_STR, BENCHMARK_JOB_STATUS_IN_PROGRESS_STR,
+    BENCHMARK_JOB_STATUS_QUEUED_STR, BENCHMARK_JOB_STATUS_SUCCESS_STR,
+    BENCHMARK_REQUEST_MASTER_STR, BENCHMARK_REQUEST_RELEASE_STR,
     BENCHMARK_REQUEST_STATUS_ARTIFACTS_READY_STR, BENCHMARK_REQUEST_STATUS_COMPLETED_STR,
     BENCHMARK_REQUEST_STATUS_IN_PROGRESS_STR, BENCHMARK_REQUEST_STATUS_WAITING_FOR_ARTIFACTS_STR,
     BENCHMARK_REQUEST_TRY_STR,
@@ -1624,7 +1625,7 @@ where
 
         let requests = rows
             .into_iter()
-            .map(|it| row_to_benchmark_request(&it))
+            .map(|it| row_to_benchmark_request(&it, None))
             .collect();
         Ok(requests)
     }
@@ -1984,14 +1985,23 @@ where
     }
 
     async fn get_status_page_data(&self) -> anyhow::Result<PartialStatusPageData> {
-        let max_completed_requests = 7;
+        let max_completed_requests = 30;
 
-        // Returns in progress requests along with their associated jobs
         let in_progress_query = format!(
             "
             WITH in_progress_requests AS (
                 SELECT
-                    {BENCHMARK_REQUEST_COLUMNS}
+                    tag,
+                    parent_sha,
+                    pr,
+                    commit_type,
+                    status,
+                    created_at,
+                    completed_at,
+                    backends,
+                    profiles,
+                    commit_date,
+                    duration_ms
                 FROM
                     benchmark_request
                 WHERE
@@ -2022,15 +2032,73 @@ where
                 LEFT JOIN in_progress_requests ON job_queue.request_tag = in_progress_requests.tag
                 GROUP BY
                     job_queue.request_tag
+            ), parent AS (
+                SELECT
+                    benchmark_request.tag AS parent_tag,
+                    benchmark_request.parent_sha AS parent_sha,
+                    benchmark_request.pr AS parent_pr,
+                    benchmark_request.commit_type AS parent_commit_type,
+                    benchmark_request.status AS parent_status,
+                    benchmark_request.created_at AS parent_created_at,
+                    benchmark_request.completed_at AS parent_completed_at,
+                    benchmark_request.backends AS parent_backends,
+                    benchmark_request.profiles AS parent_profiles,
+                    benchmark_request.commit_date AS parent_commit_date,
+                    benchmark_request.duration_ms AS parent_duration_ms,
+                    EXISTS (
+                        SELECT
+                            1
+                        FROM
+                            job_queue
+                        WHERE
+                            job_queue.request_tag = benchmark_request.tag
+                            AND job_queue.status IN (
+                                '{BENCHMARK_JOB_STATUS_QUEUED_STR}',
+                                '{BENCHMARK_JOB_STATUS_IN_PROGRESS_STR}'
+                            )
+                    ) AS parent_active
+                FROM
+                    benchmark_request
+                LEFT JOIN
+                    in_progress_requests ON benchmark_request.tag = in_progress_requests.parent_sha
+            ), parent_jobs AS (
+                SELECT
+                    request_tag AS parent_tag,
+                    ARRAY_AGG(
+                        ROW(
+                            job_queue.id,
+                            job_queue.request_tag,
+                            job_queue.target,
+                            job_queue.backend,
+                            job_queue.profile,
+                            job_queue.benchmark_set,
+                            job_queue.status,
+                            job_queue.created_at,
+                            job_queue.started_at,
+                            job_queue.completed_at,
+                            job_queue.retry,
+                            job_queue.collector_name
+                        )::TEXT
+                    ) AS parent_jobs
+                FROM
+                    job_queue
+                LEFT JOIN parent ON job_queue.request_tag = parent.parent_tag
+                GROUP BY
+                    job_queue.request_tag
             )
             SELECT
                 in_progress_requests.*,
-                in_progress_jobs.jobs
+                in_progress_jobs.jobs,
+                parent.*,
+                parent_jobs.parent_jobs
             FROM
                 in_progress_requests
             LEFT JOIN
-                in_progress_jobs ON in_progress_requests.tag = in_progress_jobs.tag;
-        "
+                in_progress_jobs ON in_progress_requests.tag = in_progress_jobs.tag
+            LEFT JOIN
+                parent_jobs ON in_progress_requests.parent_sha = parent_jobs.parent_tag
+            LEFT JOIN
+                parent ON in_progress_requests.parent_sha = parent.parent_tag;"
         );
 
         // Gets requests along with how long the request took (latest job finish
@@ -2075,19 +2143,41 @@ where
         "
         );
 
-        let in_progress: Vec<(BenchmarkRequest, Vec<BenchmarkJob>)> = self
+        let in_progress: Vec<InProgressRequestWithJobs> = self
             .conn()
             .query(&in_progress_query, &[])
             .await?
             .iter()
             .map(|it| {
-                let benchmark_request = row_to_benchmark_request(it);
+                let benchmark_request = row_to_benchmark_request(it, None);
                 let jobs: Vec<BenchmarkJob> = it
                     .get::<_, Vec<String>>("jobs")
                     .iter()
                     .map(|it| benchmark_job_str_to_type(it).unwrap())
                     .collect();
-                (benchmark_request, jobs)
+
+                // This is ever-so-slightly grim however it allows us to not
+                // have to parse the text representation of the jobs. Which
+                // saves a reasonable amount of time to justify doing this.
+                let parent_active = it.get::<_, Option<bool>>("parent_active");
+
+                InProgressRequestWithJobs {
+                    request: (benchmark_request, jobs),
+                    parent: if parent_active.unwrap_or(false) {
+                        // The rows values will only be non-null if the `parent_active`
+                        // has been set
+                        let parent_benchmark_request = row_to_benchmark_request(it, Some(12));
+                        // Only parse the jobs if we need to include the parent
+                        let parent_jobs: Vec<BenchmarkJob> = it
+                            .get::<_, Vec<String>>("parent_jobs")
+                            .iter()
+                            .map(|it| benchmark_job_str_to_type(it).unwrap())
+                            .collect();
+                        Some((parent_benchmark_request, parent_jobs))
+                    } else {
+                        None
+                    },
+                }
             })
             .collect();
 
@@ -2098,81 +2188,13 @@ where
             .iter()
             .map(|it| {
                 (
-                    row_to_benchmark_request(it),
+                    row_to_benchmark_request(it, None),
                     // The errors, if there are none this will be an empty vector
                     it.get::<_, Option<Vec<String>>>(11).unwrap_or_default(),
                 )
             })
             .collect();
 
-        let in_progress_tags: Vec<&str> =
-            in_progress.iter().map(|it| it.0.tag().unwrap()).collect();
-
-        let in_progress_tags: String = in_progress_tags.join(",");
-
-        // We don't do a status check on the jobs as we want to return all jobs,
-        // irrespective of status, that are attached to an inprogress
-        // benchmark_request
-        let rows = self
-            .conn()
-            .query(
-                "SELECT
-                    id,
-                    target,
-                    backend,
-                    profile,
-                    request_tag,
-                    benchmark_set,
-                    created_at,
-                    status,
-                    started_at,
-                    collector_name,
-                    completed_at,
-                    retry
-                FROM
-                    job_queue WHERE job_queue.request_tag IN ($1);",
-                &[&in_progress_tags],
-            )
-            .await?;
-
-        let mut in_progress_jobs = vec![];
-        for row in rows {
-            let status_str = row.get::<_, &str>(7);
-            let status = match status_str {
-                BENCHMARK_JOB_STATUS_QUEUED_STR => BenchmarkJobStatus::Queued,
-                BENCHMARK_JOB_STATUS_IN_PROGRESS_STR => BenchmarkJobStatus::InProgress {
-                    started_at: row.get::<_, DateTime<Utc>>(8),
-                    collector_name: row.get::<_, String>(9),
-                },
-                BENCHMARK_JOB_STATUS_SUCCESS_STR | BENCHMARK_JOB_STATUS_FAILURE_STR => {
-                    BenchmarkJobStatus::Completed {
-                        started_at: row.get::<_, DateTime<Utc>>(8),
-                        collector_name: row.get::<_, String>(9),
-                        success: status_str == BENCHMARK_JOB_STATUS_SUCCESS_STR,
-                        completed_at: row.get::<_, DateTime<Utc>>(10),
-                    }
-                }
-                _ => panic!("Invalid benchmark job status: {status_str}"),
-            };
-
-            let job = BenchmarkJob {
-                id: row.get::<_, i32>(0) as u32,
-                target: Target::from_str(row.get::<_, &str>(1)).map_err(|e| anyhow::anyhow!(e))?,
-                backend: CodegenBackend::from_str(row.get::<_, &str>(2))
-                    .map_err(|e| anyhow::anyhow!(e))?,
-                profile: Profile::from_str(row.get::<_, &str>(3))
-                    .map_err(|e| anyhow::anyhow!(e))?,
-                request_tag: row.get::<_, String>(4),
-                benchmark_set: BenchmarkSet(row.get::<_, i32>(5) as u32),
-                created_at: row.get::<_, DateTime<Utc>>(6),
-                // The job is now in an in_progress state
-                status,
-                deque_counter: row.get::<_, i32>(11) as u32,
-            };
-
-            in_progress_jobs.push(job);
-        }
-
         Ok(PartialStatusPageData {
             completed_requests,
             in_progress,
@@ -2231,18 +2253,19 @@ where
     }
 }
 
-fn row_to_benchmark_request(row: &Row) -> BenchmarkRequest {
-    let tag = row.get::<_, Option<String>>(0);
-    let parent_sha = row.get::<_, Option<String>>(1);
-    let pr = row.get::<_, Option<i32>>(2);
-    let commit_type = row.get::<_, &str>(3);
-    let status = row.get::<_, &str>(4);
-    let created_at = row.get::<_, DateTime<Utc>>(5);
-    let completed_at = row.get::<_, Option<DateTime<Utc>>>(6);
-    let backends = row.get::<_, String>(7);
-    let profiles = row.get::<_, String>(8);
-    let commit_date = row.get::<_, Option<DateTime<Utc>>>(9);
-    let duration_ms = row.get::<_, Option<i32>>(10);
+fn row_to_benchmark_request(row: &Row, row_offset: Option<usize>) -> BenchmarkRequest {
+    let row_offset = row_offset.unwrap_or(0);
+    let tag = row.get::<_, Option<String>>(row_offset);
+    let parent_sha = row.get::<_, Option<String>>(1 + row_offset);
+    let pr = row.get::<_, Option<i32>>(2 + row_offset);
+    let commit_type = row.get::<_, &str>(3 + row_offset);
+    let status = row.get::<_, &str>(4 + row_offset);
+    let created_at = row.get::<_, DateTime<Utc>>(5 + row_offset);
+    let completed_at = row.get::<_, Option<DateTime<Utc>>>(6 + row_offset);
+    let backends = row.get::<_, String>(7 + row_offset);
+    let profiles = row.get::<_, String>(8 + row_offset);
+    let commit_date = row.get::<_, Option<DateTime<Utc>>>(9 + row_offset);
+    let duration_ms = row.get::<_, Option<i32>>(10 + row_offset);
 
     let pr = pr.map(|v| v as u32);
 
diff --git a/site/frontend/src/pages/status_new/collector.vue b/site/frontend/src/pages/status_new/collector.vue
index 5f606f93c..3123ecf00 100644
--- a/site/frontend/src/pages/status_new/collector.vue
+++ b/site/frontend/src/pages/status_new/collector.vue
@@ -1,13 +1,18 @@
 <script setup lang="ts">
-import {CollectorConfigAndWork, CollectorConfig} from "./data";
+import {BenchmarkJob, CollectorInfo, CollectorConfig} from "./data";
 
 const props = defineProps<{
-  collector: CollectorConfigAndWork;
+  collector: CollectorInfo;
+  jobMap: Dict<BenchmarkJob>;
 }>();
 
 function statusClass(c: CollectorConfig): string {
   return c.isActive ? "active" : "inactive";
 }
+
+function getStartedAt(j: BenchmarkJob): string {
+  return "startedAt" in j.status ? j.status.startedAt : "";
+}
 </script>
 
 <template>
@@ -55,59 +60,43 @@ function statusClass(c: CollectorConfig): string {
       </div>
     </div>
 
-    <div v-if="collector.request !== null">
-      <div class="table-collector-wrapper">
-        <table class="table-collector">
-          <caption>
-            current benchmark request
-          </caption>
-          <thead>
-            <tr class="table-header-row">
-              <th class="table-header-padding">Type</th>
-              <th class="table-header-padding">Created At</th>
-              <th class="table-header-padding">Sha / Tag</th>
-            </tr>
-          </thead>
-          <tbody>
-            <tr>
-              <td class="table-cell-padding">{{ collector.request.type }}</td>
-              <td class="table-cell-padding">
-                {{ collector.request.createdAt }}
-              </td>
-              <td class="table-cell-padding">{{ collector.request.tag }}</td>
-            </tr>
-          </tbody>
-        </table>
-      </div>
-
-      <div class="table-collector-wrapper">
-        <table class="table-collector" style="border-collapse: collapse">
-          <caption>
-            current benchmark jobs
-          </caption>
-          <thead>
-            <tr class="table-header-row">
-              <th class="table-header-padding">State</th>
-              <th class="table-header-padding">Started At</th>
-              <th class="table-header-padding">Backend</th>
-              <th class="table-header-padding">Profile</th>
-              <th class="table-header-padding">Dequeue Counter</th>
-            </tr>
-          </thead>
-          <tbody>
-            <tr v-for="j in collector.jobs">
-              <td class="table-cell-padding">{{ j.state }}</td>
-              <td class="table-cell-padding">{{ j.startedAt }}</td>
-              <td class="table-cell-padding">{{ j.backend }}</td>
-              <td class="table-cell-padding">{{ j.profile }}</td>
-              <td class="table-cell-padding">{{ j.dequeCounter }}</td>
-            </tr>
-          </tbody>
-        </table>
-      </div>
+    <div class="table-collector-wrapper">
+      <table class="table-collector" style="border-collapse: collapse">
+        <caption>
+          current benchmark jobs
+        </caption>
+        <thead>
+          <tr class="table-header-row">
+            <th class="table-header-padding">Tag / Sha</th>
+            <th class="table-header-padding">State</th>
+            <th class="table-header-padding">Started At</th>
+            <th class="table-header-padding">Backend</th>
+            <th class="table-header-padding">Profile</th>
+            <th class="table-header-padding">Dequeue Counter</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr v-for="id in collector.jobIds">
+            <td class="table-cell-padding">
+              {{ jobMap[id].requestTag }}
+            </td>
+            <td class="table-cell-padding">
+              {{ jobMap[id].status.state }}
+            </td>
+            <td class="table-cell-padding">
+              {{ getStartedAt(jobMap[id]) }}
+            </td>
+            <td class="table-cell-padding">{{ jobMap[id].backend }}</td>
+            <td class="table-cell-padding">{{ jobMap[id].profile }}</td>
+            <td class="table-cell-padding">
+              {{ jobMap[id].dequeCounter }}
+            </td>
+          </tr>
+        </tbody>
+      </table>
     </div>
 
-    <div class="collector-no-work" v-if="collector.request === null">
+    <div class="collector-no-work" v-if="collector.jobIds.length === 0">
       <h3>no active benchmarks 🦦</h3>
     </div>
   </div>
diff --git a/site/frontend/src/pages/status_new/data.ts b/site/frontend/src/pages/status_new/data.ts
index 345f5f955..4066b4934 100644
--- a/site/frontend/src/pages/status_new/data.ts
+++ b/site/frontend/src/pages/status_new/data.ts
@@ -150,87 +150,15 @@ export type CollectorConfig = {
   dateAdded: string;
 };
 
-export type StatusResponseInProgress = {
-  request: BenchmarkRequestInProgress;
-  jobs: BenchmarkJob[];
+export type CollectorInfo = {
+  config: CollectorConfig;
+  jobIds: number[];
 };
 
 export type StatusResponse = {
-  completed: BenchmarkRequestComplete[];
-  inProgress: StatusResponseInProgress[];
-  collectorConfigs: CollectorConfig[];
-  queue: BenchmarkRequest[];
-};
-
-type SimpleJob = {
-  state: BenchmarkJobStatusStr;
-  startedAt: string;
-  backend: string;
-  profile: string;
-  dequeCounter: number;
+  queueRequestTags: string[];
+  requestsMap: Dict<BenchmarkRequest>;
+  jobMap: Dict<BenchmarkJob>;
+  collectorWorkMap: Dict<CollectorInfo>;
+  tagToJobs: Dict<number[]>;
 };
-
-type SimpleRequest = {
-  type: BenchmarkRequestTypeStr;
-  tag: string;
-  createdAt: string;
-};
-
-export type CollectorConfigAndWork = {
-  jobs: SimpleJob[];
-  config: CollectorConfig;
-  request: SimpleRequest | null;
-};
-
-export type CollectorJobMap = {
-  [key: string]: CollectorConfigAndWork;
-};
-
-/* @TODO; Do this in Rust in the api */
-export function createCollectorJobMap(
-  collectorConfigs: CollectorConfig[],
-  inProgress: StatusResponseInProgress[]
-): CollectorJobMap {
-  const collectorJobMap: CollectorJobMap = {};
-
-  for (const collectorConfig of collectorConfigs) {
-    collectorJobMap[collectorConfig.name] = {
-      request: null,
-      jobs: [],
-      config: collectorConfig,
-    };
-  }
-
-  for (const {request, jobs} of inProgress) {
-    const simpleReq: SimpleRequest = {
-      type: request.requestType.type,
-      tag: request.requestType.tag,
-      createdAt: request.createdAt,
-    };
-    for (const j of jobs) {
-      if (j.status.state !== BenchmarkJobQueued) {
-        const simpleJob: SimpleJob = {
-          state: j.status.state,
-          startedAt: j.status.startedAt,
-          profile: j.profile,
-          backend: j.backend,
-          dequeCounter: j.dequeCounter,
-        };
-        if (collectorJobMap[j.status.collectorName].request == null) {
-          collectorJobMap[j.status.collectorName].request = simpleReq;
-        }
-        /* There will be one in_progress job and a few success/failures*/
-        collectorJobMap[j.status.collectorName].jobs.push(simpleJob);
-      }
-    }
-  }
-  return collectorJobMap;
-}
-
-/* @TODO; Do this in Rust in the api */
-export function createTimeline(
-  completed: BenchmarkRequestComplete[],
-  queue: BenchmarkRequest[]
-) {
-  return queue.concat(<BenchmarkRequest[]>completed);
-}
diff --git a/site/frontend/src/pages/status_new/page.vue b/site/frontend/src/pages/status_new/page.vue
index 4d9875255..f245ee152 100644
--- a/site/frontend/src/pages/status_new/page.vue
+++ b/site/frontend/src/pages/status_new/page.vue
@@ -7,35 +7,87 @@ import {withLoading} from "../../utils/loading";
 import {formatSecondsAsDuration} from "../../utils/formatting";
 import {
   StatusResponse,
-  CollectorJobMap,
   BenchmarkRequestType,
   BenchmarkRequest,
+  BenchmarkJob,
+  CollectorInfo,
   ReleaseCommit,
-  createCollectorJobMap,
-  createTimeline,
   BenchmarkRequestCompleteStr,
+  BenchmarkRequestInProgressStr,
 } from "./data";
 import Collector from "./collector.vue";
 
+const loading = ref(true);
+
+const dataNew: Ref<{
+  queueLength: number;
+  timeline: BenchmarkRequestWithWaterLine[];
+  requestsMap: Dict<BenchmarkRequest>;
+  jobMap: Dict<BenchmarkJob>;
+  collectorWorkMap: Dict<CollectorInfo>;
+  tagToJobs: Dict<number[]>;
+} | null> = ref(null);
+
+type BenchmarkRequestWithWaterLine = BenchmarkRequest & {isWaterLine: boolean};
+
+function requestIsInProgress(req: BenchmarkRequest, tagToJobs: Dict<number[]>) {
+  switch (req.status.state) {
+    case BenchmarkRequestCompleteStr:
+      if (req.requestType.tag in tagToJobs) {
+        return true;
+      }
+      return false;
+    case BenchmarkRequestInProgressStr:
+      return true;
+    default:
+      return false;
+  }
+}
+
+function getRequestRowClassName(
+  req: BenchmarkRequestWithWaterLine,
+  tagToJobs: Dict<number[]>
+) {
+  const inProgress = requestIsInProgress(req, tagToJobs);
+  if (inProgress && req.isWaterLine) {
+    return "timeline-waterline";
+  } else if (inProgress) {
+    return "timeline-row-bold";
+  }
+  return "";
+}
+
 async function loadStatusNew(loading: Ref<boolean>) {
   dataNew.value = await withLoading(loading, async () => {
     let d: StatusResponse = await getJson<StatusResponse>(STATUS_DATA_NEW_URL);
+    let timeline: BenchmarkRequestWithWaterLine[] = [];
+    // figure out where to draw the line.
+    for (let i = 1; i < d.queueRequestTags.length; ++i) {
+      let req = d.requestsMap[d.queueRequestTags[i - 1]];
+      let nextReq = d.requestsMap[d.queueRequestTags[i]];
+      let isWaterLine = false;
+      if (
+        requestIsInProgress(req, d.tagToJobs) &&
+        !requestIsInProgress(nextReq, d.tagToJobs)
+      ) {
+        isWaterLine = true;
+      }
+      timeline.push({
+        ...req,
+        isWaterLine,
+      });
+    }
     return {
-      queueLength: d.queue.length,
-      collectorJobMap: createCollectorJobMap(d.collectorConfigs, d.inProgress),
-      timeline: createTimeline(d.completed, d.queue),
+      queueLength: d.queueRequestTags.length,
+      timeline,
+      requestsMap: d.requestsMap,
+      jobMap: d.jobMap,
+      collectorWorkMap: d.collectorWorkMap,
+      tagToJobs: d.tagToJobs,
     };
   });
 }
 
-const loading = ref(true);
-/* @TODO; redo type */
-const dataNew: Ref<{
-  queueLength: number;
-  collectorJobMap: CollectorJobMap;
-  timeline: BenchmarkRequest[];
-} | null> = ref(null);
-
 function getCreatedAt(request: BenchmarkRequest): string {
   if (request.status.state == BenchmarkRequestCompleteStr) {
     return request.status.completedAt;
@@ -86,13 +138,20 @@ loadStatusNew(loading);
           </thead>
           <tbody>
             <template v-for="req in dataNew.timeline">
-              <tr>
+              <tr :class="getRequestRowClassName(req, dataNew.tagToJobs)">
                 <td><PullRequestLink :requestType="req.requestType" /></td>
                 <td>{{ req.requestType.type }}</td>
                 <td>
                   {{ req.requestType.tag }}
                 </td>
-                <td>{{ req.status.state }}</td>
+                <td>
+                  {{
+                    req.status.state === BenchmarkRequestCompleteStr &&
+                    req.requestType.tag in dataNew.tagToJobs
+                      ? `${req.status.state}*`
+                      : `${req.status.state}`
+                  }}
+                </td>
                 <td v-html="getCreatedAt(req)"></td>
                 <td v-html="getDuration(req)"></td>
                 <td>
@@ -107,10 +166,10 @@ loadStatusNew(loading);
         <h1>Collectors</h1>
         <div class="collectors-grid">
           <div
-            :key="cc[0]"
-            v-for="cc in Object.entries(dataNew.collectorJobMap)"
+            v-for="cc in Object.values(dataNew.collectorWorkMap)"
+            :key="cc.config.name"
           >
-            <Collector :collector="cc[1]" />
+            <Collector :jobMap="dataNew.jobMap" :collector="cc" />
           </div>
         </div>
       </div>
@@ -135,6 +194,15 @@ loadStatusNew(loading);
   padding-left: 8px;
 }
 
+.timeline-waterline {
+  border-bottom: 1px solid black;
+  font-weight: bold;
+}
+
+.timeline-row-bold {
+  font-weight: bold;
+}
+
 .timeline-wrapper {
   display: flex;
   justify-content: center;
diff --git a/site/src/api.rs b/site/src/api.rs
index ea324a6d1..47b292213 100644
--- a/site/src/api.rs
+++ b/site/src/api.rs
@@ -394,6 +394,7 @@ pub mod status {
 pub mod status_new {
     use chrono::{DateTime, Utc};
     use database::BenchmarkSet;
+    use hashbrown::HashMap;
     use serde::Serialize;
 
     #[derive(Serialize, Debug)]
@@ -454,7 +455,7 @@ pub mod status_new {
         pub jobs: Vec<BenchmarkJobUi>,
     }
 
-    #[derive(Serialize, Debug)]
+    #[derive(Serialize, Debug, Clone)]
     #[serde(rename_all = "camelCase")]
     pub struct CollectorConfigUi {
         pub name: String,
@@ -465,17 +466,29 @@ pub mod status_new {
         pub date_added: DateTime<Utc>,
     }
 
+    #[derive(Serialize, Debug, Clone)]
+    #[serde(rename_all = "camelCase")]
+    pub struct CollectorInfo {
+        /// Configuration for the collector
+        pub config: CollectorConfigUi,
+        /// Jobs that are assigned to the collector from the currently inprogress
+        /// request and possibly that request's parent.
+        pub job_ids: Vec<u32>,
+    }
+
     #[derive(Serialize, Debug)]
     #[serde(rename_all = "camelCase")]
     pub struct Response {
-        /// Completed requests alongside any errors
-        pub completed: Vec<BenchmarkRequestUi>,
-        /// In progress requests alongside the jobs associated with the request
-        pub in_progress: Vec<BenchmarkInProgressUi>,
-        /// Configuration for all collectors including ones that are inactive
-        pub collector_configs: Vec<CollectorConfigUi>,
-        /// The current queue
-        pub queue: Vec<BenchmarkRequestUi>,
+        /// The current queue, ordered `in_progress`, ... the queue, `completed`
+        pub queue_request_tags: Vec<String>,
+        /// Hash table of request tags to requests
+        pub requests_map: HashMap<String, BenchmarkRequestUi>,
+        /// Hash table of job ids to jobs
+        pub job_map: HashMap<u32, BenchmarkJobUi>,
+        /// Hash table of benchmark set ids to CollectorInfo
+        pub collector_work_map: HashMap<u32, CollectorInfo>,
+        /// Request tag to a vector of job ids
+        pub tag_to_jobs: HashMap<String, Vec<u32>>,
     }
 }
 
diff --git a/site/src/request_handlers/status_page_new.rs b/site/src/request_handlers/status_page_new.rs
index 12087f88b..61d19548c 100644
--- a/site/src/request_handlers/status_page_new.rs
+++ b/site/src/request_handlers/status_page_new.rs
@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
 use crate::api::status_new::{
-    BenchmarkInProgressUi, BenchmarkJobStatusUi, BenchmarkJobUi, BenchmarkRequestStatusUi,
-    BenchmarkRequestTypeUi, BenchmarkRequestUi, CollectorConfigUi,
+    BenchmarkJobStatusUi, BenchmarkJobUi, BenchmarkRequestStatusUi, BenchmarkRequestTypeUi,
+    BenchmarkRequestUi, CollectorConfigUi, CollectorInfo,
 };
 use crate::api::{status_new, ServerResult};
 use crate::job_queue::build_queue;
@@ -10,6 +10,7 @@ use crate::load::SiteCtxt;
 use database::{
     BenchmarkJob, BenchmarkJobStatus, BenchmarkRequest, BenchmarkRequestStatus, CollectorConfig,
 };
+use hashbrown::HashMap;
 
 fn benchmark_request_status_to_ui(status: BenchmarkRequestStatus) -> BenchmarkRequestStatusUi {
     let (completed_at, duration_s) = match status {
@@ -108,7 +109,7 @@ pub async fn handle_status_page_new(ctxt: Arc<SiteCtxt>) -> ServerResult<status_
 
     let error_to_string = |e: anyhow::Error| e.to_string();
 
-    let collector_configs = conn
+    let collector_configs: Vec<CollectorConfigUi> = conn
         .get_collector_configs()
         .await
         .map_err(error_to_string)?
@@ -129,32 +130,115 @@ pub async fn handle_status_page_new(ctxt: Arc<SiteCtxt>) -> ServerResult<status_
         .await
         .map_err(error_to_string)?;
 
+    // We add the in_progress_tags first, then the queue, then completed
+    let mut queue_request_tags: Vec<String> = vec![];
+    let mut requests_map: HashMap<String, BenchmarkRequestUi> = HashMap::new();
+    let mut job_map: HashMap<u32, BenchmarkJobUi> = HashMap::new();
+    let mut collector_work_map: HashMap<u32, CollectorInfo> = HashMap::new();
+    let mut tag_to_jobs: HashMap<String, Vec<u32>> = HashMap::new();
+
+    for it in collector_configs.iter() {
+        // Multiple collectors cannot be part of the same set
+        collector_work_map.insert(
+            it.benchmark_set.0,
+            CollectorInfo {
+                config: it.clone(),
+                job_ids: vec![],
+            },
+        );
+    }
+
+    let mut jobs: Vec<&BenchmarkJob> = vec![];
+
+    for it in partial_data.in_progress.iter() {
+        let tag = it.request.0.tag().unwrap().to_string();
+        queue_request_tags.push(tag.clone());
+        requests_map.insert(
+            tag.clone(),
+            benchmark_request_to_ui(&it.request.0, vec![]).map_err(error_to_string)?,
+        );
+
+        for job in it.request.1.iter() {
+            if let Some(jobs) = tag_to_jobs.get_mut(&tag) {
+                jobs.push(job.id());
+            } else {
+                tag_to_jobs.insert(tag.clone(), vec![job.id()]);
+            }
+            jobs.push(job);
+        }
+
+        if let Some(parent) = &it.parent {
+            let parent_tag = parent.0.tag().unwrap().to_string();
+            queue_request_tags.push(parent_tag.clone());
+            requests_map.insert(
+                parent_tag.clone(),
+                benchmark_request_to_ui(&parent.0, vec![]).map_err(error_to_string)?,
+            );
+
+            for parent_job in parent.1.iter() {
+                if let Some(jobs) = tag_to_jobs.get_mut(&parent_tag) {
+                    jobs.push(parent_job.id());
+                } else {
+                    tag_to_jobs.insert(parent_tag.clone(), vec![parent_job.id()]);
+                }
+                jobs.push(parent_job);
+            }
+        }
+    }
+
     // Create the queue
-    // @TODO; do we need both the queue and the inprogress jobs from the database?
     let queue = build_queue(&*conn, &index).await.map_err(error_to_string)?;
 
-    let mut completed: Vec<BenchmarkRequestUi> = vec![];
-    for it in partial_data.completed_requests {
-        completed.push(benchmark_request_to_ui(&it.0, it.1).map_err(error_to_string)?);
+    for it in queue.iter() {
+        // We have already added the inprogress tags to the queue from the above
+        // transformative loop. We do that as the queue will not clock that a
+        // parent request is going to have work despite having a status of
+        // `complete`.
+        let tag = it.tag().unwrap().to_string();
+        if !matches!(it.status(), BenchmarkRequestStatus::InProgress) {
+            queue_request_tags.push(tag.clone());
+            requests_map.insert(
+                tag,
+                benchmark_request_to_ui(it, vec![]).map_err(error_to_string)?,
+            );
+        }
     }
 
-    let mut in_progress: Vec<BenchmarkInProgressUi> = vec![];
-    for it in partial_data.in_progress {
-        in_progress.push(BenchmarkInProgressUi {
-            request: benchmark_request_to_ui(&it.0, vec![]).map_err(error_to_string)?,
-            jobs: it.1.iter().map(benchmark_job_to_ui).collect(),
-        });
+    for it in partial_data.completed_requests {
+        let tag = it.0.tag().unwrap().to_string();
+        // To get the requests for the queue in the front end we iterate over
+        // the tags array then index requests map.
+        requests_map.insert(
+            tag,
+            benchmark_request_to_ui(&it.0, it.1).map_err(error_to_string)?,
+        );
     }
 
-    let mut queue_ui: Vec<BenchmarkRequestUi> = vec![];
-    for it in queue {
-        queue_ui.push(benchmark_request_to_ui(&it, vec![]).map_err(error_to_string)?);
+    // sort the jobs
+    jobs.sort_by_key(|job| {
+        (
+            match job.status() {
+                BenchmarkJobStatus::InProgress { .. } => 0,
+                BenchmarkJobStatus::Queued => 1,
+                BenchmarkJobStatus::Completed { .. } => 2,
+            },
+            job.created_at(),
+        )
+    });
+
+    for it in jobs.iter() {
+        let ui_job = benchmark_job_to_ui(it);
+        job_map.insert(it.id(), ui_job);
+        if let Some(collector) = collector_work_map.get_mut(&it.benchmark_set().0) {
+            collector.job_ids.push(it.id());
+        }
     }
 
     Ok(status_new::Response {
-        completed,
-        in_progress,
-        collector_configs,
-        queue: queue_ui,
+        queue_request_tags,
+        requests_map,
+        job_map,
+        collector_work_map,
+        tag_to_jobs,
     })
 }