diff --git a/app/multi-server/controllers/index-controller.html b/app/multi-server/controllers/index-controller.html
deleted file mode 100644
index cf9daa4..0000000
--- a/app/multi-server/controllers/index-controller.html
+++ /dev/null
@@ -1,150 +0,0 @@
-<loader loading="loading"></loader>
-<div id="multi-server">
-	<div class="row column">
-		<h1>All servers</h1>
-	</div>
-	<section class="row column">
-		<div class="page-header">
-			<h2 class="inline h4">Displaying all auto-discovered and manually added servers</h2>
-			<a class="inline float-right" ng-click="multi_server_add = !multi_server_add"><span class="icon icon__plus"></span>Add a server</a>
-		</div>
-	</section>
-	<section class="row column">
-		<!-- search -->
-		<p class="content-label" aria-label="sensors filter">Filter servers</p>
-		<div class="content__search">
-			<label for="content__search-input">Multi server search</label>
-			<input id="content__search-input" type="text" ng-model="customSearch" ng-keydown="doSearchOnEnter($event)"/>
-			<div class="search-submit__wrapper">
-				<button class="clear-input" ng-click="clear()">&#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="" class="row column">
-		<div class="row column header-row">
-			<div class="column large-12 header__actions-bar">
-				<div class="inline multi-server__title">Server name<span class="sort-heading"></span></div>
-				<div class="inline multi-server__col">BMC IP address<span class="sort-heading"></span></div>
-				<div class="inline multi-server__col">Model number<span class="sort-heading sort-down"></span></div>
-				<div class="inline multi-server__col narrow-col">Power<span class="sort-heading sort-up"></span></div>
-				<div class="inline multi-server__col narrow-col">Status<span class="sort-heading"></span></div>
-			</div>
-		</div>
-		<!-- server -->
-		<div class="multi-server__col-row">
-			<div class="inline multi-server__title">IBM Power Witherspoon 2 (current)</div>
-			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">BMC IP address</span>9.3.111.222
-			</div>
-			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">Model number</span>8335-GTC
-			</div>
-			<div class="inline multi-server__col narrow-col bold">
-				<span class="multi-server__label">Power</span><span class="icon icon__off"></span>Off
-			</div>
-			<div class="inline multi-server__col narrow-col bold">
-				<span class="multi-server__label">Status</span><span class="icon icon__warning" ng-class="{'icon__critical': sensor.status == 'critical', 'icon__warning': sensor.status == 'warning', 'icon__normal': sensor.status == 'normal'}" aria-label="multi.status"></span>Warning
-			</div>
-		</div>
-		<!-- server -->
-		<div class="multi-server__col-row">
-			<div class="inline multi-server__title">IBM Power Witherspoon 6</div>
-			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">BMC IP address</span>9.3.111.222
-			</div>
-			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">Model number</span>8335-GTC
-			</div>
-			<div class="inline multi-server__col narrow-col bold">
-				<span class="multi-server__label">Power</span><span class="icon icon__good"></span>On
-			</div>
-			<div class="inline multi-server__col narrow-col bold">
-				<span class="multi-server__label">Status</span><span class="icon icon__good" ng-class="{'icon__critical': sensor.status == 'critical', 'icon__warning': sensor.status == 'warning', 'icon__normal': sensor.status == 'normal'}" aria-label="multi.status"></span>Good
-			</div>
-		</div>
-		<!-- server -->
-		<div class="multi-server__col-row">
-			<div class="inline multi-server__title">IBM Power Witherspoon 4</div>
-			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">BMC IP address</span>9.3.111.222
-			</div>
-			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">Model number</span>8335-GTC
-			</div>
-			<div class="inline multi-server__col narrow-col bold">
-				<span class="multi-server__label">Power</span><span class="icon icon__good"></span>On
-			</div>
-			<div class="inline multi-server__col narrow-col bold">
-				<span class="multi-server__label">Status</span><span class="icon icon__good" ng-class="{'icon__critical': sensor.status == 'critical', 'icon__warning': sensor.status == 'warning', 'icon__normal': sensor.status == 'normal'}" aria-label="multi.status"></span>Good
-			</div>
-		</div>
-		<!-- server -->
-		<div class="multi-server__col-row">
-			<div class="inline multi-server__title">Server 100023476 ligula sed magna dictum porta. Curabitur arcu erat, accumsan id imperdiet et, porttitor at sem</div>
-			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">BMC IP address</span>9.3.111.222
-			</div>
-			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">Model number</span>8335-GTC
-			</div>
-			<div class="inline multi-server__col narrow-col bold">
-				<span class="multi-server__label">Power</span><span class="icon icon__good"></span>On
-			</div>
-			<div class="inline multi-server__col narrow-col bold">
-				<span class="multi-server__label">Status</span><span class="icon icon__critical" ng-class="{'icon__critical': sensor.status == 'critical', 'icon__warning': sensor.status == 'warning', 'icon__normal': sensor.status == 'normal'}" aria-label="multi.status"></span>Critical
-			</div>
-		</div>
-		<!-- server -->
-		<div class="multi-server__col-row">
-			<div class="inline multi-server__title">Server 100023476</div>
-			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">BMC IP address</span>9.3.111.222
-			</div>
-			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">Model number</span>8335-GTC
-			</div>
-			<div class="inline multi-server__col narrow-col bold">
-				<span class="multi-server__label">Power</span><span class="icon icon__standby"></span>Standby
-			</div>
-			<div class="inline multi-server__col narrow-col bold">
-				<span class="multi-server__label">Status</span><span class="icon icon__good" ng-class="{'icon__critical': sensor.status == 'critical', 'icon__warning': sensor.status == 'warning', 'icon__normal': sensor.status == 'normal'}" aria-label="multi.status"></span>Good
-			</div>
-		</div>
-	</section>
-</div>
-
-<!-- add server modal -->
-<section class="modal" aria-hidden="true" aria-labelledby="modalTitle" aria-describedby="modalDescription" role="dialog" ng-class="{'active': multi_server_add}">
-	<div class="modal__multi-add" role="document">
-		<div class="screen-reader-offscreen modal-description">To manually add a server that is not discovered automatically, provide either the BMC IP address or hostname and login credentials for its BMC</div><!-- accessibility only; used for screen readers -->
-		<div class="page-header ">
-			<h1 class="modal-title h4"><span class="icon icon__info"><svg xmlns="http://www.w3.org/2000/svg"
-					viewBox="0 0 32 32"><path
-					d="M18 14h-6v2h1v6h-2v2h8v-2h-2z"/><circle cx="16" cy="10" r="2"/><path
-					d="M16 2C8.269 2 2 8.269 2 16s6.269 14 14 14 14-6.269 14-14S23.731 2 16 2zm0 26C9.383 28 4 22.617 4 16S9.383 4 16 4s12 5.383 12 12-5.383 12-12 12z"/></svg></span>
-				Add a server
-			</h1>
-		</div>
-		<form id="multi-server_add-form" class="multi-server__add-form" action="">
-			<div class="modal__content row">
-				<div class="column large-12">
-					<label for="multi-server__host">Hostname</label>
-					<input id="multi-server__host" type="text" autofocus/>
-				</div>
-				<div class="column large-6">
-					<label for="username">Username</label>
-					<input type="text" id="username" name="username" ng-model="username" ng-class="{error: error}" ng-keydown="tryLogin(username, password, $event)" ng-disabled="dataService.loading">
-				</div>
-				<div class="column large-6">
-					<label for="password">Password</label>
-					<input type="password" id="password" name="password" class="" ng-model="password" ng-keydown="tryLogin(username, password, $event)" ng-disabled="dataService.loading">
-				</div>
-			</div>
-			<label class="control-check">
-				<input id="multi-server__add-view" type="checkbox" name="events__check-all" ng-model="all" />
-				<span class="control__indicator"></span>
-				<span for="multi-server__add-view" class="inline">View this server once added</span>
-			</label>
-			<div class="modal__button-wrapper">
-				<button class="inline btn-secondary" ng-click="multi_server_add=false;">Cancel</button>
-				<button class="inline btn-primary" ng-click="">Add</button>
-			</div>
-			<p class="login__error-msg" role="alert" ng-if="error">Incorrect username or password</p>
-			<p class="login__error-msg" role="alert" ng-if="server_unreachable">Server unreachable</p>
-		</form>
-	</div>
-</section>
-<div class="modal-overlay" tabindex="-1" ng-class="{'active': (multi_server_add)}"></div>
\ No newline at end of file
diff --git a/app/multi-server/controllers/index-controller.js b/app/multi-server/controllers/index-controller.js
deleted file mode 100644
index 59d3488..0000000
--- a/app/multi-server/controllers/index-controller.js
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * Controller for index
- *
- * @module app/multi-server
- * @exports indexController
- * @name indexController
- * @version 0.1.0
- */
-
-window.angular && (function (angular) {
-    'use strict';
-
-    angular
-        .module('app.overview')
-        .controller('indexController', [
-            '$scope', 
-            '$window', 
-            'APIUtils', 
-            'dataService',
-            function($scope, $window, APIUtils, dataService){
-                $scope.dataService = dataService;
-                $scope.loading = false;
-
-            }
-        ]
-    );
-
-})(angular);
\ No newline at end of file
diff --git a/app/multi-server/controllers/multi-server-controller.html b/app/multi-server/controllers/multi-server-controller.html
index b4be90e..cf9daa4 100644
--- a/app/multi-server/controllers/multi-server-controller.html
+++ b/app/multi-server/controllers/multi-server-controller.html
@@ -1,6 +1,150 @@
 <loader loading="loading"></loader>
