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..03c0a73 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",
@@ -48,7 +48,7 @@
 	1. [Email Settings](docs.user.setup.email.html)
 	1. [SMS Settings](docs.user.setup.sms.html)
 	1. [Setting up Taxes](docs.user.setup.taxes.html)
-	1. [Price Lists](docs.user.setup.price_lists.html)
+	1. [Price Lists](docs.user.setup.price_list.html)
 	1. [Adding Opening Entries](docs.user.setup.opening.html)
 	1. [POS Setting](docs.user.setup.pos_setting.html)
 	1. [Third Party Backups](docs.user.setup.third_party_backups.html)	
@@ -60,7 +60,8 @@
 		1. [Sales Person](docs.user.selling.sales_person.html)
 		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. [Price Lists](docs.user.setup.price_list.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)
@@ -73,7 +74,7 @@
 	1. [Supplier Quotation](docs.user.buying.supplier_quotation.html)
 	1. [Purchase Order](docs.user.buying.purchase_order.html)
 	1. [Purchase Taxes](docs.user.buying.purchase_taxes.html)
-	1. [Price Lists](docs.user.setup.price_lists.html)
+	1. [Price Lists](docs.user.setup.price_list.html)
 	1. [Sub Contracting](docs.user.stock.sub_contracting.html)
 1. [Stock (Inventory)](docs.user.stock.html)
 	1. [Warehouse](docs.user.stock.warehouse.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.appraisal.md b/docs/user/hr/docs.user.hr.appraisal.md
index a02ba11..5737256 100644
--- a/docs/user/hr/docs.user.hr.appraisal.md
+++ b/docs/user/hr/docs.user.hr.appraisal.md
@@ -5,6 +5,25 @@
 ---
 In ERPNext, you can manage Employee Appraisals by creating an Appraisal Template for each role with the parameters that define the performance by giving appropriate weightage to each parameter.
 
+> HR > Appraisal > New Appraisal
+
+
+
+#### Step 1: Select an Appraisal Template
+
+
+![Appraisal](img/appraisal-1.png)
+
+
+After you select the template, the remaining form appears.
+
+
+#### Step 2: Enter Employee Details
+
+![Appraisal](img/appraisal-2.png)
+
+
+
 Once the Appraisal Template is completed, you can create Appraisal records for each period where you track performance. You can give points out of 5 for each parameter and the system will calculate the overall performance of the Employee.
 
 To make the Appraisal final, make sure to “Submit” it.
\ 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..03001b7
--- /dev/null
+++ b/docs/user/hr/docs.user.hr.attendance.md
@@ -0,0 +1,26 @@
+---
+{
+	"_label": "Attendance"
+}
+---
+
+An Attendance record stating that an Employee has been present on a particular day can be created manually by:
+
+> HR > Attendance > New Attendance
+￼
+
+![Attendance](img/attendance.png)
+
+
+
+
+It can also be done by collecting attendance information via an automated system like a swipe card. You can even upload a CSV file with the attendance information. 
+
+You can get a monthly report of your Attendance data by going to the “Monthly Attendance Details” report.
+
+To upload the attendance go to:
+
+> HR > Upload Attendance 
+
+![Upload Attendance](img/upload-attendance.png)
+
diff --git a/docs/user/hr/docs.user.hr.employee.md b/docs/user/hr/docs.user.hr.employee.md
index f63b9ac..16ee8cd 100644
--- a/docs/user/hr/docs.user.hr.employee.md
+++ b/docs/user/hr/docs.user.hr.employee.md
@@ -5,17 +5,43 @@
 ---
 There are many fields you can add in your Employee records. As the organisation grows, it becomes difficult to manage more records. It is advisable to keep updating and entering records to facilitate data management of employees.
 
-Employee records also help in keeping a list of your team’s skills, previous employment history and also emergency information.
+Employee records also help in keeping a list of your team’s skills, previous employment history and  emergency information.
 
 To create new Employee go to:
 
 > HR > Employee > New Employee 
 
+#### Step 1: Capture basic information and Employement Details.
+
+
+![Employee Master](img/employee-master-1.png)
+
+<br>
+
+
+#### Step 2: Complete Job Profile and Organisation Profile.
+
+
+![Employee Master](img/employee-master-2.png)
+
+
+
+<br>
+
+
+#### Step 3: Update contact details, personal details, and previous employement details.
+
+
+
+![Employee Master](img/employee-master-3.png)
+
+
+
 ### Numbering Employees (Employee ID)
 
 By default, in ERPNext Employee Records are Numbered. You can have multiple series if you are a really large company and want to have separate numbering series for separate locations etc. You can set the numbering series just like any other transaction by going to:
 
-> Setup > Customize ERPNext > Numbering Series.
+> Setup > Customize  > Document Numbering Series.
 
 Alternatively, you can create employees by the “Employee Number” field if you already have an existing Employee Numbering system you want to follow. To set this, go to
 
diff --git a/docs/user/hr/docs.user.hr.expense_claim.md b/docs/user/hr/docs.user.hr.expense_claim.md
index 53218b2..06bb8eb 100644
--- a/docs/user/hr/docs.user.hr.expense_claim.md
+++ b/docs/user/hr/docs.user.hr.expense_claim.md
@@ -9,6 +9,12 @@
 
 > HR > Expense Claim > New Expense Claim
 
+
+![Expense Claim](img/expense-claim.png)
+
+
+
+
 Set the Employee ID, date and the list of expenses that are to be claimed and “Submit” the record.
 
 ### Approving Expenses
@@ -21,4 +27,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..b5dbba6 100644
--- a/docs/user/hr/docs.user.hr.leave.md
+++ b/docs/user/hr/docs.user.hr.leave.md
@@ -1,31 +1,30 @@
 ---
 {
-	"_label": "Leave and Attendance"
+	"_label": "Leave"
 }
 ---
 
-An Attendance record stating that an Employee has been present on a particular day can be created either manually by:
-
-> HR > Attendance > New Attendance
-￼
-Or if you are collecting attendance information via an automated system like a swipe card, then you can upload a CSV file with the attendance information. 
-
-You can get a monthly report of your Attendance data by going to the “Monthly Attendance Details” report.
-
-To upload the attendance go to:
-
-> HR > Upload Attendance (sidebar)
-
----
-
 ### Leave Allotment
 
-Fixed number of leaves per Employee can be allocated using the Leave Allocation Tool. If you have special leaves to be allocated, you can also allocate them manually by create new Leave Allocation records.
+Fixed number of leaves per Employee can be allocated using the Leave Allocation Tool. If you have special leaves to be allocated, you can also allocate them manually by creating new Leave Allocation records.
+
+> HR > Leave Allocation > New Leave Allocation
+
+![Leave ALlocation](img/leave-allocation.png)
 
 ---
 
 ### Leave Application
 
-If your company has a formal system where Employees have to apply for leaves and only if their leaves are approved they are considered as paid leaves, you can create Leave Application to track approval and usage of leaves. You have to mention the Employee, Leave Type and the period for which the leave is taken. If you want only certain users to approve leaves, you can give “Submission” rights to those users only.
+If your company has a formal system where Employees have to apply for leaves to be able to qualify as paid leaveas, you can create Leave Application to track approval and usage of leaves. You have to mention the Employee, Leave Type and the period for which the leave is taken. If you want specific users to approve leaves, you can give “Submission” rights to those users only.
 
-If you want all users to create their own Leave Applications, you can set their “Employee ID” as a match rule in the Leave Application Permission settings. See the earlier discussion on permission settings for more info.
+> HR > Leave Application > Make New Leave Application
+
+
+![New Leave Application](img/new-leave-application.png)
+
+
+
+If you want all users to create their own Leave Applications, you can set their “Employee ID” as a match rule in the Leave Application Permission settings. See the earlier discussion on permission settings for more info. [Permissions](docs.user.setup.permissions.html)
+
+
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/hr/docs.user.hr.payroll.md b/docs/user/hr/docs.user.hr.payroll.md
index a2ad250..598be00 100644
--- a/docs/user/hr/docs.user.hr.payroll.md
+++ b/docs/user/hr/docs.user.hr.payroll.md
@@ -13,7 +13,11 @@
 
 The Salary Structure represents how Salaries are calculated based on Earnings and Deductions. To create a new Salary Structure go to:
 
-> HR > Salary and Payroll > Salary Structure > New Salary Structure
+> HR > Salary Structure > New Salary Structure
+
+
+![Salary Structure](img/salary-structure.png)
+s
 
 ### In the Salary Structure,
 
@@ -31,9 +35,24 @@
 
 ### Creating Salary Slips
 
-Once the Salary Structure is created, you can process your payroll for the month using the Salary Manager
+Once the Salary Structure is created, you can make a salary slip from the same form or you can process your payroll for the month using the Salary Manager.
 
-> HR > Salary and Payroll > Process Payroll
+To create a salary slip from Salary Structure, click on the button Make Salary Slip.
+
+
+![Salary Slip](img/salary-slip-1.png)
+
+<br>
+
+
+Through Salary Manager:
+
+> HR > Process Payroll
+
+
+![Salary Manager](img/salary-manager.png)
+
+
 
 In the Salary Manager tool,
 
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.price_list.md b/docs/user/setup/docs.user.setup.price_list.md
index 0103cc3d..021df09 100644
--- a/docs/user/setup/docs.user.setup.price_list.md
+++ b/docs/user/setup/docs.user.setup.price_list.md
@@ -3,13 +3,19 @@
 	"_label": "Price Lists"
 }
 ---
