diff --git a/docs/dev/docs.dev.md b/docs/dev/docs.dev.md
index 15afea8..f14208a 100644
--- a/docs/dev/docs.dev.md
+++ b/docs/dev/docs.dev.md
@@ -15,6 +15,6 @@
 ---
 ### Is this for me?
 
-To starting hacking into ERPNext, you must have some understanding of how a dynamic web application works. There are hundreds of architectures and frameworks to make web development easier, but at the core there are a few elements that are important to understand.
+To start hacking into ERPNext, you must have some understanding of how a dynamic web application works. There are hundreds of architectures and frameworks to make web development easier, but at the core there are a few elements that are important to understand.
 
 ERPNext is built on `wnframework` which is primarily developed for ERPNext but can be extended to make similar database driven applications. wnframework uses Python on the server-side and has a javascript based client for entering data, managing workflow and making reports.
\ No newline at end of file
diff --git a/docs/user/accounts/docs.user.accounts.md b/docs/user/accounts/docs.user.accounts.md
index 57597cb..21a43e3 100644
--- a/docs/user/accounts/docs.user.accounts.md
+++ b/docs/user/accounts/docs.user.accounts.md
@@ -1,8 +1,21 @@
 ---
 {
-	"_label": "Accounts"
+	"_label": "Accounts",
+	"_toc": [
+		"docs.user.accounts.sales_invoice",
+		"docs.user.accounts.purchase_invoice",
+		"docs.user.accounts.payments",
+		"docs.user.accounts.journal_voucher",
+		"docs.user.accounts.opening_entry",
+		"docs.user.accounts.closing",
+		"docs.user.accounts.reports",
+		"docs.user.accounts.voucher_import",
+		"docs.user.accounts.pos"
+	]
 }
 ---
+
+
 At end of the sales and purchase cycle is billing and payments. You may have an accountant in your team, or you may be doing accounting yourself or you may have outsourced your accounting. Financial accounting forms the core of any business management system like an ERP.
 
 In ERPNext, your accounting operations consists of 3 main transactions:
diff --git a/docs/user/customize/docs.user.customize.custom_scripts b/docs/user/customize/docs.user.customize.custom_scripts
new file mode 100644
index 0000000..9b6c91f
--- /dev/null
+++ b/docs/user/customize/docs.user.customize.custom_scripts
@@ -0,0 +1,6 @@
+---
+{
+	"_label": "Custom Scripts"
+}
+---
+
diff --git a/docs/user/customize/docs.user.customize.custom_scripts.md b/docs/user/customize/docs.user.customize.custom_scripts.md
new file mode 100644
index 0000000..9b6c91f
--- /dev/null
+++ b/docs/user/customize/docs.user.customize.custom_scripts.md
@@ -0,0 +1,6 @@
+---
+{
+	"_label": "Custom Scripts"
+}
+---
+
diff --git a/docs/user/customize/docs.user.customize.hide_unhide.md b/docs/user/customize/docs.user.customize.hide_unhide.md
new file mode 100644
index 0000000..ff64b24
--- /dev/null
+++ b/docs/user/customize/docs.user.customize.hide_unhide.md
@@ -0,0 +1,22 @@
+---
+{
+	"_label": "Hiding Modules and Features"
+}
+---
+### Hiding Unused Features
+
+As you have seen from this manual that ERPNext contains tons of features which you may not use. We have observed that most users start with using 20% of the features, though a different 20%. To hide fields belonging to features you dont require, go to:
+
+> Setup > Customize ERPNext > Disable Features.
+
+Check / uncheck the features you want to use and refresh your page for the changes to take effect.
+
+---
+
+### Hiding Module Icons
+
+To hide modules (icons) from the home page, go to:
+
+Setup > Customize ERPNext > Modules Setup
+
+> Note: Modules are automatically hidden for users that have no permissions on the documents within that module. For example, if a user has no permissions on Purchase Order, Purchase Request, Supplier, the “Buying” module will automatically be hidden.
diff --git a/docs/user/customize/docs.user.customize.md b/docs/user/customize/docs.user.customize.md
index ec9c3b3..9bcdac3 100644
--- a/docs/user/customize/docs.user.customize.md
+++ b/docs/user/customize/docs.user.customize.md
@@ -1,6 +1,13 @@
 ---
 {
-	"_label": "Customize ERPNext"
+	"_label": "Customize ERPNext",
+	"_toc": [
+		"docs.user.customize.custom_field",
+		"docs.user.customize.custom_form",
+		"docs.user.customize.hide_unhide",
+		"docs.user.customize.print_format",
+		"docs.user.customize.custom_scripts"
+	]
 }
 ---
 ERPNext offers many tools to customize the system.
diff --git a/docs/user/customize/docs.user.customize.modules.md b/docs/user/customize/docs.user.customize.modules.md
index ff64b24..8bd21b6 100644
--- a/docs/user/customize/docs.user.customize.modules.md
+++ b/docs/user/customize/docs.user.customize.modules.md
@@ -1,6 +1,6 @@
 ---
 {
-	"_label": "Hiding Modules and Features"
+	"_label": "Hiding Modules and Features "
 }
 ---
 ### Hiding Unused Features
