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.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.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.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.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/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"
 	]
 }
 ---
