diff --git a/erpnext/docs/assets/img/human-resources/created-payroll.png b/erpnext/docs/assets/img/human-resources/created-payroll.png
new file mode 100644
index 0000000..2465e64
--- /dev/null
+++ b/erpnext/docs/assets/img/human-resources/created-payroll.png
Binary files differ
diff --git a/erpnext/docs/assets/img/human-resources/payroll-entry.png b/erpnext/docs/assets/img/human-resources/payroll-entry.png
new file mode 100644
index 0000000..345eef8
--- /dev/null
+++ b/erpnext/docs/assets/img/human-resources/payroll-entry.png
Binary files differ
diff --git a/erpnext/docs/assets/img/human-resources/payroll-journal-entry.png b/erpnext/docs/assets/img/human-resources/payroll-journal-entry.png
new file mode 100644
index 0000000..2e4f05e
--- /dev/null
+++ b/erpnext/docs/assets/img/human-resources/payroll-journal-entry.png
Binary files differ
diff --git a/erpnext/docs/assets/img/human-resources/payroll-make-bank-entry.png b/erpnext/docs/assets/img/human-resources/payroll-make-bank-entry.png
new file mode 100644
index 0000000..89873ec
--- /dev/null
+++ b/erpnext/docs/assets/img/human-resources/payroll-make-bank-entry.png
Binary files differ
diff --git a/erpnext/docs/user/manual/en/human-resources/employee-advance.md b/erpnext/docs/user/manual/en/human-resources/employee-advance.md
index 4e07611..621c8d5 100644
--- a/erpnext/docs/user/manual/en/human-resources/employee-advance.md
+++ b/erpnext/docs/user/manual/en/human-resources/employee-advance.md
@@ -14,7 +14,7 @@
 
 Employee Advance record can be created by any employee but they cannot submit the record. 
 
-After saving Employee Advance, Employee should [Assign document to Approver](/docs/user/manual/en/using-eprnext/assignment.html). On assignment, approving user will also receive email notification. To automate email notification, you can also setup [Email Alert](/docs/user/manual/en/setting-up/email/email-alerts.html).
+After saving Employee Advance, Employee should [Assign document to Approver](/docs/user/manual/en/using-erpnext/assignment.html). On assignment, approving user will also receive email notification. To automate email notification, you can also setup [Email Alert](/docs/user/manual/en/setting-up/email/email-alerts.html).
 
 After verification, approver can submit the Employee Advance form or reject the request.
 
diff --git a/erpnext/docs/user/manual/en/human-resources/index.md b/erpnext/docs/user/manual/en/human-resources/index.md
index 5191505..120b64c 100644
--- a/erpnext/docs/user/manual/en/human-resources/index.md
+++ b/erpnext/docs/user/manual/en/human-resources/index.md
@@ -2,7 +2,7 @@
 
 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
-Process Payroll to generate Salary Slips. Most countries have complex tax
+Payroll Entry 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
diff --git a/erpnext/docs/user/manual/en/human-resources/index.txt b/erpnext/docs/user/manual/en/human-resources/index.txt
index 04abb85..327d05f 100644
--- a/erpnext/docs/user/manual/en/human-resources/index.txt
+++ b/erpnext/docs/user/manual/en/human-resources/index.txt
@@ -4,6 +4,7 @@
 expense-claim
 attendance
 salary-and-payroll
+payroll-entry
 appraisal
 job-applicant
 job-opening
diff --git a/erpnext/docs/user/manual/en/human-resources/payroll-entry.md b/erpnext/docs/user/manual/en/human-resources/payroll-entry.md
new file mode 100644
index 0000000..4414bc2
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/payroll-entry.md
@@ -0,0 +1,49 @@
+# Payroll Entry
+
+You can also create salary slip for multiple employees using Payroll Entry:
+
+> Human Resources > Payroll Entry
+
+<img class="screenshot" alt="Payroll Entry" src="/docs/assets/img/human-resources/payroll-entry.png">
+
+In Payroll Entry,
+
+  1. Select the Company for which you want to create the Salary Slips. You can also select the other fields like Branch, Department, Designation or Project to be more specific.
+  2. Check "Salary Slip based on Timesheet" if you want to process timesheet based Salary Slips.
+  3. Select the Start Date and End Date or Fiscal year and month for which you want to create the Salary Slips.
+  4. Click on "Get Employee Details" to get a list of Employees for which the Salary Slips will be created based on the selected criteria.
+  5. Select the Cost Center and Payment Account.
+  6. Save the form and Submit it to create Salary Slip records for each active Employee for the time period selected. If the Salary Slips are already created, the system will not create any more Salary Slips. You can also just save the form as Draft and create the Salary Slips later.
+
+<img class="screenshot" alt="Payroll Entry" src="/docs/assets/img/human-resources/created-payroll.png">
+
+Once all Salary Slips are created, you can check by clicking on "View Salary Slips", if they are created correctly or edit it if you want to deduct Leave Without Pay (LWP).
+
+After checking, you can "Submit" them all together by clicking on "Submit Salary Slip".
+
+### Booking Salaries in Accounts
+
+The final step is to book the Salaries in your Accounts.
+
+Salaries in businesses are usually dealt with extreme privacy. In most cases,
+the companies issues a single payment to the bank combining all salaries and
+the bank distributes the salaries to each employee’s salary account. This way
+there is only one payment entry in the company’s books of accounts and anyone
+with access to the company’s accounts will not have access to the individual
+salaries.
+
+The salary payment entry is a Journal Entry that debits the total of the
+earning type salary component and credits the total of deduction type salary 
+component of all Employees to the default account set at Salary Component level 
+for each component.
+
+To generate your salary payment voucher from Payroll Entry, click on, 
+> Make > Bank Entry
+
+<img class="screenshot" alt="Payroll Entry" src="/docs/assets/img/human-resources/payroll-make-bank-entry.png">
+
+It will ask to enter the Bank Transaction Reference Number and date. All other details will be auto-filled according to your Payroll Entry form. Click on Save and create it.
+
+<img class="screenshot" alt="Payroll Entry" src="/docs/assets/img/human-resources/payroll-journal-entry.png">
+
+{next}
diff --git a/erpnext/docs/user/manual/en/human-resources/salary-and-payroll.md b/erpnext/docs/user/manual/en/human-resources/salary-and-payroll.md
index e902617..1f078ff 100644
--- a/erpnext/docs/user/manual/en/human-resources/salary-and-payroll.md
+++ b/erpnext/docs/user/manual/en/human-resources/salary-and-payroll.md
@@ -7,7 +7,7 @@
 To process Payroll in ERPNext,
 
   1. Create Salary Structures for all Employees.