diff --git a/docs/user/docs.user.md b/docs/user/docs.user.md
index 31f2d74..1bf6394 100644
--- a/docs/user/docs.user.md
+++ b/docs/user/docs.user.md
@@ -8,7 +8,7 @@
 		"docs.user.selling",
 		"docs.user.buying",
 		"docs.user.stock",
-		"docs.user.accounting",
+		"docs.user.accounts",
 		"docs.user.hr",
 		"docs.user.mfg",
 		"docs.user.support",
@@ -61,6 +61,7 @@
 		1. [Campaign](docs.user.selling.campaign.html)
 		1. [Terms and Conditions](docs.user.selling.terms.html)
 		1. [Price Lists](docs.user.setup.price_lists.html)
+		1. [Discount](docs.user.selling.discount.html)
 	1. [Customers](docs.user.selling.customer.html)
 	1. [Lead](docs.user.selling.lead.html)
 	1. [Opportunity](docs.user.selling.opportunity.html)
@@ -87,7 +88,7 @@
 	1. [Sales Return](docs.user.stock.sales_return.html)
 	1. [Purchase Return](docs.user.stock.purchase_return.html)
 	1. [Projected Quantity](docs.user.stock.projected_quantity.html)
-1. [Accounting](docs.user.accounting.html)
+1. [Accounts](docs.user.accounts.html)
 	1. [Chart of Accounts](docs.user.setup.accounting.html)
 	1. [Chart of Cost Centers](docs.user.setup.cost_centers.html)
 	1. [Sales Invoice](docs.user.accounts.sales_invoice.html)
@@ -98,7 +99,7 @@
 	1. [Period Closing](docs.user.accounts.closing.html)
 	1. [Accounting Reports](docs.user.accounts.reports.html)
 	1. [Upload Journal Entries in Bulk](docs.user.accounts.voucher_import.html)
-	1. [Point of Sale (POS) Invoice](docs.user.accounts.pos.html)
+	1. [Point of Sale (POS) Invoice](docs.user.accounts.pos.html)	
 1. [Human Resources (HR)](docs.user.hr.html)
 	1. [HR Setup](docs.user.hr.setup.html)
 	1. [Employee](docs.user.hr.employee.html)
@@ -135,6 +136,6 @@
 1. [Customize](docs.user.customize.html)
 	1. [Custom Fields](docs.user.customize.custom_field.html)
 	1. [Customize Form](docs.user.customize.custom_form.html)
-	1. [Hide / Unhide modules](docs.user.customize.module.html)
+	1. [Hide / Unhide modules](docs.user.customize.hide_unhide.html)
 	1. [Print Formats](docs.user.customize.print_formats.html)
 	1. [Custom Scripts](docs.user.customize.custom_scripts.html)
\ No newline at end of file
diff --git a/docs/user/docs.user.projects.md b/docs/user/docs.user.projects.md
deleted file mode 100644
index 28ab0cb..0000000
--- a/docs/user/docs.user.projects.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-{
-	"_label": "Projects"
-}
----
-Managing Projects
-
-ERPNext helps you manage your Projects by breaking them into Tasks and allocating them to different people. 
-
-Purchasing and selling can also be tracked against Projects and this can help the company keep tabs on its budget, delivery and profitability for a Project. 
-
-Projects can be used to manage internal projects, manufacturing jobs or service jobs. For service jobs, Time Sheets can also be created that can be used to bill Customers if billing is done on a Time & Money basis.
-
-## Project
-
-The Project record maintains the details of your project and milestones that you have set. The Project record can be linked in Quotations, Sales Orders, Delivery Notes, Sales Invoices, Purchase Requests, Purchase Orders and Purchase Invoices. This way you can keep a track of all the activities that happen around this project.
-
-## Tasks
-
-Project is broken into Tasks and each Task is allocated to a resource. In ERPNext, you can also create an allocate a Task independently of a Project. If you define the start and end dates, it will add calendar events for the same and also show the task on the Gantt Chart that you can use for monitoring the Project.
-
-## Time Sheets
-
-You can create Time Sheets to track billable work to Customers. These Time Sheets can be tracked against Project and Tasks so that you can get reports on how much time was spent on each Task or Project.
\ No newline at end of file
diff --git a/docs/user/hr/docs.user.hr.attendance.md b/docs/user/hr/docs.user.hr.attendance.md
new file mode 100644
index 0000000..c57f17c
--- /dev/null
+++ b/docs/user/hr/docs.user.hr.attendance.md
@@ -0,0 +1,6 @@
+---
+{
+	"_label": "Attendance"
+}
+---
+
diff --git a/docs/user/hr/docs.user.hr.expense_claim.md b/docs/user/hr/docs.user.hr.expense_claim.md
index 53218b2..4c99fdb 100644
--- a/docs/user/hr/docs.user.hr.expense_claim.md
+++ b/docs/user/hr/docs.user.hr.expense_claim.md
@@ -21,4 +21,4 @@
 
 ### Booking the Expense and Reimbursement
 
