diff --git a/erpnext/website/templates/css/blog.css b/erpnext/website/templates/css/blog.css
new file mode 100644
index 0000000..199df1a
--- /dev/null
+++ b/erpnext/website/templates/css/blog.css
@@ -0,0 +1,7 @@
+	<style>
+		h2 > a, h2 > a:link, h2 > a:visited, h2 > a:active,
+		h2 > a:hover, h2 > a:focus {
+			text-decoration: none;
+			color: inherit;
+		}
+	</style>
\ No newline at end of file
diff --git a/erpnext/website/templates/css/blog_page.css b/erpnext/website/templates/css/blog_page.css
new file mode 100644
index 0000000..928b8ac
--- /dev/null
+++ b/erpnext/website/templates/css/blog_page.css
@@ -0,0 +1,9 @@
+	<style>
+		.comment-title {
+			color:#777;
+		}
+		
+		.comment-content {
+			margin-left: 20px;
+		}
+	</style>
\ No newline at end of file
diff --git a/erpnext/website/templates/css/login.css b/erpnext/website/templates/css/login.css
new file mode 100644
index 0000000..4e3e4b1
--- /dev/null
+++ b/erpnext/website/templates/css/login.css
@@ -0,0 +1,10 @@
+	<style>
+		#login_wrapper {
+			width: 300px !important;
+			margin: 20px auto;
+		}
+
+		.login-banner {
+			margin-bottom: 20px;
+		}
+	</style>
\ No newline at end of file
diff --git a/erpnext/website/templates/css/product_page.css b/erpnext/website/templates/css/product_page.css
new file mode 100644
index 0000000..2708625
--- /dev/null
+++ b/erpnext/website/templates/css/product_page.css
@@ -0,0 +1,34 @@
+	<style>
+		.web-long-description {
+			font-size: 18px;
+			line-height: 200%;
+		}
+		.product-page-content {
+			float: left;
+		}
+		/* product page image css */
+		.product-page-content img {
+			max-width: 100%;
+		}
+		
+		/* similar products listing */
+		.similar-products .img-area img {
+			max-width: 55px;
+			max-height: 55px;
+		}
+		
+		.similar-products .img-area {
+			float: left;
+			width: 30%;
+			margin-top: 0.3em;
+		}
+		
+		.similar-product-description {
+			float: left;
+			width: 70%;
+		}
+		
+		.similar-product-description span {
+			font-size: 12px;
+		}
+	</style>
\ No newline at end of file
diff --git a/erpnext/website/templates/css/products.css b/erpnext/website/templates/css/products.css
new file mode 100644
index 0000000..73289c4
--- /dev/null
+++ b/erpnext/website/templates/css/products.css
@@ -0,0 +1,11 @@
+	<style>
+		.img-area {
+			float:left;
+			width: 115px;
+		}
+		
+		.product-list-description {
+			float:left;
+			width: 400px;
+		}
+	</style>
\ No newline at end of file
diff --git a/erpnext/website/templates/base.html b/erpnext/website/templates/html/base.html
similarity index 100%
rename from erpnext/website/templates/base.html
rename to erpnext/website/templates/html/base.html
diff --git a/erpnext/website/templates/blog/blog.html b/erpnext/website/templates/html/blog_page.html
similarity index 72%
rename from erpnext/website/templates/blog/blog.html
rename to erpnext/website/templates/html/blog_page.html
index d87b128..c07706a 100644
--- a/erpnext/website/templates/blog/blog.html
+++ b/erpnext/website/templates/html/blog_page.html
@@ -1,26 +1,41 @@
-{% extends "blog/blog.js" %}
+{% extends "html/page.html" %}
+
+{% block javascript %}
+	{% include "js/blog_page.js" %}
+{% endblock %}
+
+{% block css %}
+	{% include "css/blog_page.css" %}
+{% endblock %}
 
 {% block content %}
 	<div class="layout-wrapper layout-wrapper-background">
 		<div class="web-content" id="blog-{{ name }}">
 
 			<div class="layout-main-section">
+				
 				<h2>{{ title }}</h2>
+
+				<!-- begin blog content -->
 				<div class="help">By {{ full_name }} on {{ updated }}</div>
 				<br>
 				{{ content_html }}
 				<hr>
 				<h3>Comments</h3><br>
 				<div class="blog-comments">
+					
+					{% if not comment_list %}
 					<div class="no-result help hide">
 						<p>Be the first one to comment</p>
 						<br />
 					</div>
