diff --git a/apps/metrics/app.xml b/apps/metrics/app.xml
index dc9ce3e..f1137aa 100644
--- a/apps/metrics/app.xml
+++ b/apps/metrics/app.xml
@@ -15,6 +15,6 @@
   ~ limitations under the License.
   -->
 <app name="org.onosproject.metrics" origin="ON.Lab" version="1.2.0"
-        features="onos-app-config">
+        features="onos-app-metrics">
     <description>ONOS performance metrics collection</description>
 </app>
diff --git a/apps/test/election/app.xml b/apps/test/election/app.xml
index 9d604f6..0db483d 100644
--- a/apps/test/election/app.xml
+++ b/apps/test/election/app.xml
@@ -15,6 +15,6 @@
   ~ limitations under the License.
   -->
 <app name="org.onosproject.election" origin="ON.Lab" version="1.2.0"
-        features="onos-app-metrics">
+        features="onos-app-election">
     <description>ONOS master election test application</description>
 </app>