-The approved Expense Claim must then be converted into a Journal Voucher and a payment must be made. Note: This amount should not be clubbed with Salary because the amount will then be taxable to the Employee.
+The approved Expense Claim must then be converted into a Journal Voucher and a payment must be made. Note: This amount should not be clubbed with Salary because the amount will then be taxable to the Employee.
\ No newline at end of file
diff --git a/docs/user/hr/docs.user.hr.leave.md b/docs/user/hr/docs.user.hr.leave.md
index 3dc8bb1..b637569 100644
--- a/docs/user/hr/docs.user.hr.leave.md
+++ b/docs/user/hr/docs.user.hr.leave.md
@@ -1,6 +1,6 @@
 ---
 {
-	"_label": "Leave and Attendance"
+	"_label": "Leave"
 }
 ---
 
diff --git a/docs/user/hr/docs.user.hr.md b/docs/user/hr/docs.user.hr.md
index 8657454..e86f9e0 100644
--- a/docs/user/hr/docs.user.hr.md
+++ b/docs/user/hr/docs.user.hr.md
@@ -1,6 +1,15 @@
 ---
 {
-	"_label": "Human Resource Management"
+	"_label": "Human Resource Management",
+	"_toc": [
+		"docs.user.hr.set-up",
+		"docs.user.hr.employee",
+		"docs.user.hr.leave",
+		"docs.user.hr.attendance",
+		"docs.user.hr.payroll",
+		"docs.user.hr.expense_claim",
+		"docs.user.hr.appraisal"		
+	]
 }
 ---
 The Human Resources (HR) Module covers the processes linked to managing a team of co-workers. Most important feature here is processing the payroll by using the Salary Manager to generate Salary Slips. Most countries have complex tax rules stating which expenses the company can make on behalf of the Employees. There are a set of rules for the company to deduct taxes and social security from employee payroll. ERPNext allows to accomodate all types of taxes and their calculation.
diff --git a/docs/user/mfg/docs.user.mfg.md b/docs/user/mfg/docs.user.mfg.md
index 3755987..84bf08d 100644
--- a/docs/user/mfg/docs.user.mfg.md
+++ b/docs/user/mfg/docs.user.mfg.md
@@ -1,6 +1,11 @@
 ---
 {
-	"_label": "Manufacturing"
+	"_label": "Manufacturing",
+	"_toc": [
+		"docs.user.mfg.bom",
+		"docs.user.mfg.planning",
+		"docs.user.mfg.production_order"
+	]
 }
 ---
 The Manufacturing module in ERPNext helps you to maintain multi-level Bill of Materials (BOMs) for your Items. It helps you in Product Costing, planing your production via Production Plan, creating Production Orders for your manufacturing shop floor,s and planing your inventory by getting your material requirement via BOMs (also called Material Requirements Planning MRP).
