diff --git a/docs/img/expstat1.png b/docs/img/expstat1.png
new file mode 100644
index 0000000..fb5fa1a
--- /dev/null
+++ b/docs/img/expstat1.png
Binary files differ
diff --git a/docs/img/expstat2.png b/docs/img/expstat2.png
new file mode 100644
index 0000000..7723a9c
--- /dev/null
+++ b/docs/img/expstat2.png
Binary files differ
diff --git a/docs/img/gau-app-dep.png b/docs/img/gau-app-dep.png
deleted file mode 100644
index b7b23ce..0000000
--- a/docs/img/gau-app-dep.png
+++ /dev/null
Binary files differ
diff --git a/docs/img/gau-app-detail-tab.png b/docs/img/gau-app-detail-tab.png
deleted file mode 100644
index f7c305d..0000000
--- a/docs/img/gau-app-detail-tab.png
+++ /dev/null
Binary files differ
diff --git a/docs/img/gau-app-input.png b/docs/img/gau-app-input.png
deleted file mode 100644
index 256c54a..0000000
--- a/docs/img/gau-app-input.png
+++ /dev/null
Binary files differ
diff --git a/docs/img/gau-app-inputoutput1.png b/docs/img/gau-app-inputoutput1.png
new file mode 100644
index 0000000..ae6a0df
--- /dev/null
+++ b/docs/img/gau-app-inputoutput1.png
Binary files differ
diff --git a/docs/img/gau-app-inputoutput2.png b/docs/img/gau-app-inputoutput2.png
new file mode 100644
index 0000000..a8614d9
--- /dev/null
+++ b/docs/img/gau-app-inputoutput2.png
Binary files differ
diff --git a/docs/img/gau-app-int-1.png b/docs/img/gau-app-int-1.png
deleted file mode 100644
index 435f1c9..0000000
--- a/docs/img/gau-app-int-1.png
+++ /dev/null
Binary files differ
diff --git a/docs/img/gau-app-int-2.png b/docs/img/gau-app-int-2.png
deleted file mode 100644
index b654ba2..0000000
--- a/docs/img/gau-app-int-2.png
+++ /dev/null
Binary files differ
diff --git a/docs/img/gau-app-int-3.png b/docs/img/gau-app-int-3.png
deleted file mode 100644
index e466a46..0000000
--- a/docs/img/gau-app-int-3.png
+++ /dev/null
Binary files differ
diff --git a/docs/img/gau-app-mod.png b/docs/img/gau-app-mod.png
deleted file mode 100644
index 68e5875..0000000
--- a/docs/img/gau-app-mod.png
+++ /dev/null
Binary files differ
diff --git a/docs/img/gau-app-output1.png b/docs/img/gau-app-output1.png
deleted file mode 100644
index ece7689..0000000
--- a/docs/img/gau-app-output1.png
+++ /dev/null
Binary files differ
diff --git a/docs/img/gau-app-output2.png b/docs/img/gau-app-output2.png
deleted file mode 100644
index 198742a..0000000
--- a/docs/img/gau-app-output2.png
+++ /dev/null
Binary files differ
diff --git a/docs/img/gau-app-output3.png b/docs/img/gau-app-output3.png
deleted file mode 100644
index f549dfa..0000000
--- a/docs/img/gau-app-output3.png
+++ /dev/null
Binary files differ
diff --git a/docs/img/gau16-app-detail-tab.png b/docs/img/gau16-app-detail-tab.png
new file mode 100644
index 0000000..76d8fb2
--- /dev/null
+++ b/docs/img/gau16-app-detail-tab.png
Binary files differ
diff --git a/docs/img/gau16appdeploy.png b/docs/img/gau16appdeploy.png
new file mode 100644
index 0000000..2f9092f
--- /dev/null
+++ b/docs/img/gau16appdeploy.png
Binary files differ
diff --git a/docs/img/gau16appdetails.png b/docs/img/gau16appdetails.png
new file mode 100644
index 0000000..5814b53
--- /dev/null
+++ b/docs/img/gau16appdetails.png
Binary files differ
diff --git a/docs/img/gau16appinput.png b/docs/img/gau16appinput.png
new file mode 100644
index 0000000..07c7c5b
--- /dev/null
+++ b/docs/img/gau16appinput.png
Binary files differ
diff --git a/docs/img/manageuser.png b/docs/img/manageuser.png
new file mode 100644
index 0000000..8970ccb
--- /dev/null
+++ b/docs/img/manageuser.png
Binary files differ
diff --git a/docs/user-documentation/application-catalog.md b/docs/user-documentation/application-catalog.md
index 202d9ea..cb9d482 100644
--- a/docs/user-documentation/application-catalog.md
+++ b/docs/user-documentation/application-catalog.md
@@ -1,10 +1,19 @@
 ## Application Catalog
 
