diff --git a/erpnext/docs/assets/img/human-resources/earned-leave.png b/erpnext/docs/assets/img/human-resources/earned-leave.png
new file mode 100644
index 0000000..8a365b6
--- /dev/null
+++ b/erpnext/docs/assets/img/human-resources/earned-leave.png
Binary files differ
diff --git a/erpnext/docs/assets/img/human-resources/employee-grade.png b/erpnext/docs/assets/img/human-resources/employee-grade.png
new file mode 100644
index 0000000..931f6bf
--- /dev/null
+++ b/erpnext/docs/assets/img/human-resources/employee-grade.png
Binary files differ
diff --git a/erpnext/docs/assets/img/human-resources/employee-leave-policy.png b/erpnext/docs/assets/img/human-resources/employee-leave-policy.png
new file mode 100644
index 0000000..10d11b8
--- /dev/null
+++ b/erpnext/docs/assets/img/human-resources/employee-leave-policy.png
Binary files differ
diff --git a/erpnext/docs/assets/img/human-resources/leave-encashment.png b/erpnext/docs/assets/img/human-resources/leave-encashment.png
new file mode 100644
index 0000000..f537ddc
--- /dev/null
+++ b/erpnext/docs/assets/img/human-resources/leave-encashment.png
Binary files differ
diff --git a/erpnext/docs/assets/img/human-resources/leave-period-1.png b/erpnext/docs/assets/img/human-resources/leave-period-1.png
new file mode 100644
index 0000000..0079dbe
--- /dev/null
+++ b/erpnext/docs/assets/img/human-resources/leave-period-1.png
Binary files differ
diff --git a/erpnext/docs/assets/img/human-resources/leave-period-2.png b/erpnext/docs/assets/img/human-resources/leave-period-2.png
new file mode 100644
index 0000000..7d79133
--- /dev/null
+++ b/erpnext/docs/assets/img/human-resources/leave-period-2.png
Binary files differ
diff --git a/erpnext/docs/assets/img/human-resources/leave-period-grant.png b/erpnext/docs/assets/img/human-resources/leave-period-grant.png
new file mode 100644
index 0000000..f9193d0
--- /dev/null
+++ b/erpnext/docs/assets/img/human-resources/leave-period-grant.png
Binary files differ
diff --git a/erpnext/docs/assets/img/human-resources/leave-policy.png b/erpnext/docs/assets/img/human-resources/leave-policy.png
new file mode 100644
index 0000000..6fdc686
--- /dev/null
+++ b/erpnext/docs/assets/img/human-resources/leave-policy.png
Binary files differ
diff --git a/erpnext/docs/assets/img/human-resources/new-leave-type.png b/erpnext/docs/assets/img/human-resources/new-leave-type.png
index 3004b09..78fd04f 100644
--- a/erpnext/docs/assets/img/human-resources/new-leave-type.png
+++ b/erpnext/docs/assets/img/human-resources/new-leave-type.png
Binary files differ
diff --git a/erpnext/docs/user/manual/en/human-resources/index.md b/erpnext/docs/user/manual/en/human-resources/index.md
index 120b64c..34b0c83 100644
--- a/erpnext/docs/user/manual/en/human-resources/index.md
+++ b/erpnext/docs/user/manual/en/human-resources/index.md
@@ -5,7 +5,7 @@
 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
+from employee payroll. ERPNext allows to accommodate all types of taxes and
 their calculation.
 
 It also maintains a complete employee database including contact information,
diff --git a/erpnext/docs/user/manual/en/human-resources/leave-application.md b/erpnext/docs/user/manual/en/human-resources/leave-application.md
index c735a6b..4472964 100644
--- a/erpnext/docs/user/manual/en/human-resources/leave-application.md
+++ b/erpnext/docs/user/manual/en/human-resources/leave-application.md
@@ -5,13 +5,13 @@
 track approval and usage of leaves. You have to mention the Employee, Leave
 Type and the period for which the leave is taken.
 
-> Human Resources > Leave Application > New Leave Application
+> Human Resources > Leaves and Holiday > Leave Application > New Leave Application
 
 <img class="screenshot" alt="Leave Application" src="{{docs_base_url}}/assets/img/human-resources/leave-application.png">
 
 ###Setting Leave Approver
 