diff --git a/docs/user/projects/docs.user.projects.md b/docs/user/projects/docs.user.projects.md
new file mode 100644
index 0000000..beeeb0b
--- /dev/null
+++ b/docs/user/projects/docs.user.projects.md
@@ -0,0 +1,18 @@
+---
+{
+	"_label": "Projects",
+	"_toc": [
+		"docs.user.projects.projects",
+		"docs.user.projects.task",
+		"docs.user.projects.timelog"
+	]
+}
+---
+Managing Projects
+
+ERPNext helps you manage your Projects by breaking them into Tasks and allocating them to different people. 
+
+Purchasing and selling can also be tracked against Projects and this can help the company keep tabs on its budget, delivery and profitability for a Project. 
+
+Projects can be used to manage internal projects, manufacturing jobs or service jobs. For service jobs, Time Sheets can also be created that can be used to bill Customers if billing is done on a Time & Money basis.
+
diff --git a/docs/user/projects/docs.user.projects.projects.md b/docs/user/projects/docs.user.projects.projects.md
new file mode 100644
index 0000000..9bcda3d
--- /dev/null
+++ b/docs/user/projects/docs.user.projects.projects.md
@@ -0,0 +1,12 @@
+---
+{
+	"_label": "Projects"
+}
+---
+
+## Project
+
+The Project record maintains the details of your project and milestones that you have set. The Project record can be linked in Quotations, Sales Orders, Delivery Notes, Sales Invoices, Purchase Requests, Purchase Orders and Purchase Invoices. This way you can keep a track of all the activities that happen around this project.
+
+
+![projects](img/projects.png)
\ No newline at end of file
diff --git a/docs/user/projects/docs.user.projects.task.md b/docs/user/projects/docs.user.projects.task.md
new file mode 100644
index 0000000..7972d58
--- /dev/null
+++ b/docs/user/projects/docs.user.projects.task.md
@@ -0,0 +1,15 @@
+---
+{
+	"_label": "Tasks"
+}
+---
+
+## Tasks
+
+Project is divided into Tasks and each Task is allocated to a resource. In ERPNext, you can also create and allocate a Task independently of a Project. If you define the start and end dates, it will add calendar events for the same and also show the task on the Gantt Chart that you can use for monitoring the Project.
+
+
+
+![Tasks](img/tasks.png)
+
+
diff --git a/docs/user/projects/docs.user.projects.tasks.md b/docs/user/projects/docs.user.projects.tasks.md
new file mode 100644
index 0000000..7a8cd48
--- /dev/null
+++ b/docs/user/projects/docs.user.projects.tasks.md
@@ -0,0 +1,14 @@
+---
+{
+	"_label": "Task"
+}
+---
+
+## Tasks
+
+Project is broken into Tasks and each Task is allocated to a resource. In ERPNext, you can also create an allocate a Task independently of a Project. If you define the start and end dates, it will add calendar events for the same and also show the task on the Gantt Chart that you can use for monitoring the Project.
+
+
+
+![Tasks](img/tasks.png)
+
diff --git a/docs/user/projects/docs.user.projects.timelog.md b/docs/user/projects/docs.user.projects.timelog.md
new file mode 100644
index 0000000..ffecb70
--- /dev/null
+++ b/docs/user/projects/docs.user.projects.timelog.md
@@ -0,0 +1,12 @@
+---
+{
+	"_label": "Time Log"	
+}
+---
+
+## Time Sheets
+
+You can create Time Sheets to track billable work to Customers. These Time Sheets can be tracked against Project and Tasks so that you can get reports on how much time was spent on each Task or Project.
+
+
+![Time Log](img/time-log.png)
\ No newline at end of file
diff --git a/docs/user/selling/docs.user.selling.discount.md b/docs/user/selling/docs.user.selling.discount.md
new file mode 100644
index 0000000..0f0bf2a
--- /dev/null
+++ b/docs/user/selling/docs.user.selling.discount.md
@@ -0,0 +1,16 @@
+---
+{
+	"_label": "Discount"
+}
+---
+
+
+While making your sales transactions like a Quotation (or Sales Order) you would already have noticed that there is a “Discount” column. On the left is the “Price List Rate” on the right is the “Basic Rate”.  You can add a “Discount” value to update the basic rate.
+
+Since your taxes are calculated on Items, you must apply your discounts here so that you apply the tax on the discounted rate, which is the case for most taxes.
+
+The second way to apply discount is to add it in your Taxes and Charges table. This way you can explicitly show the Customer the discount you have applied on the order. If you choose this method, remember that you will tax your Customer at the full rate, not the discounted rate. So this is not a good way to track discounts.
+
+There is a third way to do it. Create an Item called “Discount” and make sure that all the taxes apply in the same way as the main Items. (This method is useful if only one type of tax is applicable on the sale). This way your “Discount” will appear as an expense. You will see a slightly higher income and expense but your profits will still remain the same. This method might be interesting where you want detailed accounting of your discounts.
+
+> Note: The maximum Discount that can be applied on an Item can be fixed in the Item master.
\ No newline at end of file
diff --git a/docs/user/selling/docs.user.selling.md b/docs/user/selling/docs.user.selling.md
index 5c1b6a7..5c0a5ae 100644
--- a/docs/user/selling/docs.user.selling.md
+++ b/docs/user/selling/docs.user.selling.md
@@ -1,6 +1,20 @@
 ---
 {
-	"_label": "Selling"
+	"_label": "Selling",
+	"_toc": [
+		"docs.user.selling.selling_setup",
+		"docs.user.selling.customer_group",
+		"docs.user.selling.territory",
+		"docs.user.selling.sales_partner",
+		"docs.user.selling.sales_person",
+		"docs.user.selling.campaign",
+		"docs.user.selling.terms",
+		"docs.user.selling. customer",
+		"docs.user.selling.lead",
+		"docs.user.selling.opportunity",
+		"docs.user.selling.quotation",
+		"docs.user.selling.sales_order"
+	]
 }
 ---
 Selling is the communication that happens with the customer prior to and during the sale. You might be managing all the communication yourself or you may have a small team of sales people to handle this. ERPNext helps you track the communication leading up to the sale, by keeping all your documents in an organized and searchable manner.
diff --git a/docs/user/selling/docs.user.selling.quotation.md b/docs/user/selling/docs.user.selling.quotation.md
index 8a0afb7..d7743a2 100644
--- a/docs/user/selling/docs.user.selling.quotation.md
+++ b/docs/user/selling/docs.user.selling.quotation.md
@@ -21,7 +21,7 @@
 
 - The recipient of the Quotation
 - The Items and quantities you are offering.
-- The rates at which they are offered.
+- The rates at which they are offered. For details refer 
 - The taxes applicable.
 - Other charges (like shipping, insurance) if applicable.
 - The validity of contract.
@@ -35,7 +35,8 @@
 
 The rates you quote may depend on two things.
 
-- The Price List: If you have multiple Price Lists, you can select a Price List or tag it to the Customer (so that it is auto-selected). Your Item prices will automatically be updated from the Price List.
+- The Price List: If you have multiple Price Lists, you can select a Price List or tag it to the Customer (so that it is auto-selected). Your Item prices will automatically be updated from the Price List.For details refer [Price List](docs.user.setup.price_list.html)
+
 - The Currency: If you are quoting to a Customer in a different currency, you will have to update the conversion rates to enable ERPNext to save the information in your standard Currency. This will help you to analyze the value of your Quotations in standard Currency.
 
 ### Taxes
