diff --git a/VERSION b/VERSION
index a1fcd4a..a523090 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-2.11.0-dev3
+2.11.0-dev5
diff --git a/howto/code/linting.rst b/howto/code/linting.rst
index 1dcce7a..76f19ca 100644
--- a/howto/code/linting.rst
+++ b/howto/code/linting.rst
@@ -39,7 +39,7 @@
 Makefile help
 ~~~~~~~~~~~~~
 
-Individual Makefiles support a help targe that will display a list of
+Individual Makefiles support a help target that will display a list of
 targets and functionality supported.
 
 .. code:: bash
@@ -140,9 +140,9 @@
 
 Notes:
 
-- pylint --py3k options is no longer supported by v3.10+
+- pylint the --py3k option is no longer supported by v3.10+
 - lint-python target dependency will create a `python virtual env <https://wiki.opennetworking.org/display/JOEY/PythonVenv>`_
-- python 3.10+ requires `virtual env patching <https://gerrit.opencord.org/plugins/gitiles/voltha-docs/+/refs/heads/master/patches/>`_
+- python 3.10+ requires `virtual env patching <https://gerrit.opencord.org/plugins/gitiles/voltha-docs/+/refs/heads/master/patches/>`_ (dynamic, applied when needed).
 
 |
 
diff --git a/howto/release/charts/index.rst b/howto/release/charts/index.rst
new file mode 100644
index 0000000..8e79243
--- /dev/null
+++ b/howto/release/charts/index.rst
@@ -0,0 +1,15 @@
+RELEASE: voltha-helm-charts
+===========================
+
+- Repository `voltha-helm-charts <https://gerrit.opencord.org/plugins/gitiles/voltha-helm-charts/+/refs/heads/master>`_.
+- Modify `VERSION file <https://gerrit.opencord.org/plugins/gitiles/voltha-helm-charts/+/refs/heads/master/VERSION>`_.
+
+  - For release remove all version decorations: -dev, -SNAPSHOT
+
+- Release job will `publish to <https://gerrit.opencord.org/plugins/gitiles/cord-charts-repo/+/refs/heads/master>`_.
+
+- lint/syntax checking
+
+  - make test
+    - make lint-chart
+    - make lint-helm
diff --git a/howto/release/components/index.rst b/howto/release/components/index.rst
index a63e5dc..f13b276 100644
--- a/howto/release/components/index.rst
+++ b/howto/release/components/index.rst
@@ -1,17 +1,71 @@
-VOLTHA Components (wip)
-=======================
+VOLTHA Components
+=================
+
+ONOS
+----
+A few different processes exist for releasing the VOLTHA project and componets.
+Some are released through github using branches/tags/downloads.
+Others are released as packages on maven central.
+
+A jenkins job exists for releasing ONOS app
+- Maven central based release
+- Release process requires some manual steps.
 
 - `Jenkins Release Job <https://jenkins.opencord.org/job/onos-app-release/>`_
 
-    - Initiate a build for the target component, specify appVersion & apiVersion.
-    - Job will modify pom.xml and create pull requests based on version strings.
-    - Approve and merge the pom.xml changes.
-    - Next a jenkins job will publish changes to maven central.
+  - Initiate a build with parameters for the target component.
 