-
-					{% include 'blog/comment.html' %}
-
-					<button class="btn add-comment">Add Comment</button>
+					{% endif %}
+					
+					{% include 'html/comment.html' %}
 				</div>
+				<!-- end blog content -->
+				
+				<button class="btn add-comment">Add Comment</button>
 			</div>
 
 			<div class="layout-side-section">
@@ -39,21 +54,4 @@
 			<div style="clear: both"></div>
 		</div>
 	</div>
-{% endblock %}
-
-{% block css %}
-	<style>
-		.comment-title {
-			color:#777;
-		}
-		
-		.comment-content {
-			margin-left: 20px;
-		}
-		
-/*		.comment-row {
-			padding: 5px 0px;
-		}
-*/	</style>
-	
 {% endblock %}
\ No newline at end of file
diff --git a/erpnext/website/templates/blog/comment.html b/erpnext/website/templates/html/comment.html
similarity index 100%
rename from erpnext/website/templates/blog/comment.html
rename to erpnext/website/templates/html/comment.html
diff --git a/erpnext/website/templates/outer.html b/erpnext/website/templates/html/outer.html
similarity index 91%
rename from erpnext/website/templates/outer.html
rename to erpnext/website/templates/html/outer.html
index 4b8c04d..47184fa 100644
--- a/erpnext/website/templates/outer.html
+++ b/erpnext/website/templates/html/outer.html
@@ -2,7 +2,7 @@
 	requires, brand, top_bar_items, footer_items, copyright, content
 #}
 
-{% extends "base.html" %}
+{% extends "html/base.html" %}
 
 {% block body %}
 
@@ -31,7 +31,7 @@
 				</ul>
 				<img src="images/lib/ui/spinner.gif" id="spinner"/>
 				<ul class="nav pull-right">
-					<li id="login-topbar-item"><a href="login-page.html">Login</a></li>
+					<li id="login-topbar-item"><a href="login.html">Login</a></li>
 				</ul>
 			</div>
 			</div>
@@ -50,7 +50,9 @@
 				data-label="{{ item.label }}">{{ item.label }}</a></li>
 		{% endfor %}
 		</ul></div>
+		{% if copyright %}
 		<div class="web-footer-copyright">&copy; {{ copyright }}
+		{% endif %}
 		</div>
 	</footer>
 
diff --git a/erpnext/website/templates/page.html b/erpnext/website/templates/html/page.html
similarity index 87%
rename from erpnext/website/templates/page.html
rename to erpnext/website/templates/html/page.html
index c6e0715..e2eb6f4 100644
--- a/erpnext/website/templates/page.html
+++ b/erpnext/website/templates/html/page.html
@@ -1,10 +1,9 @@
-{% extends "outer.html" %}
+{% extends "html/outer.html" %}
 
 {% block title %}{{ title }}{% endblock %}
 
 {% block header %}
 	{{ super() }}
-	{% if insert_code %}
 	<script>
 	window.page_name = "{{ name }}";
 
@@ -13,7 +12,6 @@
 	
 		// page script
 		{% block javascript %}
-		{{ javascript }}
 		{% endblock %}
 	
 		// trigger onload
@@ -23,7 +21,6 @@
 		wn.container.change_to(window.page_name);
 	});
 	</script>
-	{% endif %}
 	
 	{% block css %}
 	{% if insert_style %}
diff --git a/erpnext/website/templates/product/product.html b/erpnext/website/templates/html/product_page.html
similarity index 62%
rename from erpnext/website/templates/product/product.html
rename to erpnext/website/templates/html/product_page.html
index 6f33ec9..646bba9 100644
--- a/erpnext/website/templates/product/product.html
+++ b/erpnext/website/templates/html/product_page.html
@@ -1,4 +1,12 @@
-{% extends "product/product.js" %}
+{% extends "html/page.html" %}
+
+{% block javascript %}
+	{% include "js/product_page.js" %}
+{% endblock %}
+
+{% block css %}
+	{% include "css/product_page.css" %}
+{% endblock %}
 
 {% block title %}
 	{% if item_name != name %}
@@ -37,41 +45,4 @@
 			<div style="clear: both"></div>
 		</div>
 	</div>