@@ -69,15 +70,7 @@
 
 > Tip: Quotations can also be titled as “Proforma Invoice” or “Proposal”. Select the right heading in the “Print Heading” field in the “More Info” section. To create new Print Headings go to Setup > Branding and Printing > Print Headings.
 
-## Discounts
+### Discount
 
-While making your sales transactions like a Quotation (or Sales Order) you would already have noticed that there is a “Discount” column. On the left is the “Price List Rate” on the right is the “Basic Rate”.  You can add a “Discount” value to update the basic rate.
-
-Since your taxes are calculated on Items, you must apply your discounts here so that you apply the tax on the discounted rate, which is the case for most taxes.
-
-The second way to apply discount is to add it in your Taxes and Charges table. This way you can explicitly show the Customer the discount you have applied on the order. If you choose this method, remember that you will tax your Customer at the full rate, not the discounted rate. So this is not a good way to track discounts.
-
-There is a third way to do it. Create an Item called “Discount” and make sure that all the taxes apply in the same way as the main Items. (This method is useful if only one type of tax is applicable on the sale). This way your “Discount” will appear as an expense. You will see a slightly higher income and expense but your profits will still remain the same. This method might be interesting where you want detailed accounting of your discounts.
-
-> Note: The maximum Discount that can be applied on an Item can be fixed in the Item master.
+While making your sales transactions like a Quotation (or Sales Order) you would already have noticed that there is a “Discount” column. On the left is the “Price List Rate” on the right is the “Basic Rate”.  You can add a “Discount” value to update the basic rate. To understand more about discount read [Discount](docs.user.selling.discount.html)
 
diff --git a/docs/user/setup/docs.user.setup.company.md b/docs/user/setup/docs.user.setup.company.md
new file mode 100644
index 0000000..322f464
--- /dev/null
+++ b/docs/user/setup/docs.user.setup.company.md
@@ -0,0 +1,14 @@
+---
+{
+	"_label": "Company Setup"
+}
+---
+
+
+Enter your company details to complete Company Setup. Mention the type of business, under Domain. You can enter manufacturing, retail, or services depending on the nature of your business activity. If you have more than one companies, create the setup under the Company Setup page.
+
+> Setup > Company > New Company
+
+
+
+![Company Setup](img/company.png)
diff --git a/docs/user/setup/docs.user.setup.email.md b/docs/user/setup/docs.user.setup.email.md
index 17ef4b6..63bc146 100644
--- a/docs/user/setup/docs.user.setup.email.md
+++ b/docs/user/setup/docs.user.setup.email.md
@@ -17,7 +17,12 @@
 
 To setup your outgoing mails, go to
 
-> Setup > Email and Notifications > Email Settings
+> Setup > Outgoing Email Settings > Email Settings
+
+
+![Email Settings](img/email-settings1.png)
+
+
 
 Set your outgoing mail server settings here. These are the same settings you would use in your Outlook, Thunderbird, Apple Mail or other such email applications. If you are not sure, get in touch with your email service provider.
 
@@ -31,7 +36,13 @@
 
 To setup your Support integration, go to:
 
-> Setup > Email and Notifications > Email Settings > Incoming Mail Settings
+> Setup > Support Email Settings > EMail Settings
+
+
+![Email Settings](img/email-settings2.png)
+
+
+
 
 To make ERPNext pull emails from your mail box, enter the POP3 settings. (POP3 is a way of extracting emails from your mailbox. It should be fairly easy to find out what your POP3 settings are. If you have problems, contact your email service provider).
 If you want to setup an auto reply, check on the “Send Autoreply” box and whenever someone sends an email, an autoreply will be sent.
@@ -41,7 +52,12 @@
 
 ERPNext allows you to automatically email documents on “Submission” to the contact mentioned in the document. To set this up, go to:
 
-> Setup > Email and Notifications > Auto-notifications
+> Setup > Tools > Enable / Disable Notifications.
+
+
+![Auto Notification](img/auto-notification.png)
+
+
 
 Check on the transactions you want to send via email directly on Submission and add a custom message if you want on these documents.
 ￼
@@ -55,4 +71,7 @@
 
 To setup Email Digests, go to: 
 
-> Setup > Email and Notifications > Email Digests > New Email Digest
\ No newline at end of file
+> Setup > Email Digest > New Email Digest 
+
+
+![Email Digest](img/email-digest.png)
diff --git a/docs/user/setup/docs.user.setup.global_defaults.md b/docs/user/setup/docs.user.setup.global_defaults.md
new file mode 100644
index 0000000..8066a7f
--- /dev/null
+++ b/docs/user/setup/docs.user.setup.global_defaults.md
@@ -0,0 +1,19 @@
+---
+{
+	"_label": "Global Default"
+}
+---
+Default means automatic. Something that is predefined in the system settings, occurs without change or effort, if you do not choose another option.
+
+For example, If you deal in the currency-Rupee, you can set your default global setting as Rupee. Whenever a transaction takes place in ERPNext, the system will automatically consider Rupee as the default medium of currency, unless you specify otherwise.
+
+
+> Setup > Tools > Global Settings/Defaults
+
+
+
+![Global Defaults](img/global-defaults.png)
+
+
+
+
diff --git a/docs/user/setup/docs.user.setup.letter_head.md b/docs/user/setup/docs.user.setup.letter_head.md
index 2bd1f8a..84c861a 100644
--- a/docs/user/setup/docs.user.setup.letter_head.md
+++ b/docs/user/setup/docs.user.setup.letter_head.md
@@ -5,10 +5,22 @@
 ---
 You can create / manage Letter Heads from:
 