-  2. Generate Salary Slips via Process Payroll.
+  2. Generate Salary Slips via [Payroll Entry](/docs/user/manual/en/human-resources/payroll-entry.html).
   3. Book the Salary in your Accounts.
 
 ### Salary Structure
@@ -115,7 +115,7 @@
 ### Creating Salary Slips
 
 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 Process Payroll.
+form or you can process your payroll for the month using Payroll Entry.
 
 To create a new Salary Slip go to:
 
@@ -125,48 +125,4 @@
 
 <img class="screenshot" alt="Salary Slip" src="/docs/assets/img/human-resources/salary-slip.png">
 
-You can also create salary slip for multiple employees using Process Payroll:
-
-> Human Resources > Process Payroll
-
-#### Figure 3: Process Payroll
-
-<img class="screenshot" alt="Process Payroll" src="/docs/assets/img/human-resources/process-payroll.png">
-
-In Process Payroll,
-
-  1. Select the Company for which you want to create the Salary Slips.
-  2. Check "Salary Slip based on Timesheet" if you want to process timesheet based Salary Slips.
-  3. Select the From Date and To Date or Fiscal year and month for which you want to create the Salary Slips.
-  3. Select the Payment Account.
-  3. Click on “Create Salary Slips”. This will create Salary Slip records for each active Employee for the time period selected. If the Salary Slips are created, the system will not create any more Salary Slips. All updates will be shown in the “Activity Log” section.
-  4. Once all Salary Slips are created, you can check if they are created correctly or edit it if you want to deduct Leave Without Pay (LWP).
-  5. After checking, you can “Submit” them all together by clicking on “Submit Salary Slips”. 1. If you want them to be automatically emailed to the Employee, make sure to check the “Send Email” box.
-
-### Booking Salaries in Accounts
-
-The final step is to book the Salaries in your Accounts.
-
-Salaries in businesses are usually dealt with extreme privacy. In most cases,
-the companies issues a single payment to the bank combining all salaries and
-the bank distributes the salaries to each employee’s salary account. This way
-there is only one payment entry in the company’s books of accounts and anyone
-with access to the company’s accounts will not have access to the individual
-salaries.
-
-The salary payment entry is a Journal Entry that debits the total of the
-earning type salary component and credits the total of deduction type salary 
-component of all Employees to the default account set at Salary Component level 
-for each component.
-
-To generate your salary payment voucher from Process Payroll, click on
-“Make Bank Entry”. It will ask to enter the Bank Transaction Reference Number and date.
-Click on "Make" and a new Journal Entry with the total salary components will be
-created.
-
-#### Figure 3.1: Make Bank Entry
-
-<img class="screenshot" alt="Process Payroll" src="/docs/assets/img/human-resources/bank-entry.png">
-
-
 {next}
diff --git a/erpnext/docs/user/manual/en/introduction/concepts-and-terms.md b/erpnext/docs/user/manual/en/introduction/concepts-and-terms.md
index c53bef9..dc3db10 100644
--- a/erpnext/docs/user/manual/en/introduction/concepts-and-terms.md
+++ b/erpnext/docs/user/manual/en/introduction/concepts-and-terms.md
@@ -302,11 +302,11 @@
 
 > Human Resource > Leave and Attendance > Leave Type
 
-#### Process Payroll
+#### Payroll Entry
 
 A tool that helps in creation of multiple Salary Slips for Employees.
 
-> Human Resource > Salary and Payroll > Process Payroll
+> Human Resource > Payroll Entry
 
 #### Salary Slip
 