-{% endblock %}
-
-{% block css %}
-	<style>
-		.web-long-description {
-			font-size: 18px;
-			line-height: 200%;
-		}
-		.product-page-content {
-			float: left;
-		}
-		/* product page image css */
-		.product-page-content img {
-			max-width: 100%;
-		}
-		
-		/* similar products listing */
-		.similar-products .img-area img {
-			max-width: 55px;
-			max-height: 55px;
-		}
-		
-		.similar-products .img-area {
-			float: left;
-			width: 30%;
-			margin-top: 0.3em;
-		}
-		
-		.similar-product-description {
-			float: left;
-			width: 70%;
-		}
-		
-		.similar-product-description span {
-			font-size: 12px;
-		}
-</style>
-{% endblock %}
+{% endblock %}
\ No newline at end of file
diff --git a/erpnext/website/templates/web_page.html b/erpnext/website/templates/html/web_page.html
similarity index 81%
rename from erpnext/website/templates/web_page.html
rename to erpnext/website/templates/html/web_page.html
index 8188e71..6fa7d27 100644
--- a/erpnext/website/templates/web_page.html
+++ b/erpnext/website/templates/html/web_page.html
@@ -1,4 +1,10 @@
-{% extends "page.html" %}
+{% extends "html/page.html" %}
+
+{% block javascript %}
+	{% if insert_code %}
+		{{ javascript }}
+	{% endif %}
+{% endblock %}
 
 {% block content %}
 	<div class="layout-wrapper layout-wrapper-background">
diff --git a/erpnext/website/templates/blog/blog_list.js b/erpnext/website/templates/js/blog.js
similarity index 95%
rename from erpnext/website/templates/blog/blog_list.js
rename to erpnext/website/templates/js/blog.js
index 70628c1..1212a84 100644
--- a/erpnext/website/templates/blog/blog_list.js
+++ b/erpnext/website/templates/js/blog.js
@@ -1,6 +1,3 @@
-{% extends "page.html" %}
-
-{% block javascript %}
 // ERPNext - web based ERP (http://erpnext.com)
 // Copyright (C) 2012 Web Notes Technologies Pvt Ltd
 // 
@@ -43,6 +40,4 @@
 		page_length: 10
 	});
 	erpnext.blog_list.run();
-}
-
-{% endblock %}
+}
\ No newline at end of file
diff --git a/erpnext/website/templates/blog/blog.js b/erpnext/website/templates/js/blog_page.js
similarity index 94%
rename from erpnext/website/templates/blog/blog.js
rename to erpnext/website/templates/js/blog_page.js
index 24d5033..7121677 100644
--- a/erpnext/website/templates/blog/blog.js
+++ b/erpnext/website/templates/js/blog_page.js
@@ -1,6 +1,3 @@
-{% extends "page.html" %}
-
-{% block javascript %}
 // ERPNext - web based ERP (http://erpnext.com)
 // Copyright (C) 2012 Web Notes Technologies Pvt Ltd
 // 
