diff --git a/kubernetes/processbot/templates/processbot.yaml b/kubernetes/processbot/templates/processbot.yaml
index 3643d927..68c3f365 100644
--- a/kubernetes/processbot/templates/processbot.yaml
+++ b/kubernetes/processbot/templates/processbot.yaml
@@ -78,7 +78,7 @@ spec:
             - name: RUST_BACKTRACE
               value: full
             - name: RUST_LOG
-              value: debug
+              value: info
             - name: INSTALLATION_LOGIN
               value: {{ .Values.orgName }}
             - name: PRIVATE_KEY_PATH
diff --git a/src/auth.rs b/src/auth.rs
index 4c16f573..cda35b38 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -34,11 +34,11 @@ impl GithubUserAuthenticator {
 				Error::OrganizationMembership {
 					source: Box::new(e),
 				}
-				.map_issue(Some((
+				.map_issue((
 					self.org.clone(),
 					self.repo_name.clone(),
 					self.pr_number,
-				)))
+				))
 			})?;
 
 		if !is_member {
@@ -50,11 +50,11 @@ impl GithubUserAuthenticator {
 					),
 				}),
 			}
-			.map_issue(Some((
+			.map_issue((
 				self.org.clone(),
 				self.repo_name.clone(),
 				self.pr_number,
-			))))?;
+			)))?;
 		}
 		Ok(())
 	}
diff --git a/src/companion.rs b/src/companion.rs
index 16748b70..4db36401 100644
--- a/src/companion.rs
+++ b/src/companion.rs
@@ -2,7 +2,11 @@ use regex::Regex;
 use snafu::ResultExt;
 use std::path::Path;
 
