diff --git a/docs/quick_start.md b/docs/quick_start.md
index 9808e15..dc8df50 100644
--- a/docs/quick_start.md
+++ b/docs/quick_start.md
@@ -6,6 +6,9 @@
 This documentation assumes that you are using an Arm® *Ethos™-U55* NPU, it is configured to use 128 Multiply-Accumulate units, and is
 sharing SRAM with the Arm® *Cortex®-M55*.
 
+The FVP is also available via Arm Virtual Hardware (AVH) hosted on AWS. This quick start guide can also be executed on an AVH instance
+but requires creation of an AWS account and basic configuration outlined [here](./arm_virtual_hardware.md).
+
 To get started quickly, please follow these steps:
 
 1. First, verify that you have installed [the required prerequisites](sections/building.md#Build-prerequisites).
@@ -47,14 +50,19 @@
 5. Launch the project as explained in the following section: [Deployments](sections/deployment.md#Deployment). In quick
    start guide, we use the keyword spotting application and the FVP.
 
-    Point the generated `bin/ethos-u-kws.axf` file, from step four, to the FVP you downloaded when installing the
-    prerequisites. Now use the following command:
+    Change directory to generated cmake build folder which contains the .axf file output from step 4 in it's `bin`
+    subdirectory. Launch the application by passing the axf to the FVP you downloaded when installing the prerequisites. 
+    Alternatively, from the root directory add `<cmake-build-your_config>` to the path to the axf and use one of the
+    following commands:
 
     ```commandline
-    <path_to_FVP>/FVP_Corstone_SSE-300_Ethos-U55 -a ./bin/ethos-u-kws.axf
+   From auto-generated (or custom) build directory: 
+   <path_to_FVP>/FVP_Corstone_SSE-300_Ethos-U55 -a ./bin/ethos-u-kws.axf
+   From root directory:
+   <path_to_FVP>/FVP_Corstone_SSE-300_Ethos-U55 -a <cmake-build-your_config>/bin/ethos-u-kws.axf
     ```
 
-6. A telnet window is launched through where you can interact with the application and obtain performance figures.
+6. A telnet window is launched through which you can interact with the application and obtain performance figures.
 
 > **Note:** Executing the `build_default.py` script is equivalent to running the following commands:
 
diff --git a/docs/sections/arm_virtual_hardware.md b/docs/sections/arm_virtual_hardware.md
index a14f020..dcd5534 100644
--- a/docs/sections/arm_virtual_hardware.md
+++ b/docs/sections/arm_virtual_hardware.md
@@ -18,12 +18,20 @@
  2. Go to the AWS Marketplace and search for [Arm Virtual Hardware](https://aws.amazon.com/marketplace/pp/prodview-urbpq7yo5va7g).
  3. Subscribe to the Arm Virtual Hardware Amazon Machine Image.
  4. Launch the AWS instance.
- 5. If you want to access the Arm Virtual Hardware AWS instance via ssh, at the moment of creating the instance you would need to generate a *.pem* key.
- You could then access the AWS instance over ssh: `$ ssh -i <mykey.pem> ubuntu@<ec2-ip-address>`.
 
+
+ To access the Arm Virtual Hardware AWS instance via ssh, accept the prompt  to generate a *.pem* key while creating the instance or add it later.
+ You can then access the AWS instance over ssh: `$ ssh -i <mykey.pem> ubuntu@<ec2-ip-address>`. 
+ It may be necessary to change the permissions for mykey.pem with `$ chmod 400 mykey.pem`.
+
+
+### Useful Links
 Note that you can register to receive free AWS credits to use Arm Virtual Hardware from [here](https://www.arm.com/company/contact-us/virtual-hardware).
 
 You can find more information about Arm Virtual Hardware [here](https://arm-software.github.io/VHT/main/overview/html/index.html).
 
 Once you have access to the AWS instance, we recommend starting from the [quick start guide](../quick_start.md#Quick-start-example-ML-application) in order to get familiar
 with the ml-embedded-evaluation-kit. Note that on the AWS instance, the FVP is available under `/opt/FVP_Corstone_SSE-300`.
+
+In order to view the FVP window when launching on the AWS instance a VNC is required.
+See relevant section [here](https://aws.amazon.com/premiumsupport/knowledge-center/ec2-linux-2-install-gui/).
\ No newline at end of file
