diff --git a/docs/.vuepress/bmcAppPlugin.js b/docs/.vuepress/bmcAppPlugin.js
new file mode 100644
index 0000000..d068b05
--- /dev/null
+++ b/docs/.vuepress/bmcAppPlugin.js
@@ -0,0 +1,8 @@
+import "../../src/assets/styles/_obmc-custom.scss";
+import Alert from '../../src/components/Global/Alert';
+
+export default {
+    install (Vue, options) {
+        Vue.component('Alert', Alert);
+    }
+}
\ No newline at end of file
diff --git a/docs/.vuepress/components/BmcAlerts.vue b/docs/.vuepress/components/BmcAlerts.vue
new file mode 100644
index 0000000..a0c9503
--- /dev/null
+++ b/docs/.vuepress/components/BmcAlerts.vue
@@ -0,0 +1,15 @@
+<template>
+    <div>
+        <alert show variant="warning">This is a warning message</alert>
+        <alert show variant="danger">This is an error message</alert>
+        <alert show variant="info">This is an info message</alert>
+    </div>
+</template>
+
+<script>
+
+export default {
+    name: 'BmcAlerts',
+
+}
+</script>
\ No newline at end of file
diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index 5a8e601..abcbeb9 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -42,7 +42,10 @@
           },
           {
             title: "Components",
-            children: ["/guide/components/", "/guide/components/page-section"]
+            children: [
+            "/guide/components/",
+            "/guide/components/alert",
+          ]
           }
         ],
         "/themes/": [""]
diff --git a/docs/.vuepress/enhanceApp.js b/docs/.vuepress/enhanceApp.js
new file mode 100644
index 0000000..5a84f61
--- /dev/null
+++ b/docs/.vuepress/enhanceApp.js
@@ -0,0 +1,10 @@
+import {
+    AlertPlugin,
+  } from 'bootstrap-vue';
+
+import BmcAppPlugin from './bmcAppPlugin';
+
+export default ({ Vue }) => {
+      Vue.use(AlertPlugin);
+      Vue.use(BmcAppPlugin);
+}
\ No newline at end of file
diff --git a/docs/guide/components/alert.md b/docs/guide/components/alert.md
new file mode 100644
index 0000000..768aa87
--- /dev/null
+++ b/docs/guide/components/alert.md
@@ -0,0 +1,12 @@
+# Alerts
+An alert is an inline message that contains a short description that a user cannot manually dismiss. With exception to the error message on the login page, alerts are not triggered by user action. Success and error notifications based on user actions are created using a toast component.
+
+[Learn more about Bootstrap-vue alert options](https://bootstrap-vue.js.org/docs/components/alert)
+
+<BmcAlerts />
+
+```vue
+<alert show variant="warning">This is a warning message</alert>
+<alert show variant="danger">This is an error message</alert>
+<alert show variant="info">This is an info message</alert>
+```
\ No newline at end of file