-* A leave approver is a user who can approve an leave application for an employee. 
+* A leave approver is a user who can approve an leave application for an employee.
 
 * You need to mention a list of Leave Approvers against an Employee in the Employee Master.
 
@@ -22,11 +22,11 @@
 settings. See the earlier discussion on [Setting Up Permissions](/docs/user/manual/en/setting-up/users-and-permissions/user-permissions.html)
 for more info.
 
-You assign Leaves aginast an Employee check [Leave Allocation](/docs/user/manual/en/human-resources/leave.html)
+To understand how ERPNext allows you configure leaves for employees, check [Leaves - Overview](/docs/user/manual/en/human-resources/leave.html)
 
 <div class="embed-container">
     <iframe src="https://www.youtube.com/embed/fc0p_AXebc8?rel=0" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
     </iframe>
 </div>
 
-{next}
\ No newline at end of file
+{next}
diff --git a/erpnext/docs/user/manual/en/human-resources/leave.md b/erpnext/docs/user/manual/en/human-resources/leave.md
index 5b32a2b..6ab67ce 100644
--- a/erpnext/docs/user/manual/en/human-resources/leave.md
+++ b/erpnext/docs/user/manual/en/human-resources/leave.md
@@ -1,29 +1,48 @@
-#Overview
-This section enables you to manage leave schedule of your organization. It also explains the way employees can apply for leaves.  
-Employees create leave request and manager (leave approver) approves or rejects the request. You can select from a number of leave types such as sick leave, casual leave, privilege leave and so on. You can also allocate leaves to your employees and generate reports to track leaves record.
+#Leaves - Overview
+This section will help you understand how ERPNext enables you to effectively manage the leave schedule of your organization. It also explains the way employees can apply for leaves.
+Employees create leave requests, which their respective managers (leave approver) can approve or reject. An Employee can select from a number of leave types such as sick leave, casual leave, privilege leave and so on. The number and type of leaves an Employee can apply is controlled by Leave Allocations. You can create Leave Allocations for a Leave Period based on the company's Leave Policy. You can also allocate additional leaves to your employees and generate reports to track leaves taken by Employees.
 
 ---
 
 #Leave Type
+> Human Resources > Leaves and Holiday > Leave Type > New Leave Type
 
-> Human Resources > Setup > Leave Type > New Leave Type
-
-Leave Type refers to types of leave allotted to an employee by a company. An employee can select a particular Leave Type while requesting for a leave. You can create any number of Leave Types based on your company’s 
+Leave Type refers to types of leave allotted to an employee by a company. An employee can select a particular Leave Type while requesting for a leave. You can create any number of Leave Types based on your company’s
 requirement.
 
-<img class="screenshot" alt="New Leave Type" 
+<img class="screenshot" alt="New Leave Type"
 	src="{{docs_base_url}}/assets/img/human-resources/new-leave-type.png">
 
-**Max Days Leave Allowed:** It refers to maximum number of days this particular Leave Type can be availed at a stretch. If an employee exceeds the maximum number of days under a particular Leave Type, his/her extended leave may be considered as ‘Leave Without Pay’ and this may affect his/her salary calculation.
+**Max Leaves Allowed:** This field allows you to set the maximum number of leaves of this Leave Type that Employees can apply within a Leave Period.
+
+**Applicable After (Working Days):** Employees who have worked with the company for this number of days are only allowed to apply for this Leave Type. Do note that any other leaves availed by the Employee after her joining date is also considered while calculating working days.
+
+**Maximum Continuous Days Applicable:** It refers to maximum number of days this particular Leave Type can be availed at a stretch. If an employee exceeds the maximum number of days under a particular Leave Type, his/her extended leave may be considered as ‘Leave Without Pay’ and this may affect his/her salary calculation.
 
 **Is Carry Forward:** If checked, the balance leave will be carried forwarded to the next allocation period.
 
-**Is Leave Without Pay:** This ensures that the Leave Type will be treated as leaves whithout pay and salary will get deducted for this Leave Type.
+**Is Leave Without Pay:** This ensures that the Leave Type will be treated as leaves without pay and salary will get deducted for this Leave Type.
 