-- _Application Catalog_ is where you will add your gateway applications/tools/codes for gateway users to consume.
+- Available actions on Experiments
+    - <a href= "#Gaussiangen">Introduction</a></br> 
+    - <a href= "#Gaussianapplication">Add Gaussian16 Details</a></br> 
+    - <a href= "#gau16interface">Add Gaussian16 Inputs and Outputs</a></br>
+    - <a href= "#gau16dep">Add Gaussian16 Deployment</a></br>
+    - <a href= "#edit">Edit</a></br>
+    - <a href= "#launch">Launch</a></br>
+    
+#####<h5 id="Gaussiangen">Introduction</h5>
+- _**Application Catalog**_ is where you will add your gateway applications/tools/codes for gateway users to consume.
 - Application/tool/code is what you create in the gateway, which will have all the configurations required to execute the actual code in the  remote resource.
 - Configuring an _Application_ is a three step process. You would;
  - First add the main _Details_ of the application
- - Next its the _Interface_, where you would add all the input required to execute application and also the outputs that the gateay should bring back for the user.
+ - Next its the _Interface_, where you would add all the input required to execute application and also the outputs that the gateway should bring back for the user.
  - Last is the _Deployment_, Which is the place you will add all the commands that are needed to execute the application in the remote resource.
 
 - Gateway admins can;
@@ -15,68 +24,81 @@
     
 NOTE: In order to explain how an application could be added to the gateway, we would take Gaussian16 application as the example. 
 
-#####<h5 id="Gaussianapplication">Register Gaussian16 Application</h5>
+#####<h5 id="Gaussianapplication">Add Gaussian16 Details</h5>
 
-1. Settings &rarr; Application Catalog &rarr; New Application +
+1. **Settings** &rarr; **Application Catalog** &rarr; **New Application +**
 2. In Details tab:
-    - Application Name: Gaussian16
-    - Application Version: Gaussian 16 (Optional)
-    - Application Description: Gaussian provides capabilities for electronic structure modeling
+    - Application Name: _Gaussian16_
+    - Application Version: _Gaussian 16:  ES64L-G16RevA.03_ (Optional)
+    - Application Description: Gaussian computes molecular electronic properties using ab inito and dft techniques. Core Count  should be same as %nproc value in the input. (Optional)
     - Save
 
 <ADD>------
-![Screenshot](../img/gau-app-detail-tab.png)
+![Screenshot](../img/gau16-app-detail-tab.png)
 Image:Adding Gaussian16 Details
 
-3. In Interface tab:
-    - Set 'Enable Archiving Working Directory' to True (Why? - This is set to true when you want to bring back all the files in the remote working directory back to the gateway portal. Caution: Gateway has a size restriction on ARCHIVE. Please contact SciGaP admins for more details.)
-    - Set 'Hide Queue Details' - This is your gateway preference. If you gateway users are not give the option of changing the queue properties when submitting jobs, you can hide this and have same properties set for all the users.
+#####<h5 id="gau16interface">Add Gaussian16 Inputs and Outputs</h5>
+1. **Settings** &rarr; **Application Catalog** &rarr; **Gaussian16** &rarr; **Interface**
+2. In Interface tab:
+    - Set _Enable Archiving Working Directory_ to `True` (Why? - This is set to true when you want to bring back all the files in the remote working directory back to the gateway portal. Caution: Gateway has a size restriction on ARCHIVE. Please contact SciGaP admins for more details.)
+    - Set _Show Queue Settings_ to `False` - This is your gateway preference. If you gateway users are not give the option of changing the queue properties when submitting jobs, you can hide this and have same properties set for all the users.
     - Provide Input Fields