+A Price List is a place where different rate plans can be stored. It’s a name you give to a set of Item Prices stored under a particular Price List.
 
-Price List is a  table of sale price for an Item. An Item can have multiple prices based on customer, currency, region, shipping cost etc. 
+An Item can have multiple prices based on customer, currency, region, shipping cost etc, which can be stored as different rate plans. In ERPNext, you are required to store all the lists seperately. Buying Price List is different from Selling Price List and thus is stored separately. 
 
-A Price List is a place where different rate plans can be stored. It’s a name you can give to a set of Item prices. In case you have different zones (based on the shipping costs), for different currencies etc, you can maintain different Price Lists.You can maintain a Price List for your international customers with USD as transacting currency.
+> Selling > Price List
 
 
 ![Price-List](img/price-lists.png)
 
 
- A Price List is formed when you create different Item Prices. To import Item Price visit “Import Item Price”.
\ No newline at end of file
+> For multiple currencies, maintain multiple Price Lists.
+
+
+To add a new Item to the Price List, add the Item Code and its rate in the Item Prices table.
+
+You can also import Item Prices via [Data Import Tool](docs.user.setup.data_import.html)
\ No newline at end of file
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..64892b9
--- /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-setting2.jpg)
+
+
+
+
+> Note: the string up to the "?" is 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..c7c320a
--- /dev/null
+++ b/docs/user/setup/docs.user.setup.workflows.md
@@ -0,0 +1,52 @@
+---
+{
+	"_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.
+
+Example of a leave application workflow is given below:
+
+If an user  applies for a leave, then his request will be sent to the HR department. The HR department(HR User) will either reject or approve this request. Once this process is completed, the user's Manager(leave approver) will get an indication that the HR department has Accepted or Rejected. The Manager, who is the approving authority, will either Approve or Reject this request. Accordingly,the user will get his Approved or Rejected status. 
+
+![Workflow](img/workflow-leave-fl.jpg)
+
+
+
+
+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.
+
+When a Leave Application is submitted, the status on the right hand corner of the page shows as "Applied"
+
+![Workflow Employee LA](img/workflow-employee-la.png)
+
+When the HR User logs in,  he can either Approve or Reject. If approved the status on the right hand corner of the page shows as Approved. However, a blue band of information is displayed saying approval is pending by leave approver.
+
+![Leave Approver](img/workflow-hr-user-la.png)
+
+
+When the leave approver opens the Leave Application page, he should select the status and convert to Approved or Rejected.
+
+![Workflow Leave Approver](img/workflow-leave-approver-la.png)
+
+
diff --git a/docs/user/stock/docs.user.stock.item_group.md b/docs/user/stock/docs.user.stock.item_group.md
index aca2a78..22be9ae 100644
--- a/docs/user/stock/docs.user.stock.item_group.md
+++ b/docs/user/stock/docs.user.stock.item_group.md
@@ -4,6 +4,12 @@
 }
 ---
 
-Item Group is the classification category. Depending on the type of product, you have to categorise it under its respective field. If the product is service oriented, you have to name it under the group head Service. If the product is used as a raw-material, you have to name it under the Raw-material category. In case, your product is used only in trading, you can categorise it under Trading. 
+Item Group is the classification category. Depending on the type of product, you have to categorise it under its respective field. If the product is service oriented, you have to name it under the group head service. If the product is used as a raw-material, you have to name it under the Raw-material category. In case, your product is used only in trading, you can categorise it under Trading. 
 
-You can also create your own groups . Go to Setup- Master Data- Item Group- Item Group Tree- Add Child.
+You can also create your own Item groups .
+
+> Stock > Item Group
+
+
+![Item Group](img/item-group-tree.png)
+
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"
 	]
 }
 ---
