diff --git a/app/server-health/controllers/inventory-overview-controller.html b/app/server-health/controllers/inventory-overview-controller.html
index 9af8166..597a664 100644
--- a/app/server-health/controllers/inventory-overview-controller.html
+++ b/app/server-health/controllers/inventory-overview-controller.html
@@ -8,7 +8,7 @@
 
 		</div>
 	</div>
-	<section class="row column" aria-label="hardware filtering">
+	<section class="row column">
 		<!-- search -->
 		<p class="content-label" aria-label="hardware filter">Filter hardware components</p>
 		<div class="content__search">
@@ -18,10 +18,12 @@
 				<button class="clear-input" ng-click="customSearch = ''">&#10005;</button>
 				<input id="content__search-submit" type="submit" class="btn btn-primary content__search-submit" value="Filter" ng-click="doSearchOnClick()"/>
 			</div>
+
 		</div>
+
 	</section>
 	<!-- end search -->
-	<section id="inventory-categories" class="row column" aria-label="hardware list">
+	<section id="inventory-categories" class="row column">
 		<div class="row column header-row">
 			<div class="column large-12 header__actions-bar">
 				<div class="inline inventory__heading inventory__device-col">Hardware</div>
@@ -33,7 +35,7 @@
 			<p class="inline inventory__device-col">{{inventory.title}}</p>
 			<p class="inline inventory__function-col"></p>
 			<p class="inline inventory__assoc-event"><!--<a href="#/server-health/event-log">View 3 events</a>--></p>
-			<span class="accord-trigger button float-right" ng-class="{'active': inventory.expanded}"></span>
+			<button class="accord-trigger float-right" ng-class="{'active': inventory.expanded}"></button>
 			<div class="row inventory__metadata" ng-class="{'active': inventory.expanded}" ng-click="$event.stopPropagation()">
 				<div class="column large-9 no-padding">
 					<div  ng-repeat="item in inventory.items" class="inline inventory__metadata-block">
@@ -43,6 +45,7 @@
 				</div>
 				<div class="column large-3 no-padding" ng-show="inventory.sub_components.length">
 					<div class="inventory__metadata-scroll show-scroll"> <!-- If content overflows; add 'show-scroll' class via JS to force visible scrollbar in webkit browsers-->
+						<div class="content-label">Subcomponents</div>
 						<div ng-repeat="sub_component in inventory.sub_components" class="inline inventory__metadata-block">
 							<p class="courier-bold">{{sub_component.title}}<span class="icon icon__warning" ng-if="sub_component.Present"></span></p>
 						</div>
diff --git a/app/server-health/controllers/log-controller.html b/app/server-health/controllers/log-controller.html
index fce664d..3db7bd9 100644
--- a/app/server-health/controllers/log-controller.html
+++ b/app/server-health/controllers/log-controller.html
@@ -3,7 +3,7 @@
     <div class="row column">
         <h1>Event log</h1>
     </div>
-    <section class="row column" aria-label="page header">
+    <section class="row column">
         <div class="page-header">
             <h2 class="inline h4">All events from the BMC</h2>
             <div class="event-log__timezone inline float-right">
@@ -22,26 +22,26 @@
         </div>
     </section>
     <!-- Filters -->
-    <section class="row column" aria-label="event log search">
+    <section class="row column">
         <!-- search -->
         <log-search-control></log-search-control>
         <!-- filters -->
         <log-filter></log-filter>
     </section> <!-- end filter -->
 
-    <section id="event-log__events" class="row column" aria-label="event log events">
+    <section id="event-log__events" class="row column">
         <div id="event__actions-bar" class="row header__actions-bar no-margin">
             <div class="column small-1 large-1 event-log__col-check">
                 <label class="control-check">
                     <input type="checkbox" name="events__check-all" ng-model="all" ng-checked="(logs|filter:{selected: true}).length == logs.length"/>
-                    <span class="control__indicator accessible-text">select all log events</span>
+                    <span class="control__indicator"></span>
                 </label>
             </div>
             <div class="column small-11 end col-logged-events">
                 <!-- top bar confirmation - ADD ACTIVE CLASS TO DISPLAY-->
                 <div class="inline__confirm event__confirm" ng-class="{active: confirm}">
                     <div class="inline__confirm-message">
-                        <p class="h3"><i></i>Are you sure you want to <strong class="ng-binding">delete {{selectedEvents.length}} events</strong>?
+                        <p class="h3"><i></i>Are you sure you want to <strong class="ng-binding">delete {{selectedEvents.length}} logs</strong>?
                         </p>
                     </div>
                     <div class="inline__confirm-buttons">
@@ -57,7 +57,7 @@
                         <img class="event__icon" src="assets/images/icon-trashcan-white.svg" alt="">Delete
                     </button>
                     <button class="inline btn-resolve" ng-class="{'disabled': ((selectedEvents|unResolvedCount) == 0)}" ng-show="selectedEvents.length || all" ng-click="resolve()" ng-disabled="(selectedEvents|unResolvedCount) == 0">
-                        <img class="event__icon" src="assets/images/icon-check-white.svg" alt="">Mark as resolved
+                        <img class="event__icon" src="assets/images/icon-checklist-white.svg" alt="">Mark as resolved
                     </button>
                     <a ng-href="data:text/json;charset=utf-8,{{export_data}}" class="inline btn-export"  download="{{export_name}}" ng-show="selectedEvents.length || all">Export</a>
                 </div>
@@ -70,4 +70,4 @@
         </log-event>
     </section>
     <dir-pagination-controls template-url="common/directives/dirPagination.tpl.html"></dir-pagination-controls> 
-</div> <!-- end event log -->
\ No newline at end of file
+</div> <!-- end event log -->
diff --git a/app/server-health/controllers/sensors-overview-controller.html b/app/server-health/controllers/sensors-overview-controller.html
index 8ee8d8a..95631e8 100644
--- a/app/server-health/controllers/sensors-overview-controller.html
+++ b/app/server-health/controllers/sensors-overview-controller.html
@@ -19,6 +19,7 @@
 				<button class="clear-input" ng-click="customSearch = ''">&#10005;</button>
 				<input id="content__search-submit" type="submit" class="btn btn-primary content__search-submit" value="Filter" ng-click="doSearchOnClick()"/>
 			</div>
+
 		</div>
 		<div class="toggle-filter">
 			<p class="content-label">FILTER BY SEVERITY</p>