-> Setup > Branding and Printing > Letter Heads
+> Setup > Printing > Letter Head > New Letter Head
+
+#### Step 1: Letter Head Name
+
+![Letter Head](img/letter-head1.png)
+
+
+#### Step 2 : Attach Image
+
+![Letter Head](img/letter-head2.png)
+
+
+
 
 - Create an image with your logo, brand and other information that you want to put on your letter head.
-- Attach the image in your Letter Head record and click on “Set From Image” to automatically generate the HTML required for this Letter Head.
+- Attach the image in your Letter Head record by clicking on image icon to automatically generate the HTML required for this Letter Head.
 - If you want to make this the default letter head, click on “Is Default”.
 
 Thats it! Your letter head will now appear in all Prints and Emails of documents.
diff --git a/docs/user/setup/docs.user.setup.opening.md b/docs/user/setup/docs.user.setup.opening.md
index 6b0759d..dcb2320 100644
--- a/docs/user/setup/docs.user.setup.opening.md
+++ b/docs/user/setup/docs.user.setup.opening.md
@@ -32,6 +32,14 @@
 
 Note: Make sure to set “Is Opening” as “Yes” in the More Info section.
 
+
+> Setup > Opening Accounts and Stock > Opening Accounting Entries.
+
+
+![Opening Entry](img/opening-entry.png)
+
+
+
 You can make two Opening Journal Vouchers:
 
 - For all assets (excluding Accounts Receivables): This entry will contain all your assets except the amounts you are expecting from your Customers against outstanding Sales Invoices. You will have to update your receivables by making an individual entry for each Invoice (this is because, the system will help you track the invoices which are yet to be paid). Since all the entries in this voucher will be of type “Debit”, you can credit the sum of all these debits against the “Temp Opening Liabilities” account.
@@ -63,4 +71,7 @@
 
 > Stock > Stock Reconciliation > New Stock Reconciliation
 
-and follow the steps mentioned on the page.
\ No newline at end of file
+and follow the steps mentioned on the page.
+
+
+![Stock Reconciliation](img/stock-reconciliation1.png)
diff --git a/docs/user/setup/docs.user.setup.permissions.md b/docs/user/setup/docs.user.setup.permissions.md
index 496ba97..5e35078 100644
--- a/docs/user/setup/docs.user.setup.permissions.md
+++ b/docs/user/setup/docs.user.setup.permissions.md
@@ -1,45 +1,10 @@
 ---
 {
-	"_label": "Setting up Users, Roles and Permissions"
+	"_label": "Setting up Permissions"
 }
 ---
 ERPNext has a role-based permission system, which means that you can assign Roles to Users, and permissions on Roles.
 
-## Users (Profile)
-
-Each ERPNext user has a Profile. The Profile contains the user’s email and authentication and can be set from:
-
-> Setup > Users and Permissions > Users
-
-#### Adding a new User
-￼
-To add a new user, click on “Add” button and enter the user’s
-
-- Email Id
-- First Name
-- Last Name
-- Password
-
-An invitation email will be sent to the user with the login details.
-
-#### Setting Roles
-
-ERPNext comes with a bunch of predefined roles. Each role comes with predefined permissions. See the Preset Permission Chart to find out what permission each role comes with.
-
-After creating the User, you can add / remove Roles for that User by clicking on “Roles” button. To find out what permission each role has, click on the “?” sign next to the Role.
-
-You can also create new Roles as you wish via
-
-> Document > Role
-
-#### Security Settings
-
-- Enabling / disabling users: You can enable or disable users. Disabled users will not be able to log in.
-- Setting login time: If login time is set, users can only log-in within the defined hours as per your timezone.
-- Change Password: You can update the user’s password by setting the password field.
-
-## Permissions
-
 ERPNext has a very powerful permission structure that will allow you to set permissions right up to the field level.
 
 Permissions are applied on:
@@ -56,6 +21,11 @@
 
 > Setup > Users and Permissions > Permission Manager
 
+![Permission Manager](img/permission-manager.png)
+
+
+
+
 ## Using the Permission Manager
 
 The Permission Manager is an easy way to set / unset permission rules. The Permission Manager allows you to monitor rules per Document Type.