@@ -18,6 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 // js inside blog page
+
 wn.provide('erpnext.blog');
 wn.pages['{{ name }}'].onload = function(wrapper) {
 	erpnext.blog.wrapper = wrapper;
@@ -79,6 +77,7 @@
 	var $blog_comments = $(wrapper).find('.blog-comments');
 	var $comment_rows = $blog_comments.find('.comment-row');
 	var $no_result = $blog_comments.find('.no-result');
+
 	if ($comment_rows.length == 0) {
 		$no_result.removeClass('hide');
 	} else {
@@ -156,9 +155,9 @@
 	$comment_rows = $blog_comments.find('.comment-row');
 	
 	if ($comment_rows.length) {
-		$comment_rows.last().after(comment);
+		$blog_comments.append(comment);
 	} else {
-		$blog_comments.find('.no-result').after(comment);
+		$blog_comments.append(comment);
 	}
 	
 	erpnext.blog.toggle_no_result(wrapper);
@@ -170,7 +169,12 @@
 	if ($wrapper.find('.blog-comments .comment-row').length > 50) {
 		var $comment_btn = $wrapper.find('button.add-comment');
 		$comment_btn.addClass('hide');
+		
+		// show comments are close
+		$wrapper.find('.blog-comments').append("\
+			<div class=\"help\"> \
+				<p>Comments Closed</p> \
+				<br /> \
+			</div>");
 	}
-}
-
-{% endblock %}
+}
\ No newline at end of file
diff --git a/erpnext/website/templates/js/login.js b/erpnext/website/templates/js/login.js
new file mode 100644
index 0000000..29e4922
--- /dev/null
+++ b/erpnext/website/templates/js/login.js
@@ -0,0 +1,91 @@
+// ERPNext - web based ERP (http://erpnext.com)
+// Copyright (C) 2012 Web Notes Technologies Pvt Ltd
+// 
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+wn.provide('erpnext.login');
+
+wn.pages["{{ name }}"].onload = function(wrapper) {
+	wrapper.appframe = new wn.ui.AppFrame($(wrapper).find('.appframe-area'));
+	wrapper.appframe.title('Login');
+	wrapper.appframe.$w.find('.close').toggle(false);
+
+	var lw = $i('login_wrapper');
+	$bs(lw, '1px 1px 3px #888');
+
+	$('#login_btn').click(erpnext.login.doLogin)
+		
+	$('#password').keypress(function(ev){
+		if(ev.which==13 && $('#password').val()) {
+			$('form').submit(function() {
+				erpnext.login.doLogin();
+				return false;
+			});
+		}
+	});
+	$(document).trigger('login_rendered');
+}
+
+// Login Callback
+erpnext.login.onLoginReply = function(r, rtext) {
+	$('#login_btn').done_working();
+    if(r.message=="Logged In"){
+        window.location.href='app.html' + (get_url_arg('page') ? ('?page='+get_url_arg('page')) : '');
+    } else {
+        $i('login_message').innerHTML = '<span style="color: RED;">'+(r.message)+'</span>';
+        //if(r.exc)alert(r.exc);
+    }
+}
+
+
+// Login
+erpnext.login.doLogin = function(){
+
+    var args = {};
+    args['usr']=$i("login_id").value;
+    args['pwd']=$i("password").value;
+    if($i('remember_me').checked) 
+      args['remember_me'] = 1;
+
+	$('#login_btn').set_working();
+	
+    $c("login", args, erpnext.login.onLoginReply);
+
+	return false;
+}
+
+
+erpnext.login.show_forgot_password = function(){
+    // create dialog
+	var d = new wn.ui.Dialog({
+		title:"Forgot Password",
+		fields: [
+			{'label':'Email Id', 'fieldname':'email_id', 'fieldtype':'Data', 'reqd':true},
+			{'label':'Email Me A New Password', 'fieldname':'run', 'fieldtype':'Button'}
+		]
+	});
+
+	$(d.fields_dict.run.input).click(function() {
+		var values = d.get_values();
+		if(!values) return;
+		wn.call({
+			method:'reset_password',
+			args: { user: values.email_id },
+			callback: function() {
+				d.hide();
+			}
+		})
+	})
+	d.show();
+}
\ No newline at end of file
diff --git a/erpnext/website/templates/product/product_category.js b/erpnext/website/templates/js/product_category.js
similarity index 89%
rename from erpnext/website/templates/product/product_category.js
rename to erpnext/website/templates/js/product_category.js
index e1905ac..4229d00 100644
--- a/erpnext/website/templates/product/product_category.js
+++ b/erpnext/website/templates/js/product_category.js
@@ -1,7 +1,5 @@
-{% extends "page.html" %}
-
-{% block javascript %}
 wn.provide('erpnext.products');
+
 erpnext.products.make_product_categories = function(wrapper) {
 	if (!wrapper) { wrapper = erpnext.products.wrapper; }
 	if (!wrapper) { return; }
@@ -17,6 +15,4 @@
 		}
 	});
 	wrapper.category_list.run();
-}
-
-{% endblock %}
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/erpnext/website/templates/product/product.js b/erpnext/website/templates/js/product_page.js
similarity index 95%
rename from erpnext/website/templates/product/product.js
rename to erpnext/website/templates/js/product_page.js
index f7745d7..0c4abb4 100644
--- a/erpnext/website/templates/product/product.js
+++ b/erpnext/website/templates/js/product_page.js
@@ -1,7 +1,3 @@
-{% extends "product/product_category.js" %}
-
-{% block javascript %}
-{{ super() }}
 // ERPNext - web based ERP (http://erpnext.com)
 // Copyright (C) 2012 Web Notes Technologies Pvt Ltd
 // 
@@ -17,7 +13,9 @@
 // 
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-wn.provide('erpnext.products');
+
+{% include "js/product_category.js" %}
+
 wn.pages['{{ name }}'].onload = function(wrapper) {
 	wrapper.product_group = "{{ item_group }}";
 	wrapper.product_name = "{{ name }}";
@@ -91,6 +89,4 @@
 		}
 	});
 	wrapper.similar.run();
