diff --git a/SUMMARY.md b/SUMMARY.md
index c1d9619..ee787a8 100644
--- a/SUMMARY.md
+++ b/SUMMARY.md
@@ -17,8 +17,6 @@
                 * [Single Node](prereqs/k8s-single-node.md)
                 * [Multi-Node](prereqs/k8s-multi-node.md)
             * [Helm](prereqs/helm.md)
-            * [Optional Packages](prereqs/optional.md)
-                * [OpenStack](prereqs/openstack-helm.md)
     * [Fabric Software Setup](fabric-setup.md)
     * [Install Platform](platform.md)
     * [Install Profile](profiles.md)
@@ -110,6 +108,7 @@
     * [Kafka](charts/kafka.md)
     * [Base Kubernetes](charts/base-kubernetes.md)
     * [Base OpenStack](charts/base-openstack.md)
+        * [OpenStack](prereqs/openstack-helm.md)
         * [VTN Setup](prereqs/vtn-setup.md)
     * [R-CORD](charts/rcord.md)
     * [M-CORD](charts/mcord.md)
diff --git a/prereqs/openstack-helm.md b/prereqs/openstack-helm.md
index aefa6f1..b3941c7 100644
--- a/prereqs/openstack-helm.md
+++ b/prereqs/openstack-helm.md
@@ -4,7 +4,8 @@
 project can be used to install a set of Kubernetes nodes as OpenStack
 compute nodes, with the OpenStack control services (nova, neutron,
 keystone, glance, etc.) running as containers on Kubernetes. This is
-necessary, for example, to run the M-CORD profile.
+an easy way to bring up an OpenStack cluster that can be controlled
+by loading the [Base OpenStack](../charts/base-openstack.md) chart.
 
 Instructions for installing `openstack-helm` on a single node or a
 multi-node cluster can be found at
diff --git a/prereqs/optional.md b/prereqs/optional.md
deleted file mode 100644
index e19dbe3..0000000
--- a/prereqs/optional.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Optional Packages
-
-Although not required, you may want to install the following packages:
-
-* **OpenStack:** If you need to include OpenStack in your deployment,
-  so you can bring up VMs on your POD, you will need to following the
-  [OpenStack deployment](openstack-helm.md) guide.
diff --git a/prereqs/software.md b/prereqs/software.md
index 03b0a07..971a296 100644
--- a/prereqs/software.md
+++ b/prereqs/software.md
@@ -4,11 +4,3 @@
 pretty much any Kubernetes environment. It is your choice how
 to install Kubernetes, although this section describes automation
 scripts we have found useful.
-
-> **Note:** M-CORD is the exception since its components still depend on
-> OpenStack, which is in turn deployed as a set of Kubernetes containers
-> using the [openstack-helm](https://github.com/openstack/openstack-helm)
-> project. Successfully installing the OpenStack Helm charts requires
-> some additional system configuration besides just installing Kubernetes
-> and Helm. You can find more informations about this in the
-> [OpenStack Support](./openstack-helm.md) installation section.