-**Allow Nagative Balance:** If checked, system will always allow to approve leave application for the Leave Type, even if there is no leave balance.
+**Allow Negative Balance:** If checked, system will always allow to approve leave application for the Leave Type, even if there is no leave balance.
 
 **Include holidays within leaves as leaves:** Check this option if you wish to count holidays within leaves as a ‘leave’. Such holidays will be deducted from the total number of leaves.
 
+**Is Compensatory:** Compensatory leaves are leaves granted for working overtime or on holidays, normally compensated as an encashable leave. You can check this option to mark the Leave Type as compensatory. An Employee can request for compensatory leaves (Compensatory Leave Request) and on approval of such requests, Leave Allocations are created allowing her to apply for leaves of this type later on.
+
+**Is Optional:** Check this Optional Leaves are holidays which Employees can choose to avail from a list of holidays published by the company. The Holiday List for optional leaves can have any number of holidays but you can restrict the number of such leaves granted to an Employee in a Leave Period by setting the Max Days Leave Allowed field.
+
+**Encashment:** It is possible that Employees can receive cash from their Employer for unused leaves granted to them in a Leave Period. Not all Leave Types need to be encashable, so you should set "Allow Encashment" for Leave Types which are encashable.
+
+<img class="screenshot" alt="Leave Encashment"
+	src="{{docs_base_url}}/assets/img/human-resources/leave-encashment.png">
+
+You can set the **Encashment Threshold Days** field so that encashment is only allowed for unused leaves older than that many days. You may also want to set the **Earning Component** for use in Salary Slip while paying out the encashed amount to Employees as part of their Salary.
+
+**Earned Leave:** Earned Leaves are leaves earned by an employee after working with the company for a certain amount of time. Checking "Is Earned Leave" will allot leaves pro rata by automatically updating Leave Allocation for leaves of this type at intervals set by **Earned Leave Frequency**. For example, if an employee earns 2 leaves of type Paid Leaves monthly, ERPNext automatically increments the Leave Allocation for Paid Leave at the end of every month by 2. The leave allotment process (background job) will only allot leaves considering the max leaves for the leave type, and will round to **Rounding** for fractions.
+
+<img class="screenshot" alt="Earned Leave"
+	src="{{docs_base_url}}/assets/img/human-resources/earned-leave.png">
+
 ###Default Leave Types
 There are some pre-loaded Leave Types in the system, as below:
 
@@ -35,30 +54,60 @@
 
 ---
 
-#Leave Allocation
+#Leave Policy
+> Human Resources > Leaves and Holiday > Leave Policy > New Leave Policy
 
-Leave Allocation enables you to allot a specific number of leaves to a particular employee. You can allocate a number of leaves to different types of leave. You also have the option to allocate leaves to your employees manually or via the Leave Allocation Tool.
+It is a practice for many enterprises to enforce a general Leave Policy to effectively track and manage Employee leaves. ERPNext allows you to create and manage multiple Leave Policies and allocate leaves to Employees as defined by the policy.
 
-###Manual Allocation
-> Human Resources > Setup > Leave Allocation > New Leave Allocation
+<img class="screenshot" alt="Leave Policy"
+	src="{{docs_base_url}}/assets/img/human-resources/leave-policy.png">
 
-To allocate leaves to an Employee, select the period and the number of leaves you want to allocate. You can also add unused leaves from previous allocation period.
+### Enforcing the Leave Policy
+To enforce the Leave Policy, you can either:
+* Apply the Leave Policy in Employee Grade
+<img class="screenshot" alt="Employee Grade"
+	src="{{docs_base_url}}/assets/img/human-resources/employee-grade.png">
 