-        - Click Add Application Input
-        - Name: Input-File
-        - Initial Value: gaussian.com
-        - Type: URI (Why? - This is the type for file uploads)
-        - Application Arguments:
-        - Read Only: False (Why? - this is only meaningful for String, Integer or Float inputs)
-        - User Friendly Description: Gaussian16 input file specifying desired calculation type, model chemistry, molecular system and other parameters. (This is information to the user at creating job experiment. Optional)
-        - Is the Input Required: True
-        - Required in Commandline: True
-        - Metadata:  (Why? - This is used mostly for advance string input options. Please <br>For more information refer: <a href="/user-documentation/advance-inputs" target="_blank">Advance Application Inputs</a>)
-<br></br>
-NOTE: For this application, only a single input, and its a file. For applications, there can be multiple inputs and different input types, such as String, Integer or many files.
+        - Click _Add Application Input_
+        - _Name_: `Input-File`
+        - _Initial Value_: `gaussian.com` (This is if you want to override the input names given by the user, if not leave it empty)
+        - _Type_: `URI` (Why? - This is the type for file uploads)
+        - _Application Arguments_: NULL
+        - _Required in Commandline_: `True`
+        - _Required_: `True`
+        - _Read Only_: `False` (Why? - this is only meaningful for String, Integer or Float inputs)
+        - _User Friendly Description_: Gaussian16 input file specifying desired calculation type, model chemistry, molecular system and other parameters. (This is information to the user at creating job experiment. Optional)
+        - _Advanced Input Field Modification Metadata_: NULL (Why? - This is used mostly for advance string input options. For more information refer: <a href="/user-documentation/advance-inputs" target="_blank">Advance Application Inputs</a>)
+<br>
+NOTE: For this application, only a single input, and its a file. For applications, there can be multiple inputs and different input types, such as String, Integer or multiple files.
     - Provide application outputs</br>
     NOTE: 4 application outputs to define. </br>
         - 1st Output
-            - Add Application Output
-            - Name: Gaussian-Application-Output
-            - Value: *.log
-            - Type: URI
-            - Application Argument:
-            - Is the Output required?: True
-            - Required on command line?: True
-            - Metadata: 
+            - Click _Add application output_
+            - _Name_: `Gaussian-Application-Output`
+            - _Value_: `*.log`
+            - _Type_: `URI_COLLECTION`
+            - _Application Argument_: NULL
+            - _Is Required_: `True`
+            - _Required on Command Line_: `True`
+            - _Metadata_: 
+            <div>
+            ```
+            json
+            {
+                "output-view-providers": [
+                    "gaussian_eigenvalues_view"
+                ]
+            }
+            ```
+            </div>
+
         - 2nd output
-            - Add Application Output
-            - Name: Gaussian_Checkpoint_File
-            - Value: *.chk
-            - Type: URI
-            - Application Argument:
-            - Data Movement: False
-            - Is the Output required?: True
-            - Required on command line?: True
-            - Metadata:
+            - CLick _Add Application Output_
+            - _Name_: `Gaussian_Checkpoint_File`
+            - _Value_: `*.chk`
+            - _Type_: `URI_COLLECTION`
+            - _Application Argument_: NULL
+            - _Is Required_: `True`
+            - _Required on Command Line_: `True`
+            - _Metadata_: NULL
         - For applications, STDOUT and STDERR will be automatically added for you.
 ![Screenshot](../img/gau-app-inputoutput1.png)
 ![Screenshot](../img/gau-app-inputoutput2.png)
 Image: Gaussian16 Inputs and Outputs
-</br></br>
-4. In Deployment tab
-    - New Deployment +'
-        - Select Expanse
-        - You can add SSH key which you would want to use to SSH to Expanse
-        - Share: Add groups and users you want to have access to this deployment. Meaning, who can submit Gaussian16 jobs to Expanse
-        - Application Executable Path: /home/gridchem/bin/rung09_with_chk_recovery.sh
-        - Application Parallelism Type: SERIAL </br>
+
+#####<h5 id="gau16dep">Add Gaussian16 Deployment</h5>
+1. **Settings** &rarr; **Application Catalog** &rarr; **Gaussian16** &rarr; **Deployment**
+2. In _Deployment_ tab
+    - Click _New Deployment +_
+        - Select _Expanse_
+        - _Share_ button: Add groups and users you want to have access to this deployment. Meaning, who can submit Gaussian16 jobs to Expanse
+        - _Application Executable Path_: `/home/gridchem/bin/rung09_with_chk_recovery.sh`
+        - _Application Parallelism Type_: `SERIAL`
         - Application Deployment Description: Gaussian16 Rev A.03
         - Module Load Commands: 
             - <pre><code>#SBATCH -N 1</code></pre>