-<div class="overview">
+<div id="multi-server">
 	<div class="row column">
-		<h1 class="inline">Multi Server</h1>
+		<h1>All servers</h1>
 	</div>
-</div>
\ No newline at end of file
+	<section class="row column">
+		<div class="page-header">
+			<h2 class="inline h4">Displaying all auto-discovered and manually added servers</h2>
+			<a class="inline float-right" ng-click="multi_server_add = !multi_server_add"><span class="icon icon__plus"></span>Add a server</a>
+		</div>
+	</section>
+	<section class="row column">
+		<!-- search -->
+		<p class="content-label" aria-label="sensors filter">Filter servers</p>
+		<div class="content__search">
+			<label for="content__search-input">Multi server search</label>
+			<input id="content__search-input" type="text" ng-model="customSearch" ng-keydown="doSearchOnEnter($event)"/>
+			<div class="search-submit__wrapper">
+				<button class="clear-input" ng-click="clear()">&#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="" class="row column">
+		<div class="row column header-row">
+			<div class="column large-12 header__actions-bar">
+				<div class="inline multi-server__title">Server name<span class="sort-heading"></span></div>
+				<div class="inline multi-server__col">BMC IP address<span class="sort-heading"></span></div>
+				<div class="inline multi-server__col">Model number<span class="sort-heading sort-down"></span></div>
+				<div class="inline multi-server__col narrow-col">Power<span class="sort-heading sort-up"></span></div>
+				<div class="inline multi-server__col narrow-col">Status<span class="sort-heading"></span></div>
+			</div>
+		</div>
+		<!-- server -->
+		<div class="multi-server__col-row">
+			<div class="inline multi-server__title">IBM Power Witherspoon 2 (current)</div>
+			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">BMC IP address</span>9.3.111.222
+			</div>
+			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">Model number</span>8335-GTC
+			</div>
+			<div class="inline multi-server__col narrow-col bold">
+				<span class="multi-server__label">Power</span><span class="icon icon__off"></span>Off
+			</div>
+			<div class="inline multi-server__col narrow-col bold">
+				<span class="multi-server__label">Status</span><span class="icon icon__warning" ng-class="{'icon__critical': sensor.status == 'critical', 'icon__warning': sensor.status == 'warning', 'icon__normal': sensor.status == 'normal'}" aria-label="multi.status"></span>Warning
+			</div>
+		</div>
+		<!-- server -->
+		<div class="multi-server__col-row">
+			<div class="inline multi-server__title">IBM Power Witherspoon 6</div>
+			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">BMC IP address</span>9.3.111.222
+			</div>
+			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">Model number</span>8335-GTC
+			</div>
+			<div class="inline multi-server__col narrow-col bold">
+				<span class="multi-server__label">Power</span><span class="icon icon__good"></span>On
+			</div>
+			<div class="inline multi-server__col narrow-col bold">
+				<span class="multi-server__label">Status</span><span class="icon icon__good" ng-class="{'icon__critical': sensor.status == 'critical', 'icon__warning': sensor.status == 'warning', 'icon__normal': sensor.status == 'normal'}" aria-label="multi.status"></span>Good
+			</div>
+		</div>
+		<!-- server -->
+		<div class="multi-server__col-row">
+			<div class="inline multi-server__title">IBM Power Witherspoon 4</div>
+			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">BMC IP address</span>9.3.111.222
+			</div>
+			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">Model number</span>8335-GTC
+			</div>
+			<div class="inline multi-server__col narrow-col bold">
+				<span class="multi-server__label">Power</span><span class="icon icon__good"></span>On
+			</div>
+			<div class="inline multi-server__col narrow-col bold">
+				<span class="multi-server__label">Status</span><span class="icon icon__good" ng-class="{'icon__critical': sensor.status == 'critical', 'icon__warning': sensor.status == 'warning', 'icon__normal': sensor.status == 'normal'}" aria-label="multi.status"></span>Good
+			</div>
+		</div>
+		<!-- server -->
+		<div class="multi-server__col-row">
+			<div class="inline multi-server__title">Server 100023476 ligula sed magna dictum porta. Curabitur arcu erat, accumsan id imperdiet et, porttitor at sem</div>
+			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">BMC IP address</span>9.3.111.222
+			</div>
+			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">Model number</span>8335-GTC
+			</div>
+			<div class="inline multi-server__col narrow-col bold">
+				<span class="multi-server__label">Power</span><span class="icon icon__good"></span>On
+			</div>
+			<div class="inline multi-server__col narrow-col bold">
+				<span class="multi-server__label">Status</span><span class="icon icon__critical" ng-class="{'icon__critical': sensor.status == 'critical', 'icon__warning': sensor.status == 'warning', 'icon__normal': sensor.status == 'normal'}" aria-label="multi.status"></span>Critical
+			</div>
+		</div>
+		<!-- server -->
+		<div class="multi-server__col-row">
+			<div class="inline multi-server__title">Server 100023476</div>
+			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">BMC IP address</span>9.3.111.222
+			</div>
+			<div class="inline multi-server__col courier-bold"><span class="multi-server__label">Model number</span>8335-GTC
+			</div>
+			<div class="inline multi-server__col narrow-col bold">
+				<span class="multi-server__label">Power</span><span class="icon icon__standby"></span>Standby
+			</div>
+			<div class="inline multi-server__col narrow-col bold">
+				<span class="multi-server__label">Status</span><span class="icon icon__good" ng-class="{'icon__critical': sensor.status == 'critical', 'icon__warning': sensor.status == 'warning', 'icon__normal': sensor.status == 'normal'}" aria-label="multi.status"></span>Good
+			</div>
+		</div>
+	</section>
+</div>
+
+<!-- add server modal -->
+<section class="modal" aria-hidden="true" aria-labelledby="modalTitle" aria-describedby="modalDescription" role="dialog" ng-class="{'active': multi_server_add}">
+	<div class="modal__multi-add" role="document">
+		<div class="screen-reader-offscreen modal-description">To manually add a server that is not discovered automatically, provide either the BMC IP address or hostname and login credentials for its BMC</div><!-- accessibility only; used for screen readers -->
+		<div class="page-header ">
+			<h1 class="modal-title h4"><span class="icon icon__info"><svg xmlns="http://www.w3.org/2000/svg"
+					viewBox="0 0 32 32"><path
+					d="M18 14h-6v2h1v6h-2v2h8v-2h-2z"/><circle cx="16" cy="10" r="2"/><path
+					d="M16 2C8.269 2 2 8.269 2 16s6.269 14 14 14 14-6.269 14-14S23.731 2 16 2zm0 26C9.383 28 4 22.617 4 16S9.383 4 16 4s12 5.383 12 12-5.383 12-12 12z"/></svg></span>
+				Add a server
+			</h1>
+		</div>
+		<form id="multi-server_add-form" class="multi-server__add-form" action="">
+			<div class="modal__content row">
+				<div class="column large-12">
+					<label for="multi-server__host">Hostname</label>
+					<input id="multi-server__host" type="text" autofocus/>
+				</div>
+				<div class="column large-6">
+					<label for="username">Username</label>
+					<input type="text" id="username" name="username" ng-model="username" ng-class="{error: error}" ng-keydown="tryLogin(username, password, $event)" ng-disabled="dataService.loading">
+				</div>
+				<div class="column large-6">
+					<label for="password">Password</label>
+					<input type="password" id="password" name="password" class="" ng-model="password" ng-keydown="tryLogin(username, password, $event)" ng-disabled="dataService.loading">
+				</div>
+			</div>
+			<label class="control-check">
+				<input id="multi-server__add-view" type="checkbox" name="events__check-all" ng-model="all" />
+				<span class="control__indicator"></span>
+				<span for="multi-server__add-view" class="inline">View this server once added</span>
+			</label>
+			<div class="modal__button-wrapper">
+				<button class="inline btn-secondary" ng-click="multi_server_add=false;">Cancel</button>
+				<button class="inline btn-primary" ng-click="">Add</button>
+			</div>
+			<p class="login__error-msg" role="alert" ng-if="error">Incorrect username or password</p>
+			<p class="login__error-msg" role="alert" ng-if="server_unreachable">Server unreachable</p>
+		</form>
+	</div>
+</section>
+<div class="modal-overlay" tabindex="-1" ng-class="{'active': (multi_server_add)}"></div>
\ No newline at end of file