-<img class="screenshot" alt="Manual Leave Allocation" 
+This will ensure all leave allocations for all employees of this grade will be as per the Leave Policy
+
+* Update Employee record with appropriate Leave Policy. In case you need to selectively update the Leave Policy for a particular Employee, you can do so by updating the Employee record.
+
+<img class="screenshot" alt="Employee Leave Policy"
+	src="{{docs_base_url}}/assets/img/human-resources/employee-leave-policy.png">
+
+#Leave Period
+Most companies manage leaves based on a Leave Period. ERPNext allows you to create a Leave period by going to
+> Human Resources > Leaves and Holiday > Leave Period > New Leave Period
+
+	<img class="screenshot" alt="Leave Period"
+		src="{{docs_base_url}}/assets/img/human-resources/leave-period.png">
+
+#Granting Leaves to Employees
+Leave Management in ERPNext is based on Leave Allocations created for each employee. This means, Employees can only avail as many leaves (of each Leave Type) allocated to them. There are multiple ways by which you can create Leave Allocations for Employees.
+
+###Leave Allocation
+Leave Allocation enables you to allot a specific number of leaves to a particular employee. You can allocate a number of leaves to different types of leave.
+
+###Allocating leaves for a Leave Period
+> Human Resources > Leaves and Holiday > Leave Period
+
+Leave Period helps you manage leaves for a period and also doubles up as a tool to help you grant leaves for a category of employees. The **Grant** button will generate Leave Allocations based on the Leave Policy applicable to each Employee. You can allocate leaves based on Employee Grade, Department or Designation. Also, note that **Carry Forward Leaves** check will enable you to carry forward any unused leaves (for Leave Types with Is Carry Forward turned on) from previous allocations to new ones.
+
+<img class="screenshot" alt="Grant Leaves from Leave Period"
+	src="{{docs_base_url}}/assets/img/human-resources/leave-period-grant.png">
+
+###Manual Allocation of leaves
+> Human Resources > Leaves and Holiday > Leave Allocation > New Leave Allocation
+
+To manually allocate leaves for an Employee, select the period and the number of leaves you want to allocate. You can also add unused leaves from previous allocation period.
+
+<img class="screenshot" alt="Manual Leave Allocation"
 	src="{{docs_base_url}}/assets/img/human-resources/manual-leave-allocation.png">
 
-###Via Leave Allocation Tool
-> Human Resources > Tools > Leave Allocation Tool
-
-This tool enables you to allocate leaves for a category of employees, instead of individual ones. You can allocate leaves based on Employee Type, Branch, Department and Designation. Leave Allocation Tool is also known as Leave Control Panel.
-
-<img class="screenshot" alt="Leave Allocation Tool"
-	src="{{docs_base_url}}/assets/img/human-resources/leave-allocation-tool.png">
-
 ---
 
 #Leave Application
-> Human Resources > Documents > Leave Application > New Leave Application
+> Human Resources > Leaves and Holiday > Leave Application > New Leave Application
 
 Leave Application section enables an employee to apply for leaves. Employee can select the type of leave and the Leave Approver who will authorize the Leave Application. User with "Leave Approver" role are considered as Leave approver. Leave Approvers can also be restricted/pre-defined in the Employee record. Based on selected dates and applicable Holiday List, total leave days is calculated automatically.
 
@@ -73,7 +122,7 @@
 <img class="screenshot" alt="Leave Allocation Tool"
 	src="{{docs_base_url}}/assets/img/human-resources/new-leave-application.png">
 
-	
+
 **Notes:**
 
 - Leave Application period must be within a single Leave Allocation period. In case, you are applying for leave across leave allocation period, you have to create two Leave Application records.
@@ -84,9 +133,9 @@
 
 #Leave Block List
 
-> Human Resources > Setup > Leave Block List > New Leave Block List
+> Human Resources > Leaves and Holiday > Leave Block List > New Leave Block List
 
-Leave Block List is a list of dates in a year, on which employees can not apply for leave. You can define a list of users who can approve Leave Application on blocked days, in case of urgency. You can also define whether the list will applied on entire company or any specific departments.
+Leave Block List is a list of dates in a year, on which employees cannot apply for leave. You can define a list of users who can approve Leave Application on blocked days, in case of urgency. You can also define whether the list will be applied on entire company or any specific departments.
 
 <img class="screenshot" alt="Leave Allocation Tool"
-	src="{{docs_base_url}}/assets/img/human-resources/leave-block-list.png">
\ No newline at end of file
+	src="{{docs_base_url}}/assets/img/human-resources/leave-block-list.png">