diff --git a/docs/user/setup/docs.user.setup.print_headings b/docs/user/setup/docs.user.setup.print_headings
new file mode 100644
index 0000000..612bdf8
--- /dev/null
+++ b/docs/user/setup/docs.user.setup.print_headings
@@ -0,0 +1,36 @@
+---
+{
+	"_label": "Print Headings"
+}
+---
+Print Headings are the names which you can give to your sales invoices, supplier quotations etc. You can create a list of names for different business communications.
+
+You can create print headings from :
+
+> Setup > Printing > Print Heading > New Print Heading
+
+ 
+
+![Print Heading](img/print-heading1.png)
+
+
+
+
+Example of a change in print heading is shown below:
+
+![Print Heading](img/print-heading2.png)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/user/setup/docs.user.setup.print_headings.md b/docs/user/setup/docs.user.setup.print_headings.md
new file mode 100644
index 0000000..612bdf8
--- /dev/null
+++ b/docs/user/setup/docs.user.setup.print_headings.md
@@ -0,0 +1,36 @@
+---
+{
+	"_label": "Print Headings"
+}
+---
+Print Headings are the names which you can give to your sales invoices, supplier quotations etc. You can create a list of names for different business communications.
+
+You can create print headings from :
+
+> Setup > Printing > Print Heading > New Print Heading
+
+ 
+
+![Print Heading](img/print-heading1.png)
+
+
+
+
+Example of a change in print heading is shown below:
+
+![Print Heading](img/print-heading2.png)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/user/setup/docs.user.setup.series.md b/docs/user/setup/docs.user.setup.series.md
index 695cf77..955bded 100644
--- a/docs/user/setup/docs.user.setup.series.md
+++ b/docs/user/setup/docs.user.setup.series.md
@@ -1,6 +1,6 @@
 ---
 {
-	"_label": "Creating Numbering Series"
+	"_label": "Document Naming Series"
 }
 ---
 Data records are broadly classified as “Master” or “Transaction”. A master record is a record that has a “name”, for example a Customer, Item, Supplier, Employee etc. A Transaction is a record that has a “number”. Examples of transactions include Sales Invoices, Quotations etc. You make transactions against a number of master records.
@@ -17,7 +17,13 @@
 
 To setup a series, go to:
 
-> Setup > Customize ERPNext > Numbering Series
+> Setup > Tools > Update Numbering Series
+
+
+
+![Document Naming Series](img/naming-series.png)
+
+
 
 In this form,
 
diff --git a/docs/user/setup/docs.user.setup.sms.md b/docs/user/setup/docs.user.setup.sms.md
new file mode 100644
index 0000000..7be3d9e
--- /dev/null
+++ b/docs/user/setup/docs.user.setup.sms.md
@@ -0,0 +1,30 @@
+---
+{
+	"_label": "SMS Setting"
+}
+---
+To integrate SMS in ERPNext, approach a SMS Gateway Provider who provides HTTP API. They will create an account for you and will provide an unique username and password.
+
+To configure SMS Settings in ERPNext, find out their HTTP API (a document which describes the method of accessing their SMS interface from 3rd party applications). In this document, you will get an URL which is used to send the SMS using HTTP request. Using this URL, you can configure SMS Settings in ERPNext.
+
+Example URL: <br>
+<pre>http://instant.smses.com/web2sms.php?username=&lt;USERNAME>&password=&lt;PASSWORD>&to=&lt;MOBILENUMBER>&sender=&lt;SENDERID>&message=&lt;MESSAGE>
+</pre>
+
+![SMS Settings](img/sms-settings2.jpg)
+
+
+
+
+> Note: the characters up to the "?" are the SMS Gateway URL
+
+Example:
+<pre>http://instant.smses.com/web2sms.php?username=abcd&password=abcd&to=9900XXXXXX&sender
+=DEMO&message=THIS+IS+A+TEST+SMS</pre>
+
+The above URL will send SMS from account abcd to mobile number 9900XXXXXX with sender ID as DEMO with text message as THIS IS A TEST SMS
+
+Note that some parameters in the URL are static.You will get static values from your SMS Provider like username, password etc. These static values should be entered in the Static Parameters table.
+
+![SMS Setting](img/sms-settings1.png)
+
diff --git a/docs/user/setup/docs.user.setup.taxes.md b/docs/user/setup/docs.user.setup.taxes.md
index 84692c9..52c82bc 100644
--- a/docs/user/setup/docs.user.setup.taxes.md
+++ b/docs/user/setup/docs.user.setup.taxes.md
@@ -3,7 +3,7 @@
 	"_label": "Setting up Taxes"
 }
 ---
-One of the primary motivator for compulsory use of accounting tools is calculation of Taxes. You may or may not make money but your government will (to help your country be safe and prosperous). And if you don’t do your taxes correctly, they get very unhappy. Ok, philosophy aside, ERPNext allows you to make configurable tax templates that you can apply to your sales or purchase.
+One of the primary motivator for compulsory use of accounting tools is calculation of Taxes. You may or may not make money but your government will (to help your country be safe and prosperous). And if you don’t calculate your taxes correctly, they get very unhappy. Ok, philosophy aside, ERPNext allows you to make configurable tax templates that you can apply to your sales or purchase.
 
 ### Tax Accounts
 
@@ -17,7 +17,12 @@
 
 To create a new sales tax template called Sales Taxes and Charges Master, you have to go to:
 
-> Selling > Setup (sidebar) > Sales Taxes and Charge Master
+> Setup > Accounts > Sales Taxes and Charge Master
+
+
+![Sales Tax Master](img/sales-tax-master.png)
+
+
 
 When you create a new master, you will have to add a row for each tax type.
 