diff --git a/docs/user-documentation/quick-start.md b/docs/user-documentation/quick-start.md
index 2adec27..4976bc4 100644
--- a/docs/user-documentation/quick-start.md
+++ b/docs/user-documentation/quick-start.md
@@ -8,51 +8,52 @@
 
 
 ##### <h5 id="addapplication">Create New Application</h5>
-1. Settings -> Application Catalog -> New Application
-2. In the first 'Details' tab provide the 
+1. **Settings** &rarr; **Application Catalog** &rarr; **New Application+**
+2. In the first _Details_ tab provide the 
     - Name (Mandatory)
     - Version (Optional)
     - Description (Optional)
 3. Upon saving, the next two tabs (Interface & Deployment) will be accessible. 
-4. The "Interface" tab is where you would add the application inputs, These are the required inputs for the application to execute.
-<br>For more information refer: <a href="/user-documentation/application-catalog" target="_blank">Application Catalog</a><br>
-<br></br>
+4. The _Interface_ tab is where you would add the application inputs, These are the required inputs for the application to execute.
 
-<ADD>-
-![Screenshot](../img/appinterfaceinput.png)
-Image: Application Input
+![Screenshot](../img/gau16appdetails.png)
+Image: Application Details
 
+![Screenshot](../img/gau16appinput.png)
+Image: Application Input Configuration
 
-5. The "Deployment" to add all the details required to execute the application on the remote resoruce. This includes
+5. The _Interface_ is also the place to add any output file you would want to make available for users to download.
+
+5. The _Deployment_ tab is to add all the details required to execute the application on the remote resource. This includes
     - application's executable path
     - commands to load any required modules 
     - Any environment variables
     - Pre and post job conditions
 6. Plus you can set the default queue and its properties for users. You would choose the default queue and add default number of nodes, CPUs and walltime.
 7. This is helpful for general user, as they can just use the default settings.
-
+8. For more information refer: <a href="/user-documentation/application-catalog" target="_blank">Application Catalog</a><br>
+   <br>
 <ADD>-
-![Screenshot](../img/appdeploy.png)
+![Screenshot](../img/gau16appdeploy.png)
 Image: Application Deployment 
 
 
 ##### <h5 id="chkexpstatus">Check Experiment Status</h5>
 1. This is one of the most used functions by gateway admins.
 2. When a gateway user need help with a particular job or need to monitor the gateway job submission rate and their statuses admins use this.
-3. Settings --> Experiment Statistics
+3. **Settings** &rarr; **Experiment Statistics** (Third option in the left icon menu)
 4. Here you can search a specific experiment with its job details using the experiment ID
 5. It will retrieve experiment details, job details, statuses and all tha task statuses in he experiment life cycle.
 6. It will also show you the job submission script generated to submit the job and input files and output files. 
-7. Most importantly, this will sho you if an error occurred the error messages and exactly which task failed.
+7. Most importantly, this will show you if an error occurred the error messages and exactly which task failed.
 8. This will also list job submission responses from the remote resource and that usually gives a clue if something went wrong with job at the remote resource.
 
 
-<ADD>-
 ![Screenshot](../img/expstat1.png)
 ![Screenshot](../img/expstat2.png)
 Image: Experiment Statistics for an Experiment
 
-9. Gateway admins can use "Experiment Statistics" to get an general idea of the experiment statuses.
+9. Gateway admins can use _**Experiment Statistics**_ to get an general idea of the experiment statuses.
 10. The page will show by default the total number of experiments and their statuses for the last 2 hours.
 11. Gateway admins can view experiment status for either 24 hours or for the last week or can give the period of choice using the calendar option. Can also use extra filters;
     - Application Name
@@ -62,7 +63,7 @@
 
 
 ##### <h5 id="manageusers">Manage Users</h5>
-1. Settings --> Manage Users
+1. **Settings** &rarr; **Manage Users**
 2. You can search gateway user sand add or remove them from gateway user groups.
 3. Gateway admins mostly use this to enable users on the gateway.
 4. As an gateway admin you can add users to any base group (admin, read-only-admin or general) 