-}
-
-{% endblock %}
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/erpnext/website/templates/product/product_list.js b/erpnext/website/templates/js/products.js
similarity index 95%
rename from erpnext/website/templates/product/product_list.js
rename to erpnext/website/templates/js/products.js
index 1c6f934..f4c68cb 100644
--- a/erpnext/website/templates/product/product_list.js
+++ b/erpnext/website/templates/js/products.js
@@ -1,8 +1,3 @@
-{% extends "product/product_category.js" %}
-
-{% block javascript %}
-{{ super() }}
-
 // ERPNext - web based ERP (http://erpnext.com)
 // Copyright (C) 2012 Web Notes Technologies Pvt Ltd
 // 
@@ -20,7 +15,8 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 // js inside blog page
-wn.provide('erpnext.products');
+
+{% include "js/product_category.js" %}
 
 wn.pages['{{ name }}'].onload = function(wrapper) {
 	erpnext.products.wrapper = wrapper;
@@ -107,6 +103,4 @@
 		erpnext.products.cur_group = null;
 	}
 	return {grp:grp, label:label};
-}
-
-{% endblock %}
+}
\ No newline at end of file
diff --git a/erpnext/website/templates/login/login.js b/erpnext/website/templates/login/login.js
deleted file mode 100644
index d6b6b24..0000000
--- a/erpnext/website/templates/login/login.js
+++ /dev/null
@@ -1,103 +0,0 @@
-{% extends "page.html" %}
-
-{% block javascript %}
-{{ super() }}
-// Copyright (c) 2012 Web Notes Technologies Pvt Ltd (http://erpnext.com)
-// 
-// MIT License (MIT)
-// 
-// Permission is hereby granted, free of charge, to any person obtaining a 
-// copy of this software and associated documentation files (the "Software"), 
-// to deal in the Software without restriction, including without limitation 
-// the rights to use, copy, modify, merge, publish, distribute, sublicense, 
-// and/or sell copies of the Software, and to permit persons to whom the 
-// Software is furnished to do so, subject to the following conditions:
-// 
-// The above copyright notice and this permission notice shall be included in 
-// all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
-// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF 
-// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
-// OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-// 
-
-wn.provide('erpnext.login');
-
-wn.pages["{{ name }}"].onload = function(wrapper) {
-	wrapper.appframe = new wn.ui.AppFrame($(wrapper).find('.appframe-area'));
-	wrapper.appframe.title('Login');
-	wrapper.appframe.$w.find('.close').toggle(false);
-
-	var lw = $i('login_wrapper');
-	$bs(lw, '1px 1px 3px #888');
-
-	$('#login_btn').click(erpnext.login.doLogin)
-		
-	$('#password').keypress(function(ev){
-		if(ev.which==13 && $('#password').val()) {
-			$('form').submit(function() {
-				erpnext.login.doLogin();
-				return false;
-			});
-		}
-	});
-	$(document).trigger('login_rendered');
-}
-
-// Login Callback
-erpnext.login.onLoginReply = function(r, rtext) {
-	$('#login_btn').done_working();
-    if(r.message=="Logged In"){
-        window.location.href='app.html' + (get_url_arg('page') ? ('?page='+get_url_arg('page')) : '');
-    } else {
-        $i('login_message').innerHTML = '<span style="color: RED;">'+(r.message)+'</span>';
-        //if(r.exc)alert(r.exc);
-    }
-}
-
-
-// Login
-erpnext.login.doLogin = function(){
-
-    var args = {};
-    args['usr']=$i("login_id").value;
-    args['pwd']=$i("password").value;
-    if($i('remember_me').checked) 
-      args['remember_me'] = 1;
-
-	$('#login_btn').set_working();
-	
-    $c("login", args, erpnext.login.onLoginReply);
-
-	return false;
-}
-
-
-erpnext.login.show_forgot_password = function(){
-    // create dialog
-	var d = new wn.ui.Dialog({
-		title:"Forgot Password",
-		fields: [
-			{'label':'Email Id', 'fieldname':'email_id', 'fieldtype':'Data', 'reqd':true},
-			{'label':'Email Me A New Password', 'fieldname':'run', 'fieldtype':'Button'}
-		]
-	});
-
-	$(d.fields_dict.run.input).click(function() {
-		var values = d.get_values();
-		if(!values) return;
-		wn.call({
-			method:'reset_password',
-			args: { user: values.email_id },
-			callback: function() {
-				d.hide();
-			}
-		})
-	})
-	d.show();
-}
-
-{% endblock %}
\ No newline at end of file
diff --git a/erpnext/website/templates/404.html b/erpnext/website/templates/pages/404.html
similarity index 90%
rename from erpnext/website/templates/404.html
rename to erpnext/website/templates/pages/404.html
index 8a30892..0423608 100644
--- a/erpnext/website/templates/404.html
+++ b/erpnext/website/templates/pages/404.html
@@ -1,4 +1,4 @@
-{% extends "outer.html" %}
+{% extends "html/outer.html" %}
 
 {% block content %}
 <div class="content">
