diff --git a/site/src/api.rs b/site/src/api.rs
index f5a849e4f..65587550e 100644
--- a/site/src/api.rs
+++ b/site/src/api.rs
@@ -394,12 +394,45 @@ pub mod github {
         pub number: u32,
         pub comments_url: String,
         pub repository_url: String,
+        pub labels: Vec<Label>,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+    pub struct Label {
+        pub name: String,
     }
 
     #[derive(Debug, Clone, Serialize, Deserialize)]
-    pub struct Request {
-        pub issue: Issue,
-        pub comment: Comment,
+    #[serde(untagged)]
+    pub enum Request {
+        Issue { issue: Issue, comment: Comment },
+        Push(Push),
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct Push {
+        pub r#ref: String,
+        pub sender: Sender,
+        pub head_commit: HeadCommit,
+        pub before: String,
+        pub commits: Vec<Commit>,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct Commit {
+        #[serde(rename = "id")]
+        pub sha: String,
+        pub message: String,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct HeadCommit {
+        pub message: String,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct Sender {
+        pub login: String,
     }
 
     #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/site/src/github.rs b/site/src/github.rs
index 9a3b1425a..9e29ee671 100644
--- a/site/src/github.rs
+++ b/site/src/github.rs
@@ -1,14 +1,15 @@
-use crate::api::github::Issue;
+pub mod client;
+
+use crate::api::github::{Commit, Issue};
 use crate::comparison::{
     deserves_attention_icount, write_summary_table, write_summary_table_footer, ArtifactComparison,
     ArtifactComparisonSummary, Direction, Metric,
 };
-use crate::load::{Config, SiteCtxt, TryCommit};
+use crate::load::{SiteCtxt, TryCommit};
 
 use anyhow::Context as _;
 use database::{ArtifactId, QueuedCommit};
-use reqwest::header::USER_AGENT;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 
 use std::collections::HashSet;
 
@@ -32,42 +33,126 @@ pub async fn get_authorized_users() -> Result<Vec<usize>, String> {
         .map(|perms| perms.github_ids)
 }
 
+/// Enqueues try builds on the try-perf branch for every rollup merge in `rollup_merges`.
+/// Returns a mapping between the rollup merge commit and the try build sha.
+pub async fn enqueue_unrolled_try_builds<'a>(
+    client: client::Client,
+    rollup_merges: impl Iterator<Item = &'a Commit>,
+    previous_master: &str,
+) -> Result<Vec<(&'a Commit, String)>, String> {
+    let mut mapping = Vec::new();
+    for rollup_merge in rollup_merges {
+        // Fetch the rollup merge commit which should have two parents.
+        // The first parent is in the chain of rollup merge commits all the way back to `previous_master`.
+        // The second parent is the head of the PR that was rolled up. We want the second parent.
+        let commit = client.get_commit(&rollup_merge.sha).await.map_err(|e| {
+            format!(
+                "Error getting rollup merge commit '{}': {e:?}",
+                rollup_merge.sha
+            )
+        })?;
+        assert!(
+            commit.parents.len() == 2,
+            "What we thought was a merge commit was not a merge commit. sha: {}",
+            rollup_merge.sha
+        );
+        let rolled_up_head = &commit.parents[1].sha;
+
+        // Reset perf-tmp to the previous master
+        client
+            .update_branch("perf-tmp", previous_master)
+            .await
+            .map_err(|e| format!("Error updating perf-tmp with previous master: {e:?}"))?;
+
+        // Merge in the rolled up PR's head commit into the previous master
+        let sha = client
+            .merge_branch("perf-tmp", rolled_up_head, "merge")
+            .await
+            .map_err(|e| format!("Error merging commit into perf-tmp: {e:?}"))?;
+
+        // Force the `try-perf` branch to point to what the perf-tmp branch points to
+        client
+            .update_branch("try-perf", &sha)
+            .await
+            .map_err(|e| format!("Error updating the try-perf branch: {e:?}"))?;
+
+        mapping.push((rollup_merge, sha));
+        // Wait to ensure there's enough time for GitHub to checkout these changes before they are overwritten
+        tokio::time::sleep(std::time::Duration::from_secs(15)).await
+    }
+
+    Ok(mapping)
+}
+
+lazy_static::lazy_static! {
+    static ref ROLLUP_PR_NUMBER: regex::Regex =
+        regex::Regex::new(r#"^Auto merge of #(\d+)"#).unwrap();
+}
+
+// Gets the pr number for the associated rollup PR message. Returns None if this is not a rollup PR
+pub async fn rollup_pr(client: &client::Client, message: &str) -> Result<Option<u32>, String> {
+    if !message.starts_with("Auto merge of") {
+        return Ok(None);
+    }
+
+    let number = ROLLUP_PR_NUMBER
+        .captures(&message)
+        .and_then(|c| c.get(1))
+        .map(|m| m.as_str().parse::<u64>())
+        .transpose()
+        .map_err(|e| format!("Error parsing PR number from '{message}': {e:?}"))?;
+
+    let number = match number {
+        Some(n) => n,
+        None => return Ok(None),
+    };
+
+    let issue = client
+        .get_issue(number)
+        .await
+        .map_err(|e| format!("Error fetching PR #{number} {e:?}"))?;
+
+    Ok(issue
+        .labels
+        .iter()
+        .any(|l| l.name == "rollup")
+        .then(|| issue.number))
+}
+
 // Returns the PR number
 pub async fn pr_and_try_for_rollup(
-    client: &reqwest::Client,
     ctxt: Arc<SiteCtxt>,
     repository_url: &str,
     rollup_merge_sha: &str,
     origin_url: &str,
 ) -> anyhow::Result<u32> {
+    let client = client::Client::from_ctxt(&ctxt, repository_url.to_owned());
     log::trace!(
         "creating PR for {:?} {:?}",
         repository_url,
         rollup_merge_sha
     );
-    let branch = branch_for_rollup(client, &ctxt, repository_url, rollup_merge_sha).await?;
+    let branch = branch_for_rollup(&ctxt, repository_url, rollup_merge_sha).await?;
 
-    let pr = create_pr(
-        client,
-        &ctxt,
-        repository_url,
-        &format!(
-            "[DO NOT MERGE] perf-test for #{}",
-            branch.rolled_up_pr_number
-        ),
-        &format!("rust-timer:{}", branch.name),
-        "master",
-        &format!(
-            "This is an automatically generated pull request (from [here]({})) to \
+    let pr = client
+        .create_pr(
+            &format!(
+                "[DO NOT MERGE] perf-test for #{}",
+                branch.rolled_up_pr_number
+            ),
+            &format!("rust-timer:{}", branch.name),
+            "master",
+            &format!(
+                "This is an automatically generated pull request (from [here]({})) to \
             run perf tests for #{} which merged in a rollup.
 
 r? @ghost",
-            origin_url, branch.rolled_up_pr_number
-        ),
-        true,
-    )
-    .await
-    .context("Created PR")?;
+                origin_url, branch.rolled_up_pr_number
+            ),
+            true,
+        )
+        .await
+        .context("Created PR")?;
 
     let pr_number = pr.number;
     let rollup_merge_sha = rollup_merge_sha.to_owned();
@@ -82,11 +167,11 @@ r? @ghost",
         // Eventually we'll want to handle this automatically, but that's a ways
         // off: we'd need to store the state in the database and handle the try
         // build starting and generally that's a lot of work for not too much gain.
-        post_comment(
-            &ctxt.config,
-            pr.number,
-            &format!(
-                "@bors try @rust-timer queue
+        client
+            .post_comment(
+                pr.number,
+                &format!(
+                    "@bors try @rust-timer queue
 
 The try commit's (master) parent should be {master}. If it isn't, \
 then please:
@@ -97,11 +182,11 @@ then please:
 
 You do not need to reinvoke the queue command as long as the perf \
 build hasn't yet started.",
-                master = branch.master_base_sha,
-                merge = rollup_merge_sha,
-            ),
-        )
-        .await;
+                    master = branch.master_base_sha,
+                    merge = rollup_merge_sha,
+                ),
+            )
+            .await;
     });
 
     Ok(pr_number)
@@ -114,12 +199,15 @@ pub struct RollupBranch {
 }
 
 pub async fn branch_for_rollup(
-    client: &reqwest::Client,
     ctxt: &SiteCtxt,
     repository_url: &str,
     rollup_merge_sha: &str,
 ) -> anyhow::Result<RollupBranch> {
-    let rollup_merge = get_commit(&client, &ctxt, repository_url, rollup_merge_sha)
+    let client = client::Client::from_ctxt(ctxt, repository_url.to_owned());
+    let timer = "https://api.github.com/repos/rust-timer/rust";
+    let timer_client = client::Client::from_ctxt(ctxt, timer.to_owned());
+    let rollup_merge = client
+        .get_commit(rollup_merge_sha)
         .await
         .context("got rollup merge")?;
 
@@ -130,40 +218,38 @@ pub async fn branch_for_rollup(
             break;
         }
         assert_eq!(current.parents.len(), 2);
-        current = get_commit(&client, &ctxt, repository_url, &current.parents[0].sha)
+        current = client
+            .get_commit(&current.parents[0].sha)
             .await
             .context("success master get")?;
     }
     let old_master_commit = current;
 
-    let current_master_commit = get_commit(&client, &ctxt, repository_url, "master")
+    let current_master_commit = client
+        .get_commit("master")
         .await
         .context("success master get")?;
 
-    let revert_sha = create_commit(
-        &client,
-        &ctxt,
-        "https://api.github.com/repos/rust-timer/rust",
-        &format!("Revert to {}", old_master_commit.sha),
-        &old_master_commit.commit.tree.sha,
-        &[&current_master_commit.sha],
-    )
-    .await
-    .context("create revert")?;
-
-    let merge_sha = create_commit(
-        &client,
-        &ctxt,
-        "https://api.github.com/repos/rust-timer/rust",
-        &format!(
-            "rust-timer simulated merge of {}\n\nOriginal message:\n{}",
-            rollup_merge.sha, rollup_merge.commit.message
-        ),
-        &rollup_merge.commit.tree.sha,
-        &[&revert_sha],
-    )
-    .await
-    .context("create merge commit")?;
+    let revert_sha = timer_client
+        .create_commit(
+            &format!("Revert to {}", old_master_commit.sha),
+            &old_master_commit.commit.tree.sha,
+            &[&current_master_commit.sha],
+        )
+        .await
+        .context("create revert")?;
+
+    let merge_sha = timer_client
+        .create_commit(
+            &format!(
+                "rust-timer simulated merge of {}\n\nOriginal message:\n{}",
+                rollup_merge.sha, rollup_merge.commit.message
+            ),
+            &rollup_merge.commit.tree.sha,
+            &[&revert_sha],
+        )
+        .await
+        .context("create merge commit")?;
 
     let rolled_up_pr_number = if let Some(stripped) = rollup_merge
         .commit
@@ -184,15 +270,10 @@ pub async fn branch_for_rollup(
     };
 
     let branch = format!("try-for-{}", rolled_up_pr_number);
-    create_ref(
-        &client,
-        &ctxt,
-        "https://api.github.com/repos/rust-timer/rust",
-        &format!("refs/heads/{}", branch),
-        &merge_sha,
-    )
-    .await
-    .context("created branch")?;
+    timer_client
+        .create_ref(&format!("refs/heads/{}", branch), &merge_sha)
+        .await
+        .context("created branch")?;
 
     Ok(RollupBranch {
         rolled_up_pr_number,
@@ -201,214 +282,10 @@ pub async fn branch_for_rollup(
     })
 }
 
-#[derive(serde::Serialize)]
-struct CreateRefRequest<'a> {
-    // Must start with `refs/` and have at least two slashes.
-    // e.g. `refs/heads/master`.
-    #[serde(rename = "ref")]
-    ref_: &'a str,
-    sha: &'a str,
-}
-
-pub async fn create_ref(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    ref_: &str,
-    sha: &str,
-) -> anyhow::Result<()> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/git/refs", repository_url);
-    let response = client
-        .post(&url)
-        .json(&CreateRefRequest { ref_, sha })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("POST git/refs failed")?;
-    if response.status() != reqwest::StatusCode::CREATED {
-        anyhow::bail!("{:?} != 201 CREATED", response.status());
-    }
-
-    Ok(())
-}
-
-#[derive(serde::Serialize)]
-struct CreatePrRequest<'a> {
-    title: &'a str,
-    // username:branch if cross-repo
-    head: &'a str,
-    // branch to pull into (e.g, master)
-    base: &'a str,
-    #[serde(rename = "body")]
-    description: &'a str,
-    draft: bool,
-}
-
-#[derive(Debug, serde::Deserialize)]
-pub struct CreatePrResponse {
-    pub number: u32,
-    pub html_url: String,
-    pub comments_url: String,
-}
-
-pub async fn create_pr(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    title: &str,
-    head: &str,
-    base: &str,
-    description: &str,
-    draft: bool,
-) -> anyhow::Result<CreatePrResponse> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/pulls", repository_url);
-    let response = client
-        .post(&url)
-        .json(&CreatePrRequest {
-            title,
-            head,
-            base,
-            description,
-            draft,
-        })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("POST pulls failed")?;
-    if response.status() != reqwest::StatusCode::CREATED {
-        anyhow::bail!("{:?} != 201 CREATED", response.status());
-    }
-
-    Ok(response.json().await.context("deserializing failed")?)
-}
-
-#[derive(serde::Serialize)]
-struct CreateCommitRequest<'a> {
-    message: &'a str,
-    tree: &'a str,
-    parents: &'a [&'a str],
-}
-
-#[derive(serde::Deserialize)]
-struct CreateCommitResponse {
-    sha: String,
-}
-
-pub async fn create_commit(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    message: &str,
-    tree: &str,
-    parents: &[&str],
-) -> anyhow::Result<String> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/git/commits", repository_url);
-    let commit_response = client
-        .post(&url)
-        .json(&CreateCommitRequest {
-            message,
-            tree,
-            parents,
-        })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("POST git/commits failed")?;
-    if commit_response.status() != reqwest::StatusCode::CREATED {
-        anyhow::bail!("{:?} != 201 CREATED", commit_response.status());
-    }
-
-    Ok(commit_response
-        .json::<CreateCommitResponse>()
-        .await
-        .context("deserializing failed")?
-        .sha)
-}
-
-pub async fn get_commit(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    sha: &str,
-) -> anyhow::Result<Commit> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/commits/{}", repository_url, sha);
-    let commit_response = client
-        .get(&url)
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("cannot get commit")?;
-    let commit_response = match commit_response.text().await {
-        Ok(c) => c,
-        Err(err) => {
-            anyhow::bail!("Failed to decode response for {}: {:?}", url, err);
-        }
-    };
-    match serde_json::from_str(&commit_response) {
-        Ok(c) => Ok(c),
-        Err(e) => Err(anyhow::anyhow!(
-            "cannot deserialize commit ({}): {:?}",
-            commit_response,
-            e
-        )),
-    }
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct Commit {
-    pub sha: String,
-    pub commit: InnerCommit,
-    pub parents: Vec<CommitParent>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct InnerCommit {
-    #[serde(default)]
-    pub message: String,
-    pub tree: CommitTree,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct CommitTree {
-    pub sha: String,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct CommitParent {
-    pub sha: String,
-}
-
 pub async fn enqueue_sha(issue: Issue, ctxt: &SiteCtxt, commit: String) -> Result<(), String> {
-    let client = reqwest::Client::new();
-    let commit_response = get_commit(&client, ctxt, &issue.repository_url, &commit)
+    let client = client::Client::from_ctxt(ctxt, issue.repository_url.clone());
+    let commit_response = client
+        .get_commit(&commit)
         .await
         .map_err(|e| e.to_string())?;
     if commit_response.parents.len() != 2 {
@@ -440,7 +317,7 @@ pub async fn enqueue_sha(issue: Issue, ctxt: &SiteCtxt, commit: String) -> Resul
             commit_response.parents[0].sha,
             try_commit.comparison_url(),
         );
-        post_comment(&ctxt.config, issue.number, msg).await;
+        client.post_comment(issue.number, msg).await;
     }
     Ok(())
 }
@@ -477,38 +354,6 @@ pub async fn parse_homu_comment(comment_body: &str) -> Option<String> {
     Some(sha)
 }
 
-pub async fn post_comment<B>(cfg: &Config, pr: u32, body: B)
-where
-    B: Into<String>,
-{
-    let body = body.into();
-    let timer_token = cfg
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let client = reqwest::Client::new();
-    let req = client
-        .post(&format!(
-            "https://api.github.com/repos/rust-lang/rust/issues/{}/comments",
-            pr
-        ))
-        .json(&PostComment {
-            body: body.to_owned(),
-        })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token));
-
-    if let Err(e) = req.send().await {
-        eprintln!("failed to post comment: {:?}", e);
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct PostComment {
-    pub body: String,
-}
-
 /// Post messages to GitHub for all queued commits that have
 /// not yet been marked as completed.
 pub async fn post_finished(ctxt: &SiteCtxt) {
@@ -566,13 +411,14 @@ pub async fn post_finished(ctxt: &SiteCtxt) {
 ///
 /// `is_master_commit` is used to differentiate messages for try runs and post-merge runs.
 async fn post_comparison_comment(ctxt: &SiteCtxt, commit: QueuedCommit, is_master_commit: bool) {
+    let client = client::Client::from_ctxt(ctxt, "https://github.com/rust-lang/rust".to_owned());
     let pr = commit.pr;
     let body = match summarize_run(ctxt, commit, is_master_commit).await {
         Ok(message) => message,
         Err(error) => error,
     };
 
-    post_comment(&ctxt.config, pr, body).await;
+    client.post_comment(pr, body).await;
 }
 
 fn make_comparison_url(commit: &QueuedCommit, stat: Metric) -> String {
diff --git a/site/src/github/client.rs b/site/src/github/client.rs
new file mode 100644
index 000000000..dd9fd68b8
--- /dev/null
+++ b/site/src/github/client.rs
@@ -0,0 +1,263 @@
+use anyhow::Context;
+use http::header::USER_AGENT;
+
+use crate::{api::github::Issue, load::SiteCtxt};
+
+/// A client for interacting with the GitHub API
+pub struct Client {
+    repository_url: String,
+    token: String,
+    inner: reqwest::Client,
+}
+
+impl Client {
+    /// Create a new client from a URL and token (useful for testing)
+    pub fn new(repository_url: String, token: String) -> Self {
+        Self {
+            repository_url,
+            token,
+            inner: reqwest::Client::new(),
+        }
+    }
+
+    /// Create a client from a `SiteCtxt` and a URL
+    pub fn from_ctxt(ctxt: &SiteCtxt, repository_url: String) -> Self {
+        let token = ctxt
+            .config
+            .keys
+            .github_api_token
+            .clone()
+            .expect("needs github API token");
+        Self::new(repository_url, token)
+    }
+
+    pub async fn create_ref(&self, ref_: &str, sha: &str) -> anyhow::Result<()> {
+        #[derive(serde::Serialize)]
+        struct CreateRefRequest<'a> {
+            // Must start with `refs/` and have at least two slashes.
+            // e.g. `refs/heads/master`.
+            #[serde(rename = "ref")]
+            ref_: &'a str,
+            sha: &'a str,
+        }
+        let url = format!("{}/git/refs", self.repository_url);
+        let req = self.inner.post(&url).json(&CreateRefRequest { ref_, sha });
+        let response = self.send(req).await.context("POST git/refs failed")?;
+        if response.status() != reqwest::StatusCode::CREATED {
+            anyhow::bail!("{:?} != 201 CREATED", response.status());
+        }
+
+        Ok(())
+    }
+
+    pub async fn create_pr(
+        &self,
+        title: &str,
+        head: &str,
+        base: &str,
+        description: &str,
+        draft: bool,
+    ) -> anyhow::Result<CreatePrResponse> {
+        #[derive(serde::Serialize)]
+        struct CreatePrRequest<'a> {
+            title: &'a str,
+            // username:branch if cross-repo
+            head: &'a str,
+            // branch to pull into (e.g, master)
+            base: &'a str,
+            #[serde(rename = "body")]
+            description: &'a str,
+            draft: bool,
+        }
+
+        let url = format!("{}/pulls", self.repository_url);
+        let req = self.inner.post(&url).json(&CreatePrRequest {
+            title,
+            head,
+            base,
+            description,
+            draft,
+        });
+        let response = self.send(req).await.context("POST pulls failed")?;
+        if response.status() != reqwest::StatusCode::CREATED {
+            anyhow::bail!("{:?} != 201 CREATED", response.status());
+        }
+
+        Ok(response.json().await.context("deserializing failed")?)
+    }
+
+    pub async fn update_branch(&self, branch: &str, sha: &str) -> anyhow::Result<()> {
+        #[derive(serde::Serialize)]
+        struct UpdateBranchRequest<'a> {
+            sha: &'a str,
+            force: bool,
+        }
+        let url = format!("{}/git/refs/heads/{}", self.repository_url, branch);
+        let req = self
+            .inner
+            .patch(&url)
+            .json(&UpdateBranchRequest { sha, force: true });
+
+        let response = self.send(req).await.context("PATCH git/refs failed")?;
+        if response.status() != reqwest::StatusCode::OK {
+            anyhow::bail!("{:?} != 200 OK", response.status());
+        }
+
+        Ok(())
+    }
+
+    pub async fn merge_branch(
+        &self,
+        branch: &str,
+        sha: &str,
+        commit_message: &str,
+    ) -> anyhow::Result<String> {
+        #[derive(serde::Serialize)]
+        struct MergeBranchRequest<'a> {
+            base: &'a str,
+            head: &'a str,
+            commit_message: &'a str,
+        }
+        let url = format!("{}/merges", self.repository_url);
+        let req = self.inner.post(&url).json(&MergeBranchRequest {
+            base: branch,
+            head: sha,
+            commit_message,
+        });
+        let response = self.send(req).await.context("PATCH /merges failed")?;
+        if !response.status().is_success() {
+            anyhow::bail!("{:?} != 201 CREATED", response.status());
+        }
+
+        Ok(response.json::<MergeBranchResponse>().await?.sha)
+    }
+
+    pub async fn create_commit(
+        &self,
+        message: &str,
+        tree: &str,
+        parents: &[&str],
+    ) -> anyhow::Result<String> {
+        #[derive(serde::Serialize)]
+        struct CreateCommitRequest<'a> {
+            message: &'a str,
+            tree: &'a str,
+            parents: &'a [&'a str],
+        }
+        let url = format!("{}/git/commits", self.repository_url);
+        let req = self.inner.post(&url).json(&CreateCommitRequest {
+            message,
+            tree,
+            parents,
+        });
+
+        let response = self.send(req).await.context("POST git/commits failed")?;
+        if response.status() != reqwest::StatusCode::CREATED {
+            anyhow::bail!("{:?} != 201 CREATED", response.status());
+        }
+
+        Ok(response
+            .json::<CreateCommitResponse>()
+            .await
+            .context("deserializing failed")?
+            .sha)
+    }
+
+    pub async fn get_issue(&self, number: u64) -> anyhow::Result<Issue> {
+        let url = format!("{}/issues/{}", self.repository_url, number);
+        let req = self.inner.get(&url);
+        let response = self.send(req).await.context("cannot get issue")?;
+        if !response.status().is_success() {
+            anyhow::bail!("{:?} != 200 OK", response.status());
+        }
+
+        Ok(response.json().await?)
+    }
+
+    pub async fn get_commit(&self, sha: &str) -> anyhow::Result<Commit> {
+        let url = format!("{}/commits/{}", self.repository_url, sha);
+        let req = self.inner.get(&url);
+        let response = self.send(req).await.context("cannot get commit")?;
+        if !response.status().is_success() {
+            anyhow::bail!("{:?} != 200 OK", response.status());
+        }
+        response
+            .json()
+            .await
+            .map_err(|e| anyhow::anyhow!("cannot deserialize commit: {:?}", e))
+    }
+
+    pub async fn post_comment<B>(&self, pr: u32, body: B)
+    where
+        B: Into<String>,
+    {
+        #[derive(Debug, Clone, serde::Serialize)]
+        pub struct PostComment {
+            pub body: String,
+        }
+        let body = body.into();
+        let req = self
+            .inner
+            .post(&format!("{}/issues/{}/comments", self.repository_url, pr))
+            .json(&PostComment {
+                body: body.to_owned(),
+            });
+        let resp = self.send(req).await;
+
+        if let Err(e) = resp {
+            eprintln!("failed to post comment: {:?}", e);
+        }
+    }
+
+    async fn send(
+        &self,
+        request: reqwest::RequestBuilder,
+    ) -> Result<reqwest::Response, reqwest::Error> {
+        request
+            .header(USER_AGENT, "perf-rust-lang-org-server")
+            .basic_auth("rust-timer", Some(&self.token))
+            .send()
+            .await
+    }
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct CreatePrResponse {
+    pub number: u32,
+    pub html_url: String,
+    pub comments_url: String,
+}
+
+#[derive(serde::Deserialize)]
+struct MergeBranchResponse {
+    sha: String,
+}
+
+#[derive(serde::Deserialize)]
+struct CreateCommitResponse {
+    sha: String,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct Commit {
+    pub sha: String,
+    pub commit: InnerCommit,
+    pub parents: Vec<CommitParent>,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct InnerCommit {
+    #[serde(default)]
+    pub message: String,
+    pub tree: CommitTree,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct CommitTree {
+    pub sha: String,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct CommitParent {
+    pub sha: String,
+}
diff --git a/site/src/request_handlers/github.rs b/site/src/request_handlers/github.rs
index a0c5a4983..3ae8cf1c7 100644
--- a/site/src/request_handlers/github.rs
+++ b/site/src/request_handlers/github.rs
@@ -1,7 +1,7 @@
 use crate::api::{github, ServerResult};
 use crate::github::{
-    branch_for_rollup, enqueue_sha, get_authorized_users, parse_homu_comment, post_comment,
-    pr_and_try_for_rollup,
+    branch_for_rollup, client, enqueue_sha, enqueue_unrolled_try_builds, get_authorized_users,
+    parse_homu_comment, pr_and_try_for_rollup, rollup_pr,
 };
 use crate::load::SiteCtxt;
 
@@ -10,6 +10,10 @@ use std::sync::Arc;
 use regex::{Captures, Regex};
 
 lazy_static::lazy_static! {
+    static ref ROLLUP_PR_NUMBER: Regex =
+        Regex::new(r#"^Auto merge of #(\d+)"#).unwrap();
+    static ref ROLLUPED_PR_NUMBER: Regex =
+        Regex::new(r#"^Rollup merge of #(\d+)"#).unwrap();
     static ref BODY_TRY_COMMIT: Regex =
         Regex::new(r#"(?:\W|^)@rust-timer\s+build\s+(\w+)(?:\W|$)(?:include=(\S+))?\s*(?:exclude=(\S+))?\s*(?:runs=(\d+))?"#).unwrap();
     static ref BODY_QUEUE: Regex =
@@ -25,52 +29,126 @@ pub async fn handle_github(
     ctxt: Arc<SiteCtxt>,
 ) -> ServerResult<github::Response> {
     log::info!("handle_github({:?})", request);
-    if request.comment.body.contains(" homu: ") {
-        if let Some(sha) = parse_homu_comment(&request.comment.body).await {
-            enqueue_sha(request.issue, &ctxt, sha).await?;
+    match request {
+        github::Request::Issue { issue, comment } => handle_issue(ctxt, issue, comment).await,
+        github::Request::Push(p) => handle_push(ctxt, p).await,
+    }
+}
+
+async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<github::Response> {
+    let ci_client = client::Client::from_ctxt(
+        &ctxt,
+        "https://api.github.com/repos/rust-lang-ci/rust".to_owned(),
+    );
+    let main_repo_client = client::Client::from_ctxt(
+        &ctxt,
+        "https://api.github.com/repos/rust-lang/rust".to_owned(),
+    );
+    if push.r#ref != "refs/heads/master" || push.sender.login != "bors" {
+        return Ok(github::Response);
+    }
+    let rollup_pr = rollup_pr(&main_repo_client, &push.head_commit.message).await?;
+    let rollup_pr = match rollup_pr {
+        Some(pr) => pr,
+        None => return Ok(github::Response),
+    };
+
+    let previous_master = &push.before;
+    let rollup_merges = push
+        .commits
+        .iter()
+        .rev()
+        .skip(1) // skip the head commit
+        .take_while(|c| c.message.starts_with("Rollup merge of "));
+
+    let mapping = enqueue_unrolled_try_builds(ci_client, rollup_merges, previous_master).await?;
+
+    let mapping = mapping
+        .into_iter()
+        .map(|(rollup_merge, sha)| {
+            ROLLUPED_PR_NUMBER
+                .captures(&rollup_merge.message)
+                .and_then(|c| c.get(1))
+                .map(|m| (m.as_str(), sha))
+                .ok_or_else(|| {
+                    format!(
+                        "Could not get PR number from message: '{}'",
+                        rollup_merge.message
+                    )
+                })
+        })
+        .fold(ServerResult::Ok(String::new()), |string, n| {
+            use std::fmt::Write;
+            let (pr, commit) = n?;
+            let mut string = string?;
+            write!(&mut string, "#{pr}: {commit}\n").unwrap();
+            Ok(string)
+        })?;
+    let msg =
+        format!("Try perf builds for each individual rolled up PR have been enqueued:\n{mapping}");
+    main_repo_client.post_comment(rollup_pr, msg).await;
+    Ok(github::Response)
+}
+
+async fn handle_issue(
+    ctxt: Arc<SiteCtxt>,
+    issue: github::Issue,
+    comment: github::Comment,
+) -> ServerResult<github::Response> {
+    if comment.body.contains(" homu: ") {
+        if let Some(sha) = parse_homu_comment(&comment.body).await {
+            enqueue_sha(issue, &ctxt, sha).await?;
             return Ok(github::Response);
         }
     }
 
-    if !request.comment.body.contains("@rust-timer ") {
-        return Ok(github::Response);
+    if comment.body.contains("@rust-timer ") {
+        return handle_rust_timer(ctxt, comment, issue).await;
     }
 
-    if request.comment.author_association != github::Association::Owner
-        && !get_authorized_users()
-            .await?
-            .contains(&request.comment.user.id)
+    Ok(github::Response)
+}
+
+async fn handle_rust_timer(
+    ctxt: Arc<SiteCtxt>,
+    comment: github::Comment,
+    issue: github::Issue,
+) -> ServerResult<github::Response> {
+    let main_repo_client = client::Client::from_ctxt(
+        &ctxt,
+        "https://api.github.com/repos/rust-lang/rust".to_owned(),
+    );
+    if comment.author_association != github::Association::Owner
+        && !get_authorized_users().await?.contains(&comment.user.id)
     {
-        post_comment(
-            &ctxt.config,
-            request.issue.number,
-            "Insufficient permissions to issue commands to rust-timer.",
-        )
-        .await;
+        main_repo_client
+            .post_comment(
+                issue.number,
+                "Insufficient permissions to issue commands to rust-timer.",
+            )
+            .await;
         return Ok(github::Response);
     }
 
-    if let Some(captures) = BODY_QUEUE.captures(&request.comment.body) {
+    if let Some(captures) = BODY_QUEUE.captures(&comment.body) {
         let include = captures.get(1).map(|v| v.as_str());
         let exclude = captures.get(2).map(|v| v.as_str());
         let runs = captures.get(3).and_then(|v| v.as_str().parse::<i32>().ok());
         {
             let conn = ctxt.conn().await;
-            conn.queue_pr(request.issue.number, include, exclude, runs)
-                .await;
+            conn.queue_pr(issue.number, include, exclude, runs).await;
         }
-        post_comment(
-            &ctxt.config,
-            request.issue.number,
-            "Awaiting bors try build completion.
+        main_repo_client
+            .post_comment(
+                issue.number,
+                "Awaiting bors try build completion.
 
 @rustbot label: +S-waiting-on-perf",
-        )
-        .await;
+            )
+            .await;
         return Ok(github::Response);
     }
-
-    if let Some(captures) = BODY_TRY_COMMIT.captures(&request.comment.body) {
+    if let Some(captures) = BODY_TRY_COMMIT.captures(&comment.body) {
         if let Some(commit) = captures.get(1).map(|c| c.as_str().to_owned()) {
             let include = captures.get(2).map(|v| v.as_str());
             let exclude = captures.get(3).map(|v| v.as_str());
@@ -78,43 +156,36 @@ pub async fn handle_github(
             let commit = commit.trim_start_matches("https://github.com/rust-lang/rust/commit/");
             {
                 let conn = ctxt.conn().await;
-                conn.queue_pr(request.issue.number, include, exclude, runs)
-                    .await;
+                conn.queue_pr(issue.number, include, exclude, runs).await;
             }
-            enqueue_sha(request.issue, &ctxt, commit.to_owned()).await?;
+            enqueue_sha(issue, &ctxt, commit.to_owned()).await?;
             return Ok(github::Response);
         }
     }
-
-    for rollup_merge in extract_make_pr_for(&request.comment.body) {
-        let client = reqwest::Client::new();
+    for rollup_merge in extract_make_pr_for(&comment.body) {
         pr_and_try_for_rollup(
-            &client,
             ctxt.clone(),
-            &request.issue.repository_url,
+            &issue.repository_url,
             &rollup_merge,
-            &request.comment.html_url,
+            &comment.html_url,
         )
         .await
         .map_err(|e| format!("{:?}", e))?;
     }
-
-    for rollup_merge in extract_update_pr_for(&request.comment.body) {
+    for rollup_merge in extract_update_pr_for(&comment.body) {
         // This just creates or updates the branch for this merge commit.
         // Intended for resolving the race condition of master merging in
         // between us updating the commit and merging things.
-        let client = reqwest::Client::new();
-        let branch = branch_for_rollup(&client, &ctxt, &request.issue.repository_url, rollup_merge)
+        let branch = branch_for_rollup(&ctxt, &issue.repository_url, rollup_merge)
             .await
             .map_err(|e| e.to_string())?;
-        post_comment(
-            &ctxt.config,
-            request.issue.number,
-            &format!("Master base SHA: {}", branch.master_base_sha),
-        )
-        .await;
+        main_repo_client
+            .post_comment(
+                issue.number,
+                &format!("Master base SHA: {}", branch.master_base_sha),
+            )
+            .await;
     }
-
     Ok(github::Response)
 }
 
@@ -132,7 +203,6 @@ fn extract_update_pr_for(body: &str) -> impl Iterator<Item = &str> + '_ {
 
 fn extract_rollup_merge(capture: Captures) -> Option<&str> {
     capture.get(1).map(|c| {
-        println!("{}", c.as_str());
         c.as_str()
             .trim_start_matches("https://github.com/rust-lang/rust/commit/")
     })
diff --git a/site/src/server.rs b/site/src/server.rs
index bd146c28e..fdee7e23f 100644
--- a/site/src/server.rs
+++ b/site/src/server.rs
@@ -464,7 +464,7 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
                 }
             };
             match event.as_str() {
-                "issue_comment" => Ok(to_response(
+                "issue_comment" | "pushes" => Ok(to_response(
                     request_handlers::handle_github(check!(parse_body(&body)), ctxt.clone()).await,
                     &compression,
                 )),