diff --git a/docs/user/docs.user.md b/docs/user/docs.user.md
index 1bf6394..03c0a73 100644
--- a/docs/user/docs.user.md
+++ b/docs/user/docs.user.md
@@ -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,7 @@
 		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)
@@ -74,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)
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
index c57f17c..03001b7 100644
--- a/docs/user/hr/docs.user.hr.attendance.md
+++ b/docs/user/hr/docs.user.hr.attendance.md
@@ -4,3 +4,23 @@
 }
 ---
 
+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 4c99fdb..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
diff --git a/docs/user/hr/docs.user.hr.leave.md b/docs/user/hr/docs.user.hr.leave.md
index b637569..b5dbba6 100644
--- a/docs/user/hr/docs.user.hr.leave.md
+++ b/docs/user/hr/docs.user.hr.leave.md
@@ -4,28 +4,27 @@
 }
 ---
 
-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.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/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/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)
+