-use crate::{cmd::*, error::*, github_bot::GithubBot, Result};
+use crate::{
+	cmd::*, error::*, github_bot::GithubBot, Result, COMPANION_LONG_REGEX,
+	COMPANION_PREFIX_REGEX, COMPANION_SHORT_REGEX,
+	COMPANION_SHORT_SUFFIX_REGEX, PR_HTML_URL_REGEX,
+};
 
 pub async fn companion_update(
 	github_bot: &GithubBot,
@@ -236,10 +240,7 @@ pub fn companion_parse(body: &str) -> Option<(String, String, String, i64)> {
 }
 
 fn companion_parse_long(body: &str) -> Option<(String, String, String, i64)> {
-	let re = Regex::new(
-		r"companion[^[[:alpha:]]\n]*(?P<html_url>https://github.com/(?P<owner>[^/\n]+)/(?P<repo>[^/\n]+)/pull/(?P<number>[[:digit:]]+))"
-	)
-	.unwrap();
+	let re = Regex::new(COMPANION_LONG_REGEX!()).unwrap();
 	let caps = re.captures(&body)?;
 	let html_url = caps.name("html_url")?.as_str().to_owned();
 	let owner = caps.name("owner")?.as_str().to_owned();
@@ -254,10 +255,7 @@ fn companion_parse_long(body: &str) -> Option<(String, String, String, i64)> {
 }
 
 fn companion_parse_short(body: &str) -> Option<(String, String, String, i64)> {
-	let re = Regex::new(
-		r"companion[^[[:alpha:]]\n]*(?P<owner>[^/\n]+)/(?P<repo>[^/\n]+)#(?P<number>[[:digit:]]+)",
-	)
-	.unwrap();
+	let re = Regex::new(COMPANION_SHORT_REGEX!()).unwrap();
 	let caps = re.captures(&body)?;
 	let owner = caps.name("owner")?.as_str().to_owned();
 	let repo = caps.name("repo")?.as_str().to_owned();
diff --git a/src/error.rs b/src/error.rs
index 7911327b..b420aee3 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,6 +1,6 @@
 use snafu::Snafu;
 
-type IssueDetails = Option<(String, String, i64)>;
+type IssueDetails = (String, String, i64);
 
 #[derive(Debug, Snafu)]
 #[snafu(visibility = "pub")]
@@ -11,6 +11,11 @@ pub enum Error {
 		issue: IssueDetails,
 	},
 
+	#[snafu(display("Field is missing: {}", field))]
+	MissingField {
+		field: String,
+	},
+
 	#[snafu(display("Error updating companion: {}", source))]
 	Companion {
 		source: Box<Error>,
@@ -180,9 +185,12 @@ pub enum Error {
 
 impl Error {
 	pub fn map_issue(self, issue: IssueDetails) -> Self {
-		Self::WithIssue {
-			source: Box::new(self),
-			issue: issue,
+		match self {
+			Self::WithIssue { source, .. } => Self::WithIssue { source, issue },
+			_ => Self::WithIssue {
+				source: Box::new(self),
+				issue,
+			},
 		}
 	}
 }
diff --git a/src/github.rs b/src/github.rs
index c6f2e294..81d4deea 100644
--- a/src/github.rs
+++ b/src/github.rs
@@ -1,19 +1,7 @@
+use crate::{error::*, Result, PR_HTML_URL_REGEX};
+use regex::Regex;
 use serde::{Deserialize, Serialize};
-
-pub trait GithubIssue {
-	fn number(&self) -> i64;
-	fn id(&self) -> i64;
-	fn html_url(&self) -> &String;
-	fn user(&self) -> &User;
-	fn body(&self) -> Option<&String>;
-	fn title(&self) -> Option<&String>;
-	fn repository(&self) -> Option<&Repository>;
-	fn assignee(&self) -> Option<&User>;
-	fn is_assignee(&self, login: &str) -> bool {
-		self.assignee()
-			.map_or(false, |assignee| assignee.login == login)
-	}
-}
+use snafu::OptionExt;
 
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct PullRequest {
@@ -33,7 +21,7 @@ pub struct PullRequest {
 	pub state: Option<String>,
 	pub locked: Option<bool>,
 	pub title: Option<String>,
-	pub user: User,
+	pub user: Option<User>,
 	pub body: Option<String>,
 	pub labels: Vec<Label>,
 	pub milestone: Option<Milestone>,
@@ -49,7 +37,8 @@ pub struct PullRequest {
 	pub assignees: Option<Vec<User>>,
 	pub requested_reviewers: Option<Vec<User>>,
 	pub requested_teams: Option<Vec<RequestedTeam>>,
-	pub head: Head,
+	// Head might be missing when e.g. the branch has been deleted
+	pub head: Option<Head>,
 	pub base: Base,
 	#[serde(rename = "_links")]
 	pub links: Option<Links>,
@@ -59,37 +48,18 @@ pub struct PullRequest {
 	pub repository: Option<Repository>,
 }
 
-impl GithubIssue for PullRequest {
-	fn number(&self) -> i64 {
-		self.number
-	}
-
-	fn id(&self) -> i64 {
-		self.id
-	}
-
-	fn html_url(&self) -> &String {
-		&self.html_url
-	}
-
-	fn user(&self) -> &User {
-		&self.user
-	}
-
-	fn body(&self) -> Option<&String> {
-		self.body.as_ref()
-	}
-
-	fn title(&self) -> Option<&String> {
-		self.title.as_ref()
-	}
-
-	fn repository(&self) -> Option<&Repository> {
-		self.repository.as_ref()
-	}
-
-	fn assignee(&self) -> Option<&User> {
-		self.assignee.as_ref()
+impl PullRequest {
+	pub fn head_sha(&self) -> Result<&String> {
+		self.head
+			.as_ref()
+			.context(MissingField {
+				field: "pull_request.head",
+			})?
+			.sha
+			.as_ref()
+			.context(MissingField {
+				field: "pull_request.head.sha",
+			})
 	}
 }
 
@@ -99,7 +69,8 @@ pub struct Issue {
 	pub id: i64,
 	pub node_id: Option<String>,
 	pub html_url: String,
-	pub user: User,
+	// User might be missing when it has been deleted
+	pub user: Option<User>,
 	pub body: Option<String>,
 	pub title: Option<String>,
 	pub state: Option<String>,
@@ -117,40 +88,6 @@ pub struct Issue {
 	pub repository_url: Option<String>,
 }
 
-impl GithubIssue for Issue {
-	fn number(&self) -> i64 {
-		self.number
-	}
-
-	fn id(&self) -> i64 {
-		self.id
-	}
-
-	fn html_url(&self) -> &String {
-		&self.html_url
-	}
-
-	fn user(&self) -> &User {
-		&self.user
-	}
-
-	fn body(&self) -> Option<&String> {
-		self.body.as_ref()
-	}
-
-	fn title(&self) -> Option<&String> {
-		self.title.as_ref()
-	}
-
-	fn repository(&self) -> Option<&Repository> {
-		self.repository.as_ref()
-	}
-
-	fn assignee(&self) -> Option<&User> {
-		self.assignee.as_ref()
-	}
-}
-
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Organization {
 	pub login: String,
@@ -232,7 +169,8 @@ pub struct IssueEvent {
 pub struct Comment {
 	pub id: i64,
 	pub body: String,
-	pub user: User,
+	// User might be missing when it has been deleted
+	pub user: Option<User>,
 	pub node_id: Option<String>,
 	pub url: Option<String>,
 	pub html_url: Option<String>,
@@ -325,17 +263,19 @@ pub struct IssuePullRequest {
 pub struct Head {
 	pub label: Option<String>,
 	#[serde(rename = "ref")]
-	pub ref_field: String,
-	pub sha: String,
-	pub repo: HeadRepo,
+	pub ref_field: Option<String>,
+	pub sha: Option<String>,
+	// Repository might be missing when it has been deleted
+	pub repo: Option<HeadRepo>,
 }
 
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Base {
 	#[serde(rename = "ref")]
-	pub ref_field: String,
-	pub sha: String,
-	pub repo: HeadRepo,
+	pub ref_field: Option<String>,
+	pub sha: Option<String>,
+	// Repository might be missing when it has been deleted
+	pub repo: Option<HeadRepo>,
 }
 
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -359,27 +299,18 @@ pub struct RequestedReviewers {
 	pub teams: Vec<Team>,
 }
 
+#[derive(PartialEq, Debug, Clone, Serialize, Deserialize)]
+pub enum UserType {
+	User,
+	#[serde(other)]
+	Unknown,
+}
+
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct User {
 	pub login: String,
-	pub id: Option<i64>,
-	pub node_id: Option<String>,
-	pub avatar_url: String,
-	pub gravatar_id: String,
-	pub url: Option<String>,
-	pub html_url: Option<String>,
-	pub followers_url: String,
-	pub following_url: String,
-	pub gists_url: String,
-	pub starred_url: String,
-	pub subscriptions_url: String,
-	pub organizations_url: String,
-	pub repos_url: String,
-	pub events_url: String,
-	pub received_events_url: String,
 	#[serde(rename = "type")]
-	pub type_field: String,
-	pub site_admin: bool,
+	pub type_field: Option<UserType>,
 }
 
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -435,7 +366,7 @@ pub struct Repository {
 	pub node_id: Option<String>,
 	pub name: String,
 	pub full_name: Option<String>,
-	pub owner: User,
+	pub owner: Option<User>,
 	pub private: Option<bool>,
 	pub html_url: String,
 	pub description: Option<String>,
@@ -700,8 +631,8 @@ pub struct Diff {
 #[serde(rename_all = "snake_case")]
 pub enum IssueCommentAction {
 	Created,
-	Edited,
-	Deleted,
+	#[serde(other)]
+	Unknown,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -754,6 +685,7 @@ pub struct HeadRepo {
 	pub id: i64,
 	pub url: String,
 	pub name: String,
+	// The owner might be missing when e.g. they have deleted their account
 	pub owner: Option<User>,
 }
 
@@ -779,34 +711,9 @@ pub struct Branch {
 	pub protected: bool,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(untagged, rename_all = "snake_case")]
-pub enum PullRequestAction {
-	Opened,
-	Edited,
-	Closed,
-	Assigned,
-	Unassigned,
-	ReviewRequested,
-	ReviewRequestRemoved,
-	ReadyForReview,
-	Labeled,
-	Unlabeled,
-	Synchronized,
-	Locked,
-	Unlocked,
-	Reopened,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(PartialEq, Deserialize)]
 #[serde(untagged, rename_all = "snake_case")]
 pub enum Payload {
-	PullRequest {
-		action: PullRequestAction,
-		number: i64,
-		pull_request: PullRequest,
-		repository: Repository,
-	},
 	IssueComment {
 		action: IssueCommentAction,
 		issue: Issue,
@@ -825,3 +732,116 @@ pub enum Payload {
 		check_run: CheckRun,
 	},
 }
+
+#[derive(Deserialize)]
+struct DetectUserCommentPullRequestPullRequest {
+	pub html_url: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct DetectUserCommentPullRequestRepository {
+	pub name: Option<String>,
+	pub full_name: Option<String>,
+	pub owner: Option<User>,
+}
+
+#[derive(Deserialize)]
+struct DetectUserCommentPullRequestIssue {
+	pub pull_request: Option<DetectUserCommentPullRequestPullRequest>,
+	pub number: i64,
+}
+
+#[derive(Deserialize)]
+struct DetectUserCommentPullRequestComment {
+	pub body: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub struct DetectUserCommentPullRequest {
+	action: IssueCommentAction,
+	issue: Option<DetectUserCommentPullRequestIssue>,
+	repository: Option<DetectUserCommentPullRequestRepository>,
+	sender: Option<User>,
+	comment: Option<DetectUserCommentPullRequestComment>,
+}
+
+impl DetectUserCommentPullRequest {
+	pub fn get_details(&self) -> Option<(String, String, i64)> {
+		if let DetectUserCommentPullRequest {
+			action: IssueCommentAction::Created,
+			issue:
+				Some(DetectUserCommentPullRequestIssue {
+					number,
+					pull_request: Some(pr),
+				}),
+			comment:
+				Some(DetectUserCommentPullRequestComment { body: Some(body) }),
+			repository,
+			sender:
+				Some(User {
+					type_field: Some(UserType::User),
+					..
+				}),
+		} = self
+		{
+			if body.trim().starts_with("bot ") {
+				if let Some(DetectUserCommentPullRequestRepository {
+					name: Some(name),
+					owner: Some(User { login, .. }),
+					..
+				}) = repository
+				{
+					Some((login.to_owned(), name.to_owned(), *number))
+				} else if let Some(DetectUserCommentPullRequestRepository {
+					full_name: Some(full_name),
+					..
+				}) = repository
+				{
+					parse_repository_full_name(full_name)
+						.map(|(owner, name)| (owner, name, *number))
+				} else if let DetectUserCommentPullRequestPullRequest {
+					html_url: Some(html_url),
+				} = pr
+				{
+					parse_issue_details_from_pr_html_url(html_url)
+						.map(|(owner, name, _)| (owner, name, *number))
+				} else {
+					None
+				}
+			} else {
+				None
+			}
+		} else {
+			None
+		}
+	}
+}
+
+pub fn parse_issue_details_from_pr_html_url(
+	pr_html_url: &str,
+) -> Option<(String, String, i64)> {
+	let re = Regex::new(PR_HTML_URL_REGEX!()).unwrap();
+	let matches = re.captures(&pr_html_url)?;
+	let owner = matches.name("owner")?.as_str().to_owned();
+	let repo = matches.name("repo")?.as_str().to_owned();
+	let number = matches
+		.name("number")?
+		.as_str()
+		.to_owned()
+		.parse::<i64>()
+		.ok()?;
+	Some((owner, repo, number))
+}
+
+pub fn parse_repository_full_name(full_name: &str) -> Option<(String, String)> {
+	let parts: Vec<&str> = full_name.split("/").collect();
+	parts
+		.get(0)
+		.map(|owner| {
+			parts.get(1).map(|repo_name| {
+				Some((owner.to_string(), repo_name.to_string()))
+			})
+		})
+		.flatten()
+		.flatten()
+}
diff --git a/src/lib.rs b/src/lib.rs
index c15a4b22..c15e1ab2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,10 +1,13 @@
 mod auth;
 pub mod bamboo;
 pub mod cmd;
+mod macros;
+#[macro_use]
 pub mod companion;
 pub mod config;
 pub mod constants;
 pub mod error;
+#[macro_use]
 pub mod github;
 pub mod github_bot;
 pub mod gitlab_bot;
diff --git a/src/macros.rs b/src/macros.rs
new file mode 100644
index 00000000..e87d00f0
--- /dev/null
+++ b/src/macros.rs
@@ -0,0 +1,33 @@
+#[macro_export]
+macro_rules! PR_HTML_URL_REGEX {
+    () => {
+        r"(?P<html_url>https://github.com/(?P<owner>[^/\n]+)/(?P<repo>[^/\n]+)/pull/(?P<number>[[:digit:]]+))"
+    };
+}
+
+#[macro_export]
+macro_rules! COMPANION_PREFIX_REGEX {
+	() => {
+		r"companion[^[[:alpha:]]\n]*"
+	};
+}
+
+#[macro_export]
+macro_rules! COMPANION_LONG_REGEX {
+	() => {
+		concat!(COMPANION_PREFIX_REGEX!(), PR_HTML_URL_REGEX!())
+	};
+}
+
+#[macro_export]
+macro_rules! COMPANION_SHORT_SUFFIX_REGEX {
+	() => {
+		r"(?P<owner>[^/\n]+)/(?P<repo>[^/\n]+)#(?P<number>[[:digit:]]+)"
+	};
+}
+#[macro_export]
+macro_rules! COMPANION_SHORT_REGEX {
+	() => {
+		concat!(COMPANION_PREFIX_REGEX!(), COMPANION_SHORT_SUFFIX_REGEX!())
+	};
+}
diff --git a/src/webhook.rs b/src/webhook.rs
index d73fddff..53358dbb 100644
--- a/src/webhook.rs
+++ b/src/webhook.rs
@@ -129,16 +129,46 @@ pub async fn webhook_inner(
 		msg: format!("Validation signature does not match"),
 	})?;
 
-	let payload = serde_json::from_slice::<Payload>(&msg_bytes).ok().context(
-		Message {
-			msg: format!(
-				"Error parsing request body {}",
-				String::from_utf8_lossy(&msg_bytes)
-			),
-		},
-	)?;
+	log::info!("Parsing webhook payload");
+	match serde_json::from_slice::<Payload>(&msg_bytes) {
+		Ok(payload) => handle_payload(payload, state).await,
+		Err(parsing_err) => {
+			let err = Error::Message {
+				msg: format!(
+					"Webhook event parsing failed due to:
+```
+{}
+```
+
+Payload:
+
+```
+{}
+```
+",
+					parsing_err,
+					String::from_utf8_lossy(&msg_bytes[..])
+				),
+			};
+
+			// If this comment was originated from a Bot, then acting on it might make the bot
+			// to respond to itself recursively, as happened on
+			// https://github.com/paritytech/substrate/pull/8409. Therefore we'll only act on
+			// this error if it's known for sure it has been initiated only by a User comment.
+			let pr_details = serde_json::from_slice::<
+				DetectUserCommentPullRequest,
+			>(&msg_bytes)
+			.ok()
+			.map(|detected| detected.get_details())
+			.flatten();
 
-	handle_payload(payload, state).await
+			Err(if let Some(pr_details) = pr_details {
+				err.map_issue(pr_details)
+			} else {
+				err
+			})
+		}
+	}
 }
 
 /// Match different kinds of payload.
@@ -149,7 +179,9 @@ async fn handle_payload(payload: Payload, state: &AppState) -> Result<()> {
 			comment:
 				Comment {
 					body,
-					user: User { login, .. },
+					user: Some(User {
+						login, type_field, ..
+					}),
 					..
 				},
 			issue:
@@ -158,11 +190,44 @@ async fn handle_payload(payload: Payload, state: &AppState) -> Result<()> {
 					html_url,
 					repository_url: Some(repo_url),
 					pull_request: Some(_), // indicates the issue is a pr
+					repository,
 					..
 				},
-		} => {
-			handle_comment(body, login, number, html_url, repo_url, state).await
-		}
+		} => match type_field {
+			Some(UserType::User) => handle_comment(
+				body, &login, number, &html_url, &repo_url, state,
+			)
+			.await
+			.map_err(|e| match e {
+				Error::WithIssue { .. } => e,
+				e => {
+					let details = if let Some(Repository {
+						owner: Some(User { login, .. }),
+						name,
+						..
+					}) = &repository
+					{
+						Some((login.to_owned(), name.to_owned(), number))
+					} else if let Some(Repository {
+						full_name: Some(full_name),
+						..
+					}) = &repository
+					{
+						parse_repository_full_name(full_name)
+							.map(|(owner, name)| (owner, name, number))
+					} else {
+						parse_issue_details_from_pr_html_url(&repo_url)
+					};
+
+					if let Some(details) = details {
+						e.map_issue(details)
+					} else {
+						e
+					}
+				}
+			}),
+			_ => Ok(()),
+		},
 		Payload::CommitStatus {
 			sha, state: status, ..
 		} => handle_status(sha, status, state).await,
@@ -172,7 +237,7 @@ async fn handle_payload(payload: Payload, state: &AppState) -> Result<()> {
 			},
 			..
 		} => handle_check(status, head_sha, state).await,
-		_event => Ok(()),
+		_ => Ok(()),
 	}
 }
 
@@ -214,7 +279,7 @@ async fn checks_and_status(
 	commit_sha: &str,
 	db: &DB,
 ) -> Result<()> {
-	if let Some(b) = db.get(commit_sha.trim().as_bytes()).context(Db)? {
+	if let Some(b) = db.get(commit_sha.as_bytes()).context(Db)? {
 		let m = bincode::deserialize(&b).context(Bincode)?;
 		log::info!("Deserialized merge request: {:?}", m);
 		let MergeRequest {
@@ -226,8 +291,10 @@ async fn checks_and_status(
 		} = m;
 		let pr = github_bot.pull_request(&owner, &repo_name, number).await?;
 
+		let pr_head_sha = pr.head_sha()?;
+
 		// Head sha should not have changed since request was made.
-		if commit_sha == pr.head.sha {
+		if commit_sha == pr_head_sha {
 			log::info!(
 				"Commit sha {} matches head of {}",
 				commit_sha,
@@ -262,15 +329,15 @@ async fn checks_and_status(
 						merge(github_bot, &owner, &repo_name, &pr).await?;
 
 						// clean db
-						db.delete(pr.head.sha.trim().as_bytes())
-							.context(Db)
-							.map_err(|e| {
-								e.map_issue(Some((
+						db.delete(pr_head_sha.as_bytes()).context(Db).map_err(
+							|e| {
+								e.map_issue((
 									owner.to_string(),
 									repo_name.to_string(),
 									pr.number,
-								)))
-							})?;
+								))
+							},
+						)?;
 
 						// update companion if necessary
 						update_companion(github_bot, &repo_name, &pr, db)
@@ -284,11 +351,11 @@ async fn checks_and_status(
 						Err(Error::ChecksFailed {
 							commit_sha: commit_sha.to_string(),
 						}
-						.map_issue(Some((
+						.map_issue((
 							owner.to_string(),
 							repo_name.to_string(),
 							pr.number,
-						))))?;
+						)))?;
 					}
 					CombinedStatus {
 						state: StatusState::Error,
@@ -298,11 +365,11 @@ async fn checks_and_status(
 						Err(Error::ChecksFailed {
 							commit_sha: commit_sha.to_string(),
 						}
-						.map_issue(Some((
+						.map_issue((
 							owner.to_string(),
 							repo_name.to_string(),
 							pr.number,
-						))))?;
+						)))?;
 					}
 					CombinedStatus {
 						state: StatusState::Pending,
@@ -320,11 +387,11 @@ async fn checks_and_status(
 				Err(Error::ChecksFailed {
 					commit_sha: commit_sha.to_string(),
 				}
-				.map_issue(Some((
+				.map_issue((
 					owner.to_string(),
 					repo_name.to_string(),
 					pr.number,
-				))))?;
+				)))?;
 			} else {
 				log::info!("{} checks incomplete", html_url);
 			}
@@ -334,14 +401,9 @@ async fn checks_and_status(
 				"Head sha has changed since merge was requested on {}",
 				html_url
 			);
-			Err(Error::HeadChanged {
+			return Err(Error::HeadChanged {
 				commit_sha: commit_sha.to_string(),
-			}
-			.map_issue(Some((
-				owner.to_string(),
-				repo_name.to_string(),
-				pr.number,
-			))))?;
+			});
 		}
 	}
 
@@ -359,17 +421,17 @@ async fn checks_and_status(
 /// See also README.md.
 async fn handle_comment(
 	body: String,
-	requested_by: String,
+	requested_by: &str,
 	number: i64,
-	html_url: String,
-	repo_url: String,
+	html_url: &str,
+	repo_url: &str,
 	state: &AppState,
 ) -> Result<()> {
 	let db = &state.db;
 	let github_bot = &state.github_bot;
 	let bot_config = &state.bot_config;
 
-	let owner = GithubBot::owner_from_html_url(&html_url).context(Message {
+	let owner = GithubBot::owner_from_html_url(html_url).context(Message {
 		msg: format!("Failed parsing owner in url: {}", html_url),
 	})?;
 
@@ -381,19 +443,10 @@ async fn handle_comment(
 		)?;
 
 	// Fetch the pr to get all fields (eg. mergeable).
-	let pr = github_bot
-		.pull_request(owner, &repo_name, number)
-		.await
-		.map_err(|e| {
-			e.map_issue(Some((
-				owner.to_string(),
-				repo_name.to_string(),
-				number,
-			)))
-		})?;
+	let pr = &github_bot.pull_request(owner, &repo_name, number).await?;
 
 	let auth =
-		GithubUserAuthenticator::new(&requested_by, owner, &repo_name, number);
+		GithubUserAuthenticator::new(requested_by, owner, &repo_name, number);
 
 	if body.to_lowercase().trim() == AUTO_MERGE_REQUEST.to_lowercase().trim() {
 		//
@@ -414,16 +467,16 @@ async fn handle_comment(
 			github_bot,
 			owner,
 			&repo_name,
-			&pr,
+			pr,
 			&bot_config,
-			&requested_by,
+			requested_by,
 		)
 		.await?;
 
 		//
 		// status and merge
 		//
-		if ready_to_merge(github_bot, owner, &repo_name, &pr).await? {
+		if ready_to_merge(github_bot, owner, &repo_name, pr).await? {
 			prepare_to_merge(
 				github_bot,
 				owner,
@@ -433,17 +486,18 @@ async fn handle_comment(
 			)
 			.await?;
 
-			merge(github_bot, owner, &repo_name, &pr).await?;
-			update_companion(github_bot, &repo_name, &pr, db).await?;
+			merge(github_bot, owner, &repo_name, pr).await?;
+			update_companion(github_bot, &repo_name, pr, db).await?;
 		} else {
+			let pr_head_sha = pr.head_sha()?;
 			wait_to_merge(
 				github_bot,
 				owner,
 				&repo_name,
 				pr.number,
 				&pr.html_url,
-				&requested_by,
-				&pr.head.sha,
+				requested_by,
+				pr_head_sha,
 				db,
 			)
 			.await?;
@@ -471,7 +525,7 @@ async fn handle_comment(
 			&repo_name,
 			&pr,
 			&bot_config,
-			&requested_by,
+			requested_by,
 		)
 		.await?;
 
@@ -491,6 +545,8 @@ async fn handle_comment(
 	} else if body.to_lowercase().trim()
 		== AUTO_MERGE_CANCEL.to_lowercase().trim()
 	{
+		let pr_head_sha = pr.head_sha()?;
+
 		//
 		// CANCEL MERGE
 		//
@@ -499,16 +555,8 @@ async fn handle_comment(
 			html_url,
 			requested_by
 		);
-		log::info!("Deleting merge request for {}", &html_url);
-		db.delete(pr.head.sha.trim().as_bytes())
-			.context(Db)
-			.map_err(|e| {
-				e.map_issue(Some((
-					owner.to_string(),
-					repo_name.to_string(),
-					number,
-				)))
-			})?;
+		log::info!("Deleting merge request for {}", html_url);
+		db.delete(pr_head_sha.as_bytes()).context(Db)?;
 		let _ = github_bot
 			.create_issue_comment(
 				owner,
@@ -524,6 +572,8 @@ async fn handle_comment(
 		&& body.to_lowercase().trim()
 			== COMPARE_RELEASE_REQUEST.to_lowercase().trim()
 	{
+		let pr_head_sha = pr.head_sha()?;
+
 		//
 		// DIFF
 		//
@@ -532,82 +582,47 @@ async fn handle_comment(
 			html_url,
 			requested_by
 		);
-		let rel = github_bot.latest_release(owner, &repo_name).await.map_err(
-			|e| {
-				e.map_issue(Some((
-					owner.to_string(),
-					repo_name.to_string(),
-					number,
-				)))
-			},
-		)?;
-		let release_tag = github_bot
-			.tag(owner, &repo_name, &rel.tag_name)
-			.await
-			.map_err(|e| {
-				e.map_issue(Some((
-					owner.to_string(),
-					repo_name.to_string(),
-					number,
-				)))
-			})?;
+		let rel = github_bot.latest_release(owner, &repo_name).await?;
+		let release_tag =
+			github_bot.tag(owner, &repo_name, &rel.tag_name).await?;
 		let release_substrate_commit = github_bot
 			.substrate_commit_from_polkadot_commit(&release_tag.object.sha)
-			.await;
+			.await?;
 		let branch_substrate_commit = github_bot
-			.substrate_commit_from_polkadot_commit(&pr.head.sha)
-			.await;
-		if release_substrate_commit.is_ok() && branch_substrate_commit.is_ok() {
-			let link = github_bot.diff_url(
-				owner,
-				"substrate",
-				&release_substrate_commit.unwrap(),
-				&branch_substrate_commit.unwrap(),
-			);
+			.substrate_commit_from_polkadot_commit(pr_head_sha)
+			.await?;
+		let link = github_bot.diff_url(
+			owner,
+			"substrate",
+			&release_substrate_commit,
+			&branch_substrate_commit,
+		);
 
-			// post link
-			log::info!("Posting link to substrate diff: {}", &link);
-			let _ = github_bot
-				.create_issue_comment(owner, &repo_name, number, &link)
-				.await
-				.map_err(|e| {
-					log::error!("Error posting comment: {}", e);
-				});
-		} else {
-			if let Err(e) = release_substrate_commit {
-				log::error!("Error getting release substrate commit: {}", e);
-				Err(e.map_issue(Some((
-					owner.to_string(),
-					repo_name.to_string(),
-					number,
-				))))?;
-			}
-			if let Err(e) = branch_substrate_commit {
-				log::error!("Error getting branch substrate commit: {}", e);
-				Err(e.map_issue(Some((
-					owner.to_string(),
-					repo_name.to_string(),
-					number,
-				))))?;
-			}
-		}
+		// post link
+		log::info!("Posting link to substrate diff: {}", &link);
+		let _ = github_bot
+			.create_issue_comment(owner, &repo_name, number, &link)
+			.await
+			.map_err(|e| {
+				log::error!("Error posting comment: {}", e);
+			});
 	} else if body.to_lowercase().trim() == REBASE.to_lowercase().trim() {
 		log::info!("Rebase {} requested by {}", html_url, requested_by);
 		if let PullRequest {
 			head:
-				Head {
-					ref_field: head_branch,
+				Some(Head {
+					ref_field: Some(head_branch),
 					repo:
-						HeadRepo {
+						Some(HeadRepo {
 							name: head_repo,
 							owner:
 								Some(User {
 									login: head_owner, ..
 								}),
 							..
-						},
+						}),
 					..
-				},
+				}),
 			..
 		} = pr.clone()
 		{
@@ -627,16 +642,11 @@ async fn handle_comment(
 			)
 			.await?;
 		} else {
-			Err(Error::Message {
+			return Err(Error::Message {
 				msg: format!(
 					"PR response is missing required fields; rebase aborted."
 				),
-			}
-			.map_issue(Some((
-				owner.to_string(),
-				repo_name.to_string(),
-				number,
-			))))?;
+			});
 		}
 	} else if body.to_lowercase().trim() == BURNIN_REQUEST.to_lowercase().trim()
 	{
@@ -647,11 +657,11 @@ async fn handle_comment(
 			&state.gitlab_bot,
 			&state.matrix_bot,
 			owner,
-			&requested_by,
+			requested_by,
 			&repo_name,
 			&pr,
 		)
-		.await;
+		.await?;
 	}
 
 	Ok(())
@@ -665,14 +675,16 @@ async fn handle_burnin_request(
 	requested_by: &str,
 	repo_name: &str,
 	pr: &PullRequest,
-) {
+) -> Result<()> {
 	let make_job_link =
 		|url| format!("<a href=\"{}\">CI job for burn-in deployment</a>", url);
 
 	let unexpected_error_msg = "Starting CI job for burn-in deployment failed with an unexpected error; see logs.".to_string();
 	let mut matrix_msg: Option<String> = None;
 
-	let msg = match gitlab_bot.build_artifact(&pr.head.sha) {
+	let pr_head_sha = pr.head_sha()?;
+
+	let msg = match gitlab_bot.build_artifact(pr_head_sha) {
 		Ok(job) => {
 			let ci_job_link = make_job_link(job.url);
 
@@ -731,21 +743,19 @@ async fn handle_burnin_request(
 		}
 	};
 
-	if let Err(e) = github_bot
+	github_bot
 		.create_issue_comment(owner, &repo_name, pr.number, &msg)
-		.await
-	{
-		log::error!("Error posting GitHub comment: {}", e);
-	}
+		.await?;
 
-	let full_matrix_msg = format!(
+	matrix_bot.send_html_to_default(
+		format!(
 		"Received burn-in request for <a href=\"{}\">{}#{}</a> from {}<br />\n{}",
 		pr.html_url, repo_name, pr.number, requested_by, matrix_msg.unwrap_or(msg),
-	);
+	)
+		.as_str(),
+	)?;
 
-	if let Err(e) = matrix_bot.send_html_to_default(&full_matrix_msg) {
-		log::error!("Error sending Matrix message: {}", e);
-	}
+	Ok(())
 }
 
 /// Check if the pull request is mergeable and approved.
@@ -758,119 +768,97 @@ async fn merge_allowed(
 	requested_by: &str,
 ) -> Result<()> {
 	let mergeable = pr.mergeable.unwrap_or(false);
+
 	if !mergeable {
-		log::info!("{} is unmergeable", pr.html_url);
-		Err(Error::Message {
-			msg: format!("The PR is currently unmergeable."),
-		}
-		.map_issue(Some((
-			owner.to_string(),
-			repo_name.to_string(),
-			pr.number,
-		))))?;
-	} else {
-		log::info!("{} is mergeable.", pr.html_url);
+		let msg = format!("{} is unmergeable", pr.html_url);
+		log::info!("{}", msg);
+		return Err(Error::Message { msg });
+	}
 
-		let team_leads = github_bot
-			.team(owner, "substrateteamleads")
+	log::info!("{} is mergeable.", pr.html_url);
+
+	let team_leads = github_bot
+		.team(owner, "substrateteamleads")
+		.and_then(|team| github_bot.team_members(team.id))
+		.await
+		.unwrap_or_else(|e| {
+			log::error!("Error getting core devs: {}", e);
+			vec![]
+		});
+
+	if team_leads.iter().any(|lead| lead.login == requested_by) {
+		//
+		// MERGE ALLOWED
+		//
+		log::info!("{} merge requested by a team lead.", pr.html_url);
+	} else {
+		fn label_insubstantial(label: &&Label) -> bool {
+			label.name.contains("insubstantial")
+		}
+		let min_reviewers =
+			if pr.labels.iter().find(label_insubstantial).is_some() {
+				1
+			} else {
+				bot_config.min_reviewers
+			};
+		let core_devs = github_bot
+			.team(owner, "core-devs")
 			.and_then(|team| github_bot.team_members(team.id))
 			.await
 			.unwrap_or_else(|e| {
 				log::error!("Error getting core devs: {}", e);
 				vec![]
 			});
-
-		if team_leads.iter().any(|lead| lead.login == requested_by) {
+		let reviews = github_bot.reviews(&pr.url).await.unwrap_or_else(|e| {
+			log::error!("Error getting reviews: {}", e);
+			vec![]
+		});
+		let core_approved = reviews
+			.iter()
+			.filter(|r| {
+				core_devs.iter().any(|u| u.login == r.user.login)
+					&& r.state == Some(ReviewState::Approved)
+			})
+			.count() >= min_reviewers;
+		let lead_approved = reviews
+			.iter()
+			.filter(|r| {
+				team_leads.iter().any(|u| u.login == r.user.login)
+					&& r.state == Some(ReviewState::Approved)
+			})
+			.count() >= 1;
+		if core_approved || lead_approved {
 			//
 			// MERGE ALLOWED
 			//
-			log::info!("{} merge requested by a team lead.", pr.html_url);
+			log::info!("{} has core or team lead approval.", pr.html_url);
 		} else {
-			fn label_insubstantial(label: &&Label) -> bool {
-				label.name.contains("insubstantial")
-			}
-			let min_reviewers =
-				if pr.labels.iter().find(label_insubstantial).is_some() {
-					1
-				} else {
-					bot_config.min_reviewers
-				};
-			let core_devs = github_bot
-				.team(owner, "core-devs")
-				.and_then(|team| github_bot.team_members(team.id))
-				.await
-				.unwrap_or_else(|e| {
-					log::error!("Error getting core devs: {}", e);
-					vec![]
-				});
-			let reviews =
-				github_bot.reviews(&pr.url).await.unwrap_or_else(|e| {
-					log::error!("Error getting reviews: {}", e);
-					vec![]
-				});
-			let core_approved = reviews
-				.iter()
-				.filter(|r| {
-					core_devs.iter().any(|u| u.login == r.user.login)
-						&& r.state == Some(ReviewState::Approved)
-				})
-				.count() >= min_reviewers;
-			let lead_approved = reviews
+			// get process info
+			let process =
+				process::get_process(github_bot, owner, repo_name, pr.number)
+					.await
+					.map_err(|e| Error::ProcessFile {
+						source: Box::new(e),
+					})?;
+			let owner_approved = reviews
 				.iter()
-				.filter(|r| {
-					team_leads.iter().any(|u| u.login == r.user.login)
-						&& r.state == Some(ReviewState::Approved)
-				})
-				.count() >= 1;
-			if core_approved || lead_approved {
+				.sorted_by_key(|r| r.submitted_at)
+				.rev()
+				.find(|r| process.is_owner(&r.user.login))
+				.map_or(false, |r| r.state == Some(ReviewState::Approved));
+
+			let owner_requested = process.is_owner(&requested_by);
+
+			if owner_approved || owner_requested {
 				//
 				// MERGE ALLOWED
 				//
-				log::info!("{} has core or team lead approval.", pr.html_url);
+				log::info!("{} has owner approval.", pr.html_url);
 			} else {
-				// get process info
-				let process = process::get_process(
-					github_bot, owner, repo_name, pr.number,
-				)
-				.await
-				.map_err(|e| {
-					Error::ProcessFile {
-						source: Box::new(e),
-					}
-					.map_issue(Some((
-						owner.to_string(),
-						repo_name.to_string(),
-						pr.number,
-					)))
-				})?;
-				let owner_approved = reviews
-					.iter()
-					.sorted_by_key(|r| r.submitted_at)
-					.rev()
-					.find(|r| process.is_owner(&r.user.login))
-					.map_or(false, |r| r.state == Some(ReviewState::Approved));
-
-				let owner_requested = process.is_owner(&requested_by);
-
-				if owner_approved || owner_requested {
-					//
-					// MERGE ALLOWED
-					//
-					log::info!("{} has owner approval.", pr.html_url);
+				if process.is_empty() {
+					Err(Error::ProcessInfo {})?;
 				} else {
-					if process.is_empty() {
-						Err(Error::ProcessInfo {}.map_issue(Some((
-							owner.to_string(),
-							repo_name.to_string(),
-							pr.number,
-						))))?;
-					} else {
-						Err(Error::Approval {}.map_issue(Some((
-							owner.to_string(),
-							repo_name.to_string(),
-							pr.number,
-						))))?;
-					}
+					Err(Error::Approval {})?;
 				}
 			}
 		}
@@ -889,18 +877,16 @@ async fn ready_to_merge(
 	repo_name: &str,
 	pr: &PullRequest,
 ) -> Result<bool> {
+	let pr_head_sha = pr.head_sha()?;
+
 	//
 	// status
 	//
 	match github_bot
-		.status(owner, &repo_name, &pr.head.sha)
+		.status(owner, &repo_name, pr_head_sha)
 		.await
 		.map_err(|e| {
-			e.map_issue(Some((
-				owner.to_string(),
-				repo_name.to_string(),
-				pr.number,
-			)))
+			e.map_issue((owner.to_string(), repo_name.to_string(), pr.number))
 		})? {
 		CombinedStatus {
 			state: StatusState::Success,
@@ -911,14 +897,14 @@ async fn ready_to_merge(
 			// checks
 			//
 			let checks = github_bot
-				.check_runs(&owner, &repo_name, &pr.head.sha)
+				.check_runs(&owner, &repo_name, pr_head_sha)
 				.await
 				.map_err(|e| {
-					e.map_issue(Some((
+					e.map_issue((
 						owner.to_string(),
 						repo_name.to_string(),
 						pr.number,
-					)))
+					))
 				})?;
 			log::info!("{:?}", checks);
 			if checks
@@ -940,13 +926,13 @@ async fn ready_to_merge(
 				//
 				log::info!("{} checks were unsuccessful.", pr.html_url);
 				return Err(Error::ChecksFailed {
-					commit_sha: pr.head.sha.clone(),
+					commit_sha: pr_head_sha.to_string(),
 				}
-				.map_issue(Some((
+				.map_issue((
 					owner.to_string(),
 					repo_name.to_string(),
 					pr.number,
-				))));
+				)));
 			} else {
 				//
 				// status/checks pending
@@ -972,13 +958,9 @@ async fn ready_to_merge(
 			//
 			log::info!("{} status failure.", pr.html_url);
 			return Err(Error::ChecksFailed {
-				commit_sha: pr.head.sha.to_string(),
+				commit_sha: pr_head_sha.to_string(),
 			}
-			.map_issue(Some((
-				owner.to_string(),
-				repo_name.to_string(),
-				pr.number,
-			))));
+			.map_issue((owner.to_string(), repo_name.to_string(), pr.number)));
 		}
 		CombinedStatus {
 			state: StatusState::Error,
@@ -989,13 +971,9 @@ async fn ready_to_merge(
 			//
 			log::info!("{} status error.", pr.html_url);
 			return Err(Error::ChecksFailed {
-				commit_sha: pr.head.sha.to_string(),
+				commit_sha: pr_head_sha.to_string(),
 			}
-			.map_issue(Some((
-				owner.to_string(),
-				repo_name.to_string(),
-				pr.number,
-			))));
+			.map_issue((owner.to_string(), repo_name.to_string(), pr.number)));
 		}
 	}
 }
@@ -1021,17 +999,13 @@ async fn create_merge_request(
 	};
 	log::info!("Serializing merge request: {:?}", m);
 	let bytes = bincode::serialize(&m).context(Bincode).map_err(|e| {
-		e.map_issue(Some((owner.to_string(), repo_name.to_string(), number)))
+		e.map_issue((owner.to_string(), repo_name.to_string(), number))
 	})?;
 	log::info!("Writing merge request to db (head sha: {})", commit_sha);
 	db.put(commit_sha.trim().as_bytes(), bytes)
 		.context(Db)
 		.map_err(|e| {
-			e.map_issue(Some((
-				owner.to_string(),
-				repo_name.to_string(),
-				number,
-			)))
+			e.map_issue((owner.to_string(), repo_name.to_string(), number))
 		})?;
 	Ok(())
 }
@@ -1099,19 +1073,16 @@ async fn merge(
 	repo_name: &str,
 	pr: &PullRequest,
 ) -> Result<()> {
+	let pr_head_sha = pr.head_sha()?;
 	github_bot
-		.merge_pull_request(owner, repo_name, pr.number, &pr.head.sha)
+		.merge_pull_request(owner, repo_name, pr.number, pr_head_sha)
 		.await
 		.map_err(|e| {
 			Error::Merge {
 				source: Box::new(e),
-				commit_sha: pr.head.sha.clone(),
+				commit_sha: pr_head_sha.to_string(),
 			}
-			.map_issue(Some((
-				owner.to_string(),
-				repo_name.to_string(),
-				pr.number,
-			)))
+			.map_issue((owner.to_string(), repo_name.to_string(), pr.number))
 		})?;
 	log::info!("{} merged successfully.", pr.html_url);
 	Ok(())
@@ -1137,18 +1108,18 @@ async fn performance_regression(
 		});
 	if let PullRequest {
 		head:
-			Head {
-				ref_field: head_branch,
+			Some(Head {
+				ref_field: Some(head_branch),
 				repo:
-					HeadRepo {
+					Some(HeadRepo {
 						name: head_repo,
 						owner: Some(User {
 							login: head_owner, ..
 						}),
 						..
-					},
+					}),
 				..
-			},
+			}),
 		..
 	} = pr.clone()
 	{
@@ -1168,11 +1139,11 @@ async fn performance_regression(
 					Err(Error::Message {
 							msg: format!("Performance regression shows greater than 2x increase in benchmark average; aborting merge."),
 						}
-						.map_issue(Some((
+						.map_issue((
 							owner.to_string(),
 							repo_name.to_string(),
 							pr.number,
-						))))?;
+						)))?;
 				}
 			}
 			Ok(None) => {
@@ -1217,19 +1188,19 @@ async fn update_companion(
 					.pull_request(&comp_owner, &comp_repo, comp_number)
 					.await
 					.map_err(|e| {
-						e.map_issue(Some((
+						e.map_issue((
 							comp_owner.to_string(),
 							comp_repo.to_string(),
 							comp_number,
-						)))
+						))
 					})?;
 
 				if let PullRequest {
 					head:
-						Head {
-							ref_field: comp_head_branch,
+						Some(Head {
+							ref_field: Some(comp_head_branch),
 							repo:
-								HeadRepo {
+								Some(HeadRepo {
 									name: comp_head_repo,
 									owner:
 										Some(User {
@@ -1237,9 +1208,9 @@ async fn update_companion(
 											..
 										}),
 									..
-								},
+								}),
 							..
-						},
+						}),
 					..
 				} = comp_pr.clone()
 				{
@@ -1302,18 +1273,18 @@ Failed companion update:
 						}
 					}
 				} else {
-					Err(Error::Companion {
+					return Err(Error::Companion {
 						source: Box::new(Error::Message {
 							msg: format!(
 								"Companion PR is missing required fields."
 							),
 						}),
 					}
-					.map_issue(Some((
+					.map_issue((
 						comp_owner.to_string(),
 						comp_repo.to_string(),
 						comp_number,
-					))))?;
+					)));
 				}
 			} else {
 				log::info!("No companion found.");
@@ -1346,7 +1317,7 @@ async fn handle_error(e: Error, state: &AppState) {
 	match e {
 		Error::WithIssue {
 			source,
-			issue: Some((owner, repo, number)),
+			issue: (owner, repo, number),
 			..
 		} => {
 			let msg = match *source {