diff --git a/website/templates/html/navbar.html b/website/templates/html/navbar.html
index 8112499..4663a2f 100644
--- a/website/templates/html/navbar.html
+++ b/website/templates/html/navbar.html
@@ -47,9 +47,6 @@
 						{% endif %}
 					{% endfor %}
 				</ul>
-				<ul class="nav pull-right">
-					<li id="login-topbar-item"><a href="login">Login</a></li>
-				</ul>
 			</div>
 		</div>
 	</div>
diff --git a/website/templates/html/outer.html b/website/templates/html/outer.html
index f7296e4..207c124 100644
--- a/website/templates/html/outer.html
+++ b/website/templates/html/outer.html
@@ -4,6 +4,10 @@
 	<header>
 	</header>
 	<div class="container">
+		<div class="pull-right" style="margin:4px;" id="user-tools">
+			<a id="login-link" href="login">Login</a>
+		</div>
+		<div class="clearfix"></div>
 		{% if banner_html %}<div class="row" style="margin-top: 30px;">
 			<div class="span12">{{ banner_html }}</div>
 		</div>{% endif %}