@@ -45,6 +50,7 @@
 Similar to your Sales Taxes and Charges Master is the Purchase Taxes and Charges Master.
 
 This is the tax template that you can use in your Purchase Orders and Purchase Invoices. If you have value added taxes (VAT), where you pay to the government the difference between your incoming and outgoing taxes, you can select the same Account that you use for sales taxes.
+For more details see [Purchase Taxes](docs.user.buying.purchase_taxes.html)
 
 The columns in this table are similar to the Sales Taxes and Charges Master with the difference as follows:
 
diff --git a/docs/user/setup/docs.user.setup.users.md b/docs/user/setup/docs.user.setup.users.md
new file mode 100644
index 0000000..82d79d3
--- /dev/null
+++ b/docs/user/setup/docs.user.setup.users.md
@@ -0,0 +1,47 @@
+---
+{
+	"_label": "Adding Users"
+}
+---
+
+ERPNext has a role-based permission system, which means that you can assign Roles to Users, and permissions on Roles.Each ERPNext user has a Profile. The Profile contains the user’s email and authentication and can be set from:
+
+> Setup > Users and Permissions > Users
+
+#### Step 1: Adding a new User
+
+To add a new user, click on “Add” button and enter the user’s
+
+- Email Id
+- First Name
+- Last Name
+
+![User](img/user1.png)
+
+#### Step 2: Password and Image
+
+Enter a new password and select the image of the user. Write a small description about the User under the heading Short Bio
+
+![User](img/user2.png)
+
+<br>
+> Roles will be visible only after you save the Docuemnt.
+
+
+#### Step 3 :Setting Roles and Email Settings
+
+Check the boxes which the User can access. ERPNext comes with a bunch of predefined roles. 
+Enter his email settings. The message will appear at the end of every mail. 
+
+![User](img/user3.png)
+
+#### Step 4: Security Settings
+
+- Enabling / disabling users: You can enable or disable users. Disabled users will not be able to log in.
+- Setting login time: If login time is set, users can only log-in within the defined hours as per your timezone.
+
+If you wish to give the user access to the system only between office hours, or during weekends, mention it under security settings.
+
+
+![User](img/user4.png)
+
diff --git a/docs/user/setup/docs.user.setup.workflows.md b/docs/user/setup/docs.user.setup.workflows.md
new file mode 100644
index 0000000..ff9ec42
--- /dev/null
+++ b/docs/user/setup/docs.user.setup.workflows.md
@@ -0,0 +1,30 @@
+---
+{
+	"_label": "Workflows"
+}
+---
+In order to allow multiple people to submit  multiple requests, for approvals, by multiple users, ERPNext requires you to fill the workflow conditions.
+ERPNext tracks the multiple permissions before submission.
+
+For Example, Multiple users may wish to apply for a leave. This request will be sent to the HR department. The HR department will either reject or approve. Once this process is completed, the user's Manager(leave approver) will get an indication that the HR department has accepted or rejected. Depending on the Managers approving authority, he will either override the HR request or continue to endorse it. Accordingly,the user will get his approval or rejected status. 
+
+To make this Workflow and transition rules go to :
+
+ > Setup > Workflow > New Workflow
+
+
+#### Step 1: Enter the different states of Leave Approval Process.
+
+
+ ![Workflow](img/workflow-leave1.png)
+
+
+
+#### Step 2: Enter Transition Rules.
+
+
+![Workflow](img/workflow-leave2.png)
+
+
+Example of a Leave Application Process.
+Go to the Human Resources Module and click on Leave Application. Apply for a Leave.
diff --git a/docs/user/stock/docs.user.stock.md b/docs/user/stock/docs.user.stock.md
index 85392ea..240e44c 100644
--- a/docs/user/stock/docs.user.stock.md
+++ b/docs/user/stock/docs.user.stock.md
@@ -1,9 +1,24 @@
 ---
 {
-	"_label": "Stock / Inventory"
+	"_label": "Stock / Inventory",
+	"_toc": [
+		"docs.user.stock.warehouse",
+		"docs.user.stock.item_group",
+		"docs.user.stock.item",
+		"docs.user.stock.serialized",
+		"docs.user.stock.purchase_receipt",
+		"docs.user.stock.delivery_note",
+		"docs.user.stock.stock_entry",
+		"docs.user.stock.material_issue",
+		"docs.user.stock.sales_return",
+		"docs.user.stock.purchase_return",
+		"docs.user.stock.projected_quantity"
+	]
 }
 ---
 
+
+
 ![Stock-Inventory](img/stock-inventory.png)
 
 
diff --git a/docs/user/support/docs.user.support.md b/docs/user/support/docs.user.support.md
index 16eefff..775c030 100644
--- a/docs/user/support/docs.user.support.md
+++ b/docs/user/support/docs.user.support.md
@@ -2,10 +2,10 @@
 {
 	"_label": "Support",
 	"_toc": [
-		"docs.user.ops.support.support_ticket",
-		"docs.user.ops.support.customer_issue",
-		"docs.user.ops.support.maintenance_visit",
-		"docs.user.ops.support.maintenance_schedule"
+		"docs.user.support.support_ticket",
+		"docs.user.support.customer_issue",
+		"docs.user.support.maintenance_visit",
+		"docs.user.support.maintenance_schedule"
 	]
 }
 ---