-       - A user login is required.
-       - `Wait until artifacts are published <https://search.maven.org/search?q=g:org.opencord>`_
-       - Verify status then manually initiate.
-    - `Visit <https://oss.sonatype.org>`_
-       - Select app to release.
-       - Click Show all versions.
-       - TODO: Girish to provide remaining steps.
+    - Use repository name not name of the app itself.
+    - Specify appVersion and apiVersion stored in the pom.xml file.
+
+  - Job will modify pom.xml and create pull requests based on version strings.
+
+    - NOTE: Two pull requests are created to modify pom.xml
+      - One for release (x.y.z)
+      - The second to revert to non-release version (x.(y+1).z-SNAPSHOT)
+      - Approve and merge the release version while performing the release.
+      - Once published approve the 2nd version change to re-attach the -SNAPSHOT suffix.
+
+    - Version x.y.z-SNAPSHOT is the default non-release version.
+    - Jenkins job will morph x.y.z-SNAPSHOT into x.y.z for the release.
+    - A gerrit pull request will be created under the release requestor(s) name.
+
+  - Approve the pom.xml pull request and merge.
+  - Merge will trigger (https://jenkins.opencord.org/job/maven-publish_sadis/ for sadis app, similar link for olt and other apps) that publish the artifact in the staging repo on oss.sonatype.org, you need to release it.
+  - Wait for build to complete
+  - Merge the patches here https://gerrit.opencord.org/q/owner:do-not-reply%2540opennetworking.org
+
+- Publish sonatype staging to maven central:
+
+  - Visit `https://oss.sonatype.org <https://oss.sonatype.org>`_
+  - Login with ONF credentials
+
+    - Search for org.opencord
+    - Click on "Staging repositories" (in the left side navigation)
+    - In the top right search for last part of the app name (eg: olt)
+    - Click release (top left bar, small button)
+    - `Wait until artifacts are published <https://search.maven.org/search?q=g:org.opencord>`_
+
+- Release all other apps/components (dependency hierarch):
+
+  - Iterate over individual components in order of increasing dependency volume.
+
+    - For ex olt depends on sadis
+    - Begin by releasing sadis first
+    - Once publishing has completed then olt can be released.
+
+  - Verify expected dependent version has been released.
+  - Modify pom.xml, update dep version(s) from x.z.y-SNAPSHOT to x.y.z
+  - Commit and submit.
+
+
+See Also
+========
+.. toctree::
+
+   onos_dependencies
+
+   voltctl/index
+   voltctl/install
+   voltctl/release
+   voltctl/see_also
diff --git a/howto/release/components/onos_dependencies.rst b/howto/release/components/onos_dependencies.rst
new file mode 100644
index 0000000..2b005a6
--- /dev/null
+++ b/howto/release/components/onos_dependencies.rst
@@ -0,0 +1,103 @@
+VOLTHA Components: ONOS Dependencies
+====================================
+
+ONOS components are maintained by a series of maven projects.
+Releasing individual components will require:
+
+- Build and release dependencies:
+
+  - Three jenkins jobs
+
+    - modify version in pom.xml for release (remove -SNAPSHOT)
+    - publish artifact to maven central.
+    - modify version in pom.xml for release (append -SNAPSHOT)
+
+  - Three manual operations:
+
+    - Review and approve pull request to create a pom.xml release version.
+    - Release artifact to maven central.
+    - Review and approve pull request to create a pom.xml non-release version.
+
+  - Long idle window(s)
+
+First submit nop jobs to verify the packages can build and test cleanly.
+Bulk update copyright notice dates or modify comments within sources and submit.
+
+Search pom.xml for package version string
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+component sadis
+
+Package version strings should contain the suffix -SNAPSHOT.
+
+.. code:: bash
+
+   aaa/pom.xml
+   aaa/api/pom.xml
+   aaa/app/pom.xml
+
+.. code:: XML
+
+   <artifactId>sadis</artifactId>
+   <version>5.9.0-SNAPSHOT</version>
+   <packaging>pom</packaging>
+
+   <properties>
+      <sadis.api.version>5.9.0-SNAPSHOT</sadis.api.version>
+   </properties>
+
+
+Next search pom.xml for dependent packages
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+component: aaa
+
+Dependent package version strings will be a released (non-SNAPSHOT) version.
+
+.. code:: XML
+
+   <properties>
+      <sadis.api.version>5.9.0</sadis.api.version>
+      <aaa.api.version>2.8.0-SNAPSHOT</aaa.api.version>
+   </properties>
+
+
+Dependency Hierarchy
+--------------------
+
+Components are built and released in version hiearchy order.
+
+sadis
+^^^^^
+
+- Verify -SNAPSHOT version string is present.
+- Dependent components: none
+- Scan pom.xml for version dependencies:
+
+.. code:: XML
+
+   <sadis.api.version>5.9.0-SNAPSHOT</sadis.api.version>
+
+
+aaa
+^^^
+
+- Verify -SNAPSHOT version string is present.
+- Dependent components: sadis
+- Modify pom.xml, update released version strings
+
+.. code:: XML
+
+   <sadis.api.version>5.9.0</sadis.api.version>
+
+
+igmpproxy
+^^^^^^^^^
+
+- Verify -SNAPSHOT version string is present.
+- Dependent components: aaa, bng, dhcpl2relay igmp, mcast, olt, sadis
+- Modify pom.xml, update released version strings
+
+.. code:: XML
+
+   <sadis.api.version>5.9.0</sadis.api.version>
diff --git a/howto/release/index.rst b/howto/release/index.rst
index d98e421..da347a5 100644
--- a/howto/release/index.rst
+++ b/howto/release/index.rst
@@ -3,6 +3,8 @@
 .. toctree::
    :maxdepth: 2
 
+   components/index
+
    voltctl/index
    voltctl/install
    voltctl/release
diff --git a/howto/release/preparation.rst b/howto/release/preparation.rst
new file mode 100644
index 0000000..0fcae23
--- /dev/null
+++ b/howto/release/preparation.rst
@@ -0,0 +1,7 @@
+Release Preparation
+===================
+
+As release date approaches and development slows visit the `jira versions dashboard <https://jira.opencord.org/projects/VOL?selectedItem=com.atlassian.jira.jira-projects-plugin%3Arelease-page&status=unreleased>`.
+- Create a new dashboard for the future release candidate.
+- Visit the current release candidate and move all unresolved tickets into the future desktop.
+- On release day click the [Release] button to close out the desktop.
diff --git a/release_notes/voltha_2.11.rst b/release_notes/voltha_2.11.rst
index 964bf28..237cbf7 100644
--- a/release_notes/voltha_2.11.rst
+++ b/release_notes/voltha_2.11.rst
@@ -96,16 +96,9 @@
 release:
 
 - Edgecore ASGVolt64 GPON OLT
-- Edgecore ASXVolt16 XGSGPON OLT
 - Radisys 3200G GPON OLT
 - Radisys 1600G GPON OLT
-- Radisys 1600X COMBO OLT
-- Adtran 6320X COMBO OLT
 - Zyxel SDA3016SS Combo OLT
-- Sercomm FG1000 GPON ONU
-- Sercomm Glasfaser GPON ONU
-- Edgecore 6712-32X Switch
-- Edgecore 7712-32X Switch
 
 
 Jira stories
@@ -182,22 +175,22 @@
      -
      -
    * - `aaa <https://gerrit.opencord.org/gitweb?p=aaa.git;a=summary>`_
+     - N/A
+     - ``2.8.0``
      -
-     - ``master: 2.7.0``
-     -
-     - `X <https://gerrit.opencord.org/plugins/gitiles/aaa/+/refs/tags/2.6.0>`__
+     - `X <https://gerrit.opencord.org/plugins/gitiles/aaa/+/refs/tags/2.8.0>`__
      -
    * - `dhcpl2relay <https://gerrit.opencord.org/gitweb?p=dhcpl2relay.git;a=summary>`_
      -
-     - ``2.6.0``
+     - ``2.8.0``
      -
-     -
+     - `X <https://gerrit.opencord.org/plugins/gitiles/dhcpl2relay/+/refs/tags/2.8.0>`__
      -
    * - `igmpproxy <https://gerrit.opencord.org/gitweb?p=igmpproxy.git;a=summary>`_
      -
-     - ``2.5.0``
+     - ``2.6.0``
      -
-     -
+     - `X <https://gerrit.opencord.org/plugins/gitiles/igmpproxy/+/refs/tags/2.6.0>`__
      -
    * - `kafka <https://gerrit.opencord.org/gitweb?p=kafka-onos.git;a=summary>`_
      -
@@ -207,9 +200,9 @@
      -
    * - `mcast <https://gerrit.opencord.org/gitweb?p=mcast.git;a=summary>`_
      -
-     - ``2.6.0``
+     - ``2.7.0``
      -
-     -
+     - `X <https://gerrit.opencord.org/plugins/gitiles/mcast/+/refs/tags/2.7.0>`__
      -
    * - `olt <https://gerrit.opencord.org/gitweb?p=olt.git;a=summary>`_
      -
@@ -219,9 +212,9 @@
      -
    * - `sadis <https://gerrit.opencord.org/gitweb?p=sadis.git;a=summary>`_
      -
-     - ``5.6.0``
+     - ``5.9.0``
      -
-     -
+     - `X <https://gerrit.opencord.org/plugins/gitiles/sadis/+/refs/tags/5.9.0>`__
      -
    * - `bng <https://gerrit.opencord.org/gitweb?p=bng.git;a=summary>`_
      -
@@ -286,9 +279,9 @@
      -
      - `X <https://github.com/opencord/bbsim-sadis-server/releases/tag/v0.3.4>`__
    * - `ofagent-go <https://gerrit.opencord.org/gitweb?p=ofagent-go.git;a=tree>`_
-     - ``2.11.3``
      - ``2.1.2``
-     -
+     - ``2.1.2``
+     - ``2.11.3``
      -
      - `X <https://github.com/opencord/ofagent-go>`__
    * - `openolt agent <https://gerrit.opencord.org/gitweb?p=openolt.git;a=tree>`_