diff --git a/erpnext/website/templates/blog/blog_list.html b/erpnext/website/templates/pages/blog.html
similarity index 80%
rename from erpnext/website/templates/blog/blog_list.html
rename to erpnext/website/templates/pages/blog.html
index 242f814..40c90c2 100644
--- a/erpnext/website/templates/blog/blog_list.html
+++ b/erpnext/website/templates/pages/blog.html
@@ -1,17 +1,15 @@
-{% extends "blog/blog_list.js" %}
+{% extends "html/page.html" %}
 
-{% block title %}Blog{% endblock %}
+{% block javascript %}
+	{% include "js/blog.js" %}
+{% endblock %}
 
 {% block css %}
-	<style>
-		h2 > a, h2 > a:link, h2 > a:visited, h2 > a:active,
-		h2 > a:hover, h2 > a:focus {
-			text-decoration: none;
-			color: inherit;
-		}
-	</style>
+	{% include "css/blog.css" %}
 {% endblock %}
 
+{% block title %}Blog{% endblock %}
+
 {% block content %}
 	<div class="layout-wrapper layout-wrapper-background">
 		<div class="web-content" id="content-blog">
diff --git a/erpnext/website/templates/pages/index.html b/erpnext/website/templates/pages/index.html
new file mode 100644
index 0000000..1307872
--- /dev/null
+++ b/erpnext/website/templates/pages/index.html
@@ -0,0 +1 @@
+{% extends "html/web_page.html" %}
\ No newline at end of file
diff --git a/erpnext/website/templates/login/login.html b/erpnext/website/templates/pages/login.html
similarity index 86%
rename from erpnext/website/templates/login/login.html
rename to erpnext/website/templates/pages/login.html
index 62d252f..9bc3171 100644
--- a/erpnext/website/templates/login/login.html
+++ b/erpnext/website/templates/pages/login.html
@@ -1,4 +1,12 @@
-{% extends "login/login.js" %}
+{% extends "html/page.html" %}
+
+{% block javascript %}
+	{% include "js/login.js" %}
+{% endblock %}
+
+{% block css %}
+	{% include "css/login.css" %}
+{% endblock %}
 
 {% block title %}
 	Login Page
@@ -41,17 +49,4 @@
 	</div>
 	</div>
 
-{% endblock %}
-
-{% block css %}
-	<style>
-		#login_wrapper {
-			width: 300px !important;
-			margin: 20px auto;
-		}
-
-		.login-banner {
-			margin-bottom: 20px;
-		}
-	</style>
 {% endblock %}
\ No newline at end of file
diff --git a/erpnext/website/templates/product/product_list.html b/erpnext/website/templates/pages/products.html
similarity index 80%
rename from erpnext/website/templates/product/product_list.html
rename to erpnext/website/templates/pages/products.html
index c8dfd24..aa23ea2 100644
--- a/erpnext/website/templates/product/product_list.html
+++ b/erpnext/website/templates/pages/products.html
@@ -1,4 +1,12 @@
-{% extends "product/product_list.js" %}
+{% extends "html/page.html" %}
+
+{% block javascript %}
+	{% include "js/products.js" %}
+{% endblock %}
+
+{% block css %}
+	{% include "css/products.css" %}
+{% endblock %}
 
 {% block title %}
 	Products
@@ -26,18 +34,4 @@
 			<div style="clear: both"></div>
 		</div>
 	</div>
-{% endblock %}
-
-{% block css %}
-	<style>
-		.img-area {
-			float:left;
-			width: 115px;
-		}
-		
-		.product-list-description {
-			float:left;
-			width: 400px;
-		}
-	</style>
 {% endblock %}
\ No newline at end of file
