diff --git a/pages/403.js b/pages/403.js
new file mode 100644
index 0000000..48a384b
--- /dev/null
+++ b/pages/403.js
@@ -0,0 +1,24 @@
+import Header from '../Components/Header'
+import {Component} from 'react'
+
+export default class Home extends Component {
+	constructor(props) {
+		super(props);
+	}
+
+
+	render() {
+		return (
+			<>
+			<Header
+				name="403"
+				subtext="Forbidden - You do not have the correct permissions to view this page"
+				gradient={["F27878", "D96B6B"]}
+				wave="web/waves/header/rsm"
+				buttons={[{color: "F27878", buttonText: "ffffff", text: "Go Home", link: "/#"}]}
+        		hideArrow={true}
+			/>
+			</>
+		)
+	}
+}
diff --git a/pages/404.js b/pages/404.js
index c3dcdba..4e58543 100644
--- a/pages/404.js
+++ b/pages/404.js
@@ -13,11 +13,11 @@
 			<Header
 				name="404"
 				subtext="Not Found"
-				gradient={["6576CC", "4B5899"]}
-				wave="web/waves/header/cmp"
+				gradient={["F27878", "D96B6B"]}
+				wave="web/waves/header/rsm"
 				buttons={[
-					{color: "6576CC", buttonText: "ffffff", text: "Go Home", link: "/#"},
-					{color: "6576CC", buttonText: "ffffff", text: "Send Error",
+					{color: "F27878", buttonText: "ffffff", text: "Go Home", link: "/#"},
+					{color: "F27878", buttonText: "ffffff", text: "Send Error",
 						link: `mailto:staff@clicksminuteper.net?subject=Website%20Error%20Report&body=I%20got%20a%20404%20on%20the%20page%20%5BPlease%20Copy%20Website%20Link%20Here%5D`,
 						target: true
 				}]}
diff --git a/pages/418.js b/pages/418.js
new file mode 100644
index 0000000..7f8ae09
--- /dev/null
+++ b/pages/418.js
@@ -0,0 +1,24 @@
+import Header from '../Components/Header'
+import {Component} from 'react'
+
+export default class Home extends Component {
+	constructor(props) {
+		super(props);
+	}
+
+
+	render() {
+		return (
+			<>
+			<Header
+				name="418"
+				subtext={<>I'm a teapot<br /><br />The request body was short and stout.<br />Tip me over and pour me out</>}
+				gradient={["F27878", "D96B6B"]}
+				wave="web/waves/header/rsm"
+				buttons={[{color: "F27878", buttonText: "ffffff", text: "Go Home", link: "/#"}]}
+        		hideArrow={true}
+			/>
+			</>
+		)
+	}
+}
diff --git a/pages/500.js b/pages/500.js
index 20d66ca..4fa7248 100644
--- a/pages/500.js
+++ b/pages/500.js
@@ -13,11 +13,11 @@
 			<Header
 				name="500"
 				subtext="Internal Server Error"
-				gradient={["6576CC", "4B5899"]}
-				wave="web/waves/header/cmp"
+				gradient={["F27878", "D96B6B"]}
+				wave="web/waves/header/rsm"
 				buttons={[
-					{color: "6576CC", buttonText: "ffffff", text: "Go Home", link: "/#"},
-					{color: "6576CC", buttonText: "ffffff", text: "Send Error",
+					{color: "F27878", buttonText: "ffffff", text: "Go Home", link: "/#"},
+					{color: "F27878", buttonText: "ffffff", text: "Send Error",
 						link: `mailto:staff@clicksminuteper.net?subject=Website%20Error%20Report&body=I%20got%20a%20500%20on%20the%20page%20%5BPlease%20Copy%20Website%20Link%20Here%5D`,
 						target: true
 				}]}
