diff --git a/erpnext/docs/current/index.html b/erpnext/docs/current/index.html
index 4c5fc54..4247622 100644
--- a/erpnext/docs/current/index.html
+++ b/erpnext/docs/current/index.html
@@ -35,7 +35,7 @@
 			Version
 		</td>
 		<td>
-			<code>6.14.1</code>
+			<code>6.15.0</code>
 		</td>
 	</tr>
 </table>
diff --git a/erpnext/docs/current/models/accounts/account.html b/erpnext/docs/current/models/accounts/account.html
index bbc0203..5b3103d 100644
--- a/erpnext/docs/current/models/accounts/account.html
+++ b/erpnext/docs/current/models/accounts/account.html
@@ -946,10 +946,6 @@
 			
         
 			
-        
-			
-        
-			
             <li>
 
 
diff --git a/erpnext/docs/current/models/accounts/shipping_rule.html b/erpnext/docs/current/models/accounts/shipping_rule.html
index 8f859cb..beadc90 100644
--- a/erpnext/docs/current/models/accounts/shipping_rule.html
+++ b/erpnext/docs/current/models/accounts/shipping_rule.html
@@ -413,15 +413,6 @@
 </li>
 			
         
-			
-            <li>
-
-
-<a href="https://frappe.github.io/erpnext/current/models/shopping_cart/shopping_cart_shipping_rule">Shopping Cart Shipping Rule</a>
-
-</li>
-			
-        
         </ul>
     
 
diff --git a/erpnext/docs/current/models/setup/company.html b/erpnext/docs/current/models/setup/company.html
index 27e2294..bafb019 100644
--- a/erpnext/docs/current/models/setup/company.html
+++ b/erpnext/docs/current/models/setup/company.html
@@ -111,8 +111,7 @@
                 <pre>Distribution
 Manufacturing
 Retail
-Services
-Education</pre>
+Services</pre>
             </td>
         </tr>
         
diff --git a/erpnext/docs/current/models/stock/price_list.html b/erpnext/docs/current/models/stock/price_list.html
index 28e2cec..60d5b2e 100644
--- a/erpnext/docs/current/models/stock/price_list.html
+++ b/erpnext/docs/current/models/stock/price_list.html
@@ -391,8 +391,6 @@
 			
         
 			
-        
-			
             <li>
 
 
diff --git a/erpnext/docs/current/models/stock/warehouse.html b/erpnext/docs/current/models/stock/warehouse.html
index 2d7108b..c0fa5d3 100644
--- a/erpnext/docs/current/models/stock/warehouse.html
+++ b/erpnext/docs/current/models/stock/warehouse.html
@@ -629,8 +629,6 @@
 			
         
 			
-        
-			
             <li>
 
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/accounting-for-projects.md b/erpnext/docs/user/manual/en/accounts/articles/accounting-for-projects.md
index 6eba288..0d25fea 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/accounting-for-projects.md
+++ b/erpnext/docs/user/manual/en/accounts/articles/accounting-for-projects.md
@@ -1,4 +1,4 @@
-<h1>Accounting for Projects</h1>
+#Accounting for Projects
 
 Accounting for the projects is tracked via Cost Center in ERPNext. This will require you creating separate Cost Center for each Project. Separate Cost Center for each Project all allow:<
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/c-form.md b/erpnext/docs/user/manual/en/accounts/articles/c-form.md
index c2f2061..3c6e091 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/c-form.md
+++ b/erpnext/docs/user/manual/en/accounts/articles/c-form.md
@@ -1,4 +1,4 @@
-<h1>C-Form</h1>
+#C-Form
 
 C-Form functionality is only applicable for Indian customers.
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/changing-parent-account.md b/erpnext/docs/user/manual/en/accounts/articles/changing-parent-account.md
index 02cbd66..1cff854 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/changing-parent-account.md
+++ b/erpnext/docs/user/manual/en/accounts/articles/changing-parent-account.md
@@ -1,4 +1,4 @@
-<h1>Changing Parent Account</h1>
+#Changing Parent Account
 
 Chart of Account has hierarchical structure. This means each account has a parent account defined for it. You will have few ledger preset, and few ledger (like for Customer, Supplier, Warehouse) will be auto-created based on their master record. These ledger will be placed under pre-defined groups in the Chart of Account. If needed you can place specific account under another group by changing its Parent Account.
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/customer-for-multiple-company.md b/erpnext/docs/user/manual/en/accounts/articles/customer-for-multiple-company.md
index 6770fa3..079b4b3 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/customer-for-multiple-company.md
+++ b/erpnext/docs/user/manual/en/accounts/articles/customer-for-multiple-company.md
@@ -1,4 +1,4 @@
-<h1>Customer for Multiple Company</h1>
+#Customer for Multiple Company
 
 ERPNext allows you managing multiple companies in one ERPNext account. It is possible that you will have Customer and Supplier which would belong to more than one company of yours. While creating sales and purchase transactions, system shows result of Customer and Suppliers for that Company only.
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/depreciation-for-fixed-asset-items.md b/erpnext/docs/user/manual/en/accounts/articles/depreciation-for-fixed-asset-items.md
index 026657f..4ce7f34 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/depreciation-for-fixed-asset-items.md
+++ b/erpnext/docs/user/manual/en/accounts/articles/depreciation-for-fixed-asset-items.md
@@ -1,4 +1,4 @@
-<h1>Depreciation for Fixed Asset Items</h1>
+#Depreciation for Fixed Asset Items
 
 Depereciation of fixed asset items.
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/difference-entry-button.html b/erpnext/docs/user/manual/en/accounts/articles/difference-entry-button.md
similarity index 95%
rename from erpnext/docs/user/manual/en/accounts/articles/difference-entry-button.html
rename to erpnext/docs/user/manual/en/accounts/articles/difference-entry-button.md
index 30cae4e..4e651dc 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/difference-entry-button.html
+++ b/erpnext/docs/user/manual/en/accounts/articles/difference-entry-button.md
@@ -1,4 +1,4 @@
-<h1>Difference Entry Button </h1>
+#Difference Entry Button
 
 As per accounting standards Debit amount must be equal to Credit amount. If these amounts are not equal, then entry will not be executed in system. Also system will through validation message. And difference amount will reflect under Difference (Dr-Cr) field.
 <br>
diff --git a/erpnext/docs/user/manual/en/accounts/articles/fiscal-year-error.md b/erpnext/docs/user/manual/en/accounts/articles/fiscal-year-error.md
index e22a3ef..1dfcf00 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/fiscal-year-error.md
+++ b/erpnext/docs/user/manual/en/accounts/articles/fiscal-year-error.md
@@ -1,4 +1,4 @@
-<h1>Fixing Fiscal Year's Error</h1>
+# Fixing Fiscal Year Error
 
 While creating entries in ERPNext, system validates if dates (like Posting Date, Transaction Date etc.) matches with Fiscal Year selected in the entry. If not, system through an error message saying:
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-entries-upto-a-specific-date.html b/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-entries-upto-a-specific-date.html
deleted file mode 100644
index 38ecaf5..0000000
--- a/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-entries-upto-a-specific-date.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<h1>How to freeze accounting entries upto a specific date?</h1>
-
-To freeze accounting entries upto a certain date, follow these steps:<br><br>1. Go to <b>Accounts -&gt; Setup -&gt; Accounts Settings</b>.<br>2. Set the date in <b>Accounts Frozen Upto</b> field.<br><img src="{{docs_base_path}}/assets/img/articles/freeze-accounting-entry.png" height="302" width="488"><br><br>Now, the system will not allow to make accounting entries before that date. <br><br>But you can allow a specific <b>Role,</b> to make/edit accounting entries before that date. To do that set the desired <b>Role</b>, in <b>Role Allowed to Set Frozen Accounts &amp; Edit Frozen Entries</b> field.<br>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-entries-upto-a-specific-date.md b/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-entries-upto-a-specific-date.md
new file mode 100644
index 0000000..1bc6231
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-entries-upto-a-specific-date.md
@@ -0,0 +1,18 @@
+#How to freeze accounting entries upto a specific date?
+
+To freeze accounting entries upto a certain date, follow these steps:
+
+#### Step 1: Go to 
+
+`Accounts > Setup > Accounts Settings
+
+
+#### Step 2: Set the date in:
+
+Accounts Frozen Upto field.
+
+<img src="{{docs_base_path}}/assets/img/articles/freeze-accounting-entry.png" height="302" width="488">
+
+Now, the system will not allow to make accounting entries before that date. 
+
+But you can allow a specific Role, to make/edit accounting entries before that date. To do that set the desired **Role**, in Role Allowed to Set Frozen Accounts &amp; Edit Frozen Entries field.
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-ledger.md b/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-ledger.md
index d76a331..f21bf2d 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-ledger.md
+++ b/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-ledger.md
@@ -1,4 +1,4 @@
-<h1>How To Freeze Accounting Ledger?</h1>
+#How To Freeze Accounting Ledger?
 
 You can freeze any accounting ledger in ERPNext. So that frozen accounting ledger became unsearchable in accounting transaction. Follow below step to understand the process.
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/how-to-nullify-balance-from-temporary-accounts.md b/erpnext/docs/user/manual/en/accounts/articles/how-to-nullify-balance-from-temporary-accounts.md
deleted file mode 100644
index 5ba6d17..0000000
--- a/erpnext/docs/user/manual/en/accounts/articles/how-to-nullify-balance-from-temporary-accounts.md
+++ /dev/null
@@ -1,16 +0,0 @@
-<h1>How to Nullify Balance From Temporary Accounts? </h1>
-
-There are two separate temporary accounts in Chart of Accounts. One is Temporary Account (Assets) and other one is Temporary Account (Liabilities). These accounts are available under Application of Funds and Source of Funds in Chart of Accounts respectively.
-
-These temporary accounts only used to update opening balances. [Click here to learn about update Opening balances](https://erpnext.com/kb/accounts/updating-opening-balance-in-accounts-using-temporary-account)
-
-After completing all opening entries against these temporary accounts balances for both accounts will updated. And Debit balance of Temporary Account (Assets) will became equal to Credit balance of Temporary Account (Liabilities).
-
-Since temporary account were used only for balancing purpose, it shall not have any balance in it.
-To nullify balance in these accounts, you should create a new Journal Voucher, where will you update  balances against these accounts. To create new Journal Entry go to `Accounts &gt; Documents &gt; Journal Entry
-
-![Journal Entry]({{docs_base_url}}/assets/img/articles/$SGrab_432.png)
-
-On submit of this journal entry, balances of these temporary accounts will be set to Zero.
-
-<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/index.txt b/erpnext/docs/user/manual/en/accounts/articles/index.txt
index 08a69e3..d345c2d 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/index.txt
+++ b/erpnext/docs/user/manual/en/accounts/articles/index.txt
@@ -7,7 +7,6 @@
 fiscal-year-error
 how-to-freeze-accounting-entries-upto-a-specific-date
 how-to-freeze-accounting-ledger
-how-to-nullify-balance-from-temporary-accounts
 manage-foreign-exchange-difference
 managing-transactions-in-multiple-currency
 new-fiscal-year-auto-create-feature
diff --git a/erpnext/docs/user/manual/en/accounts/articles/manage-foreign-exchange-difference.md b/erpnext/docs/user/manual/en/accounts/articles/manage-foreign-exchange-difference.md
index 6e24f86..054c979 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/manage-foreign-exchange-difference.md
+++ b/erpnext/docs/user/manual/en/accounts/articles/manage-foreign-exchange-difference.md
@@ -1,4 +1,4 @@
-<h1>Manage Foreign Exchange Difference</h1>
+# Manage Foreign Exchange Difference
 
 When you book Sales Invoices and Purchase invoices in multiple currencies, you will have to deal with currency difference while booking payment entry. You can easily manage this in ERPNext in following ways.  
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/managing-transactions-in-multiple-currency.html b/erpnext/docs/user/manual/en/accounts/articles/managing-transactions-in-multiple-currency.md
similarity index 97%
rename from erpnext/docs/user/manual/en/accounts/articles/managing-transactions-in-multiple-currency.html
rename to erpnext/docs/user/manual/en/accounts/articles/managing-transactions-in-multiple-currency.md
index 3757a69..159402c 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/managing-transactions-in-multiple-currency.html
+++ b/erpnext/docs/user/manual/en/accounts/articles/managing-transactions-in-multiple-currency.md
@@ -1,4 +1,4 @@
-<h1>Managing Transactions In Multiple Currency</h1>
+#Managing Transactions In Multiple Currency
 
 You can make transaction in your base currency as well as in customer or supplier currencies. When you make transaction in your customer or supplier currency, the same currency reflects only in print format of that transaction. And system pass back end
 entry in your base currency.
diff --git a/erpnext/docs/user/manual/en/accounts/articles/new-fiscal-year-auto-create-feature.html b/erpnext/docs/user/manual/en/accounts/articles/new-fiscal-year-auto-create-feature.html
deleted file mode 100644
index 5b6c10f..0000000
--- a/erpnext/docs/user/manual/en/accounts/articles/new-fiscal-year-auto-create-feature.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<h1>New Fiscal Year Auto-Create feature</h1>
-
-New Fiscal Year needs to be created each year at the end of the previous fiscal year. This Process however has been automated in ERPNext.<div><br></div><div>3 days prior to the end of the existing fiscal year; the system shall check if the user has created a new fiscal year for the incoming year. If not the system generates a new fiscal year. All fiscal year Companies are also linked with the new fiscal year as in the previous year.<br><br></div><div><img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2014-12-03 at 5.03.10 pm.png"><br></div>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/new-fiscal-year-auto-create-feature.md b/erpnext/docs/user/manual/en/accounts/articles/new-fiscal-year-auto-create-feature.md
new file mode 100644
index 0000000..ace7c40
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/new-fiscal-year-auto-create-feature.md
@@ -0,0 +1,7 @@
+#New Fiscal Year Auto-Create feature
+
+New Fiscal Year needs to be created each year at the end of the previous fiscal year. This Process however has been automated in ERPNext.
+
+Three days prior to the end of the existing fiscal year; the system shall check if the user has created a new fiscal year for the incoming year. If not the system generates a new fiscal year. All fiscal year Companies are also linked with the new fiscal year as in the previous year.
+	
+<img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2014-12-03 at 5.03.10 pm.png"
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/pos-view.html b/erpnext/docs/user/manual/en/accounts/articles/pos-view.html
deleted file mode 100644
index fb3c500..0000000
--- a/erpnext/docs/user/manual/en/accounts/articles/pos-view.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<h1>POS View</h1>
-
-POS view renders form in a different layout, mainly designed for the quick selection of items. This view has primarily been designed for the retail business, who needs to be quick at invoicing.<div><br></div><div><img src="{{docs_base_path}}/assets/img/articles/$SGrab_219.png"><br></div><div><br></div><div>Using POS View, you can make complete Sales Invoice, without switching to standard form view.<br><div><br></div><div><b>Question: Why do I get error message for missing fields when making Purchase Receipt or other sales/purchase transactions from POS View?</b></div></div><div><br></div><div>Though POS View is mainly designed for Sales Invoice, but it is also made available in all the sales and purchase transactions. In other transactions, POS View is only meant for quick selection of items. This view will not provide all the fields which are available in the standard form view. Hence, you shall use POS View in other transactions just for Item selection, and revert to form view for enter values in other mandatory fields.</div>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/pos-view.md b/erpnext/docs/user/manual/en/accounts/articles/pos-view.md
new file mode 100644
index 0000000..1bf769d
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/pos-view.md
@@ -0,0 +1,11 @@
+#POS View
+
+POS view renders form in a different layout, mainly designed for the quick selection of items. This view has primarily been designed for the retail business, who needs to be quick at invoicing.
+
+<img src="{{docs_base_path}}/assets/img/articles/$SGrab_219.png">
+
+Using POS View, you can make complete Sales Invoice, without switching to standard form view.
+
+**Question:** Why do I get error message for missing fields when making Purchase Receipt or other sales/purchase transactions from POS View?
+
+Though POS View is mainly designed for Sales Invoice, but it is also made available in all the sales and purchase transactions. In other transactions, POS View is only meant for quick selection of items. This view will not provide all the fields which are available in the standard form view. Hence, you shall use POS View in other transactions just for Item selection, and revert to form view for enter values in other mandatory fields.
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/post-dated-cheque-entry.md b/erpnext/docs/user/manual/en/accounts/articles/post-dated-cheque-entry.md
index 12957d9..305fc59 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/post-dated-cheque-entry.md
+++ b/erpnext/docs/user/manual/en/accounts/articles/post-dated-cheque-entry.md
@@ -1,4 +1,4 @@
-<h1>Post Dated Cheque Entry</h1>
+#Post Dated Cheque Entry
 
 Post Dated Cheque is a cheque dated on future date given to another party. This actually works as an advance payment which will could be cleared post cheque date only.
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/pricing-rule.md b/erpnext/docs/user/manual/en/accounts/articles/pricing-rule.md
index f1caf62..dbd00e4 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/pricing-rule.md
+++ b/erpnext/docs/user/manual/en/accounts/articles/pricing-rule.md
@@ -1,4 +1,4 @@
-<h1>Pricing Rule</h1>
+#Pricing Rule
 
 Pricing Rule allows you to define rules based on which item's price or discount to be applied is determined.
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/recurring-order-and-invoices.html b/erpnext/docs/user/manual/en/accounts/articles/recurring-order-and-invoices.html
deleted file mode 100644
index 6893761..0000000
--- a/erpnext/docs/user/manual/en/accounts/articles/recurring-order-and-invoices.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<h1>Recurring Orders and Invoices</h1>
-
-If you have a contract with a <b>Customer</b> where you bill the Customer on a monthly, quarterly, half-yearly or annual basis, you should use recurring feature in orders and invoices. <br><br><h4>Scenario:</h4><br>Subscription for your hosted ERPNext account requires yearly renewal. We use Sales Order for generating proforma invoices. To automate proforma invoicing for renewal, we set original Sales Order as recurring. Recurring proforma invoice is created automatically just before customer's account is about to expire, and requires renewal. This recurring Proforma Invoice is also emailed automatically to the customer.<br><br>Feature of setting document as recurring is available in Sales Order, Sales Invoice, Purchase Order and Purchase Invoice.<br><br>Option to set document as recurring will be visible only after submission. Recurring is last section in document. Check <b>Is Recurring</b> to set document as recurring.<br><br><img src="{{docs_base_path}}/assets/img/articles/is-recurring.gif"><br><br><b>From Date and To Date: </b>This defines contract period with the customer.<br><br><b>Repeat on the Day of Month: </b>If recurring type is set as Monthly, then it will be day of the month on which&nbsp; recurring invoice will be generated.<br><br><b>End Date:</b> Date after which auto-creation of recurring invoice will be stopped.<br><br><b>Notification Email Address:</b> Email Addresses (separated by comma) on which recurring invoice will be emailed when auto-generated.<br><br><b>Recurring ID: </b>Recurring ID will be original document id which will be linked to all corresponding recurring document. For example, original Sales Invoice's id will be updated into all recurring Sales Invoices.<br><br><b>Recurring Print Format:</b> Select a print format to define document view which should be emailed to customer.<br><br><h4>Exception Handling:</h4><p>In a situation where recurring invoice is not created successfully, user with System Manager role is notified about it via email. Also the document on which recurring event failed, "Is Recurring" field is unchecked for it. This means system doesn't try creating recurring invoice for that document again.</p><p>Failure in creation of recurring invoice could be due to multiple reasons like wrong email id mentioned in the Email Notification field in Recurring section etc.</p><p>On receipt of notification, if cause of failure is fixed (like correcting email id) within 24 hours, then recurring invoice will be generated automatically. If issue is not fixed within the said time, then document should be created for that month/year manually.<br></p>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/recurring-order-and-invoices.md b/erpnext/docs/user/manual/en/accounts/articles/recurring-order-and-invoices.md
new file mode 100644
index 0000000..5db9940
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/recurring-order-and-invoices.md
@@ -0,0 +1,33 @@
+#Recurring Orders and Invoices
+
+If you have a contract with a **Customer** where you bill the Customer on a monthly, quarterly, half-yearly or annual basis, you should use recurring feature in orders and invoices. 
+
+#### Scenario:
+
+Subscription for your hosted ERPNext account requires yearly renewal. We use Sales Order for generating proforma invoices. To automate proforma invoicing for renewal, we set original Sales Order as recurring. Recurring proforma invoice is created automatically just before customer's account is about to expire, and requires renewal. This recurring Proforma Invoice is also emailed automatically to the customer.
+
+Feature of setting document as recurring is available in Sales Order, Sales Invoice, Purchase Order and Purchase Invoice.
+
+Option to set document as recurring will be visible only after submission. Recurring is last section in document. Check **Is Recurring** to set document as recurring.
+
+<img alt="Recurring Invoice" class="screenshot" src="{{docs_base_path}}/assets/img/articles/is-recurring.gif">
+
+**From Date and To Date:** This defines contract period with the customer.
+
+**Repeat on the Day of Month:** If recurring type is set as Monthly, then it will be day of the month on which&nbsp; recurring invoice will be generated.
+
+**End Date:** Date after which auto-creation of recurring invoice will be stopped.
+
+**Notification Email Address:** Email Addresses (separated by comma) on which recurring invoice will be emailed when auto-generated.
+
+**Recurring ID:** Recurring ID will be original document id which will be linked to all corresponding recurring document. For example, original Sales Invoice's id will be updated into all recurring Sales Invoices.
+
+**Recurring Print Format:** Select a print format to define document view which should be emailed to customer.
+
+####Exception Handling:
+
+In a situation where recurring invoice is not created successfully, user with System Manager role is notified about it via email. Also the document on which recurring event failed, "Is Recurring" field is unchecked for it. This means system doesn't try creating recurring invoice for that document again.
+	
+Failure in creation of recurring invoice could be due to multiple reasons like wrong email id mentioned in the Email Notification field in Recurring section etc.
+
+On receipt of notification, if cause of failure is fixed (like correcting email id) within 24 hours, then recurring invoice will be generated automatically. If issue is not fixed within the said time, then document should be created for that month/year manually.
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/update-stock-option-in-sales-invoice.html b/erpnext/docs/user/manual/en/accounts/articles/update-stock-option-in-sales-invoice.html
deleted file mode 100644
index 106f383..0000000
--- a/erpnext/docs/user/manual/en/accounts/articles/update-stock-option-in-sales-invoice.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<h1>Update Stock Option in Sales Invoice</h1>
-
-The <i>Update Stock</i> check box is available in the <i>Items</i> section within <i>Sales Invoice</i> form.<br><br><img src="{{docs_base_path}}/assets/img/articles/kb_updatestk_field.png" height="221" width="603"><br><br>Usually the Sales Invoice is a voucher specifying the amount to be paid against Quantity delivered/to be delivered as per a particular Sales Order.<br><br>Checking the update Stock option before submitting an Invoice will directly deduct the Stock from the Inventory on submission of the Sales Invoice. In such a case the Sales Invoice also satisfies the function of a Delivery Note.<br>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/update-stock-option-in-sales-invoice.md b/erpnext/docs/user/manual/en/accounts/articles/update-stock-option-in-sales-invoice.md
new file mode 100644
index 0000000..5cc6104
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/update-stock-option-in-sales-invoice.md
@@ -0,0 +1,9 @@
+#Update Stock Option in Sales Invoice
+
+The <i>Update Stock</i> check box is available in the <i>Items</i> section within <i>Sales Invoice</i> form.
+
+<img src="{{docs_base_path}}/assets/img/articles/kb_updatestk_field.png" height="221" width="603">
+
+Usually the Sales Invoice is a voucher specifying the amount to be paid against Quantity delivered/to be delivered as per a particular Sales Order.
+
+Checking the update Stock option before submitting an Invoice will directly deduct the Stock from the Inventory on submission of the Sales Invoice. In such a case the Sales Invoice also satisfies the function of a Delivery Note.
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/updating-opening-balance-in-accounts-using-temporary-account.md b/erpnext/docs/user/manual/en/accounts/articles/updating-opening-balance-in-accounts-using-temporary-account.md
index 4962b82..d78715c 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/updating-opening-balance-in-accounts-using-temporary-account.md
+++ b/erpnext/docs/user/manual/en/accounts/articles/updating-opening-balance-in-accounts-using-temporary-account.md
@@ -1,4 +1,4 @@
-<h1>Updating Opening Balance in Accounts using Temporary Account</h1>
+# Updating Opening Balance in Accounts using Temporary Account
 
 For updating opening balances in the Accounts, you will need to use temporary adjustment accounts. In the Chart of Account, two adjustment accounts will be created by default.
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/what-is-the-differences-of-total-and-valuation-in-tax-and-charges.html b/erpnext/docs/user/manual/en/accounts/articles/what-is-the-differences-of-total-and-valuation-in-tax-and-charges.html
deleted file mode 100644
index 3d1c7db..0000000
--- a/erpnext/docs/user/manual/en/accounts/articles/what-is-the-differences-of-total-and-valuation-in-tax-and-charges.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<h1>Purchase Tax or Charges Categories</h1>
-
-Consider Tax or Charge field in Purchase Taxes and Charges master has three values.<br><br><ol>
-    <li>Total</li>
-    <li>Valuation</li>
-    <li>Total and Valuation<br><br><img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2015-04-15 at 6.04.02 pm.png"><br></li>
-</ol>
-<p>Let's consider an example to understand an effect of value selected in Consider Tax or Charge field.</p>
-<p>We purchase 10 units of item, at the rate of 800, total purchase amount would be 800. Purchased item has 4% VAT tax and INR 100 transportation charges were incurred.
-
-</p><h4>Total:</h4>
-
-<p>An amount of tax/charge categorized Total will be accounted in the total of purchase transactions, but not in the value of purchased item.</p>
-<p>If VAT 4% is applied on item, it will amount to INR 32. Since VAT is the <a href="https://frappe.io/blog/erpnext-features/managing-consumption-tax" target="_blank">consumption tax</a>, its should be added value of Purchase Order/Invoice, since it will
-    be included in payable towards supplier, but its should not be added to the value of Purchased item.</p>
-<p>Hence for tax or charge you wish to be added to transaction total but not to the valuation of item, it should be categorized as Total.</p>
-<p>When Purchase Invoice is submitted, value of tax/charge is booked in respective account.
-    <br>
-</p>
-<h4>Valuation:</h4>
-<p>An amount of tax/charge categorized as Valuation will be added in the value of purchased item, but will not be added to the value of purchase transaction.</p>
-<p>Transportation charge of INR 100 should be categorized as valuation. With this, the value of purchased item will be increased from 800 to 900. Also, it will be not be added to the total of purchase transaction, because it should not be reflected to supplier,
-    as it will be irrelevant for them.
-    <br>
-</p>
-<p>When Purchase Invoice is submitted, value of tax/charge is booked in respective account. Transportation expense will be booked
-    <br>
-</p>
-<h4>Total and Valuation:</h4>
-<p>An amount of tax/charge categorized as for Total and Valuation will be added in the value of purchase item, as well as will be included in the totals of purchase transactions.</p>
-<p>Let's assume that transporter was arranged by our supplier, but we need to pay transportation charges to them. In that case, for transportation charges, category selected should be Total and Valuation. With this INR 100 transportation charges will be
-    added to actual purchase amount of INR 800. Also, INR 100 will reflect in the total, as it will be payable for us towards supplier.
-    <br>
-</p>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/what-is-the-differences-of-total-and-valuation-in-tax-and-charges.md b/erpnext/docs/user/manual/en/accounts/articles/what-is-the-differences-of-total-and-valuation-in-tax-and-charges.md
new file mode 100644
index 0000000..d4fd384
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/what-is-the-differences-of-total-and-valuation-in-tax-and-charges.md
@@ -0,0 +1,37 @@
+#Purchase Tax or Charges Categories
+
+Consider Tax or Charge field in Purchase Taxes and Charges master has three values.
+<ol>
+    <li>Total</li>
+    <li>Valuation</li>
+    <li>Total and Valuation</li>
+	</ol>
+	
+<img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2015-04-15 at 6.04.02 pm.png"><br>
+
+Let's consider an example to understand an effect of value selected in Consider Tax or Charge field. We purchase 10 units of item, at the rate of 800, total purchase amount would be 800. Purchased item has 4% VAT tax and INR 100 transportation charges were incurred.
+
+####Total:
+
+=An amount of tax/charge categorized Total will be accounted in the total of purchase transactions, but not in the value of purchased item.
+
+If VAT 4% is applied on item, it will amount to INR 32. Since VAT is the 
+<a href="https://frappe.io/blog/erpnext-features/managing-consumption-tax" target="_blank"> consumption tax</a>, its should be added value of Purchase Order/Invoice, since it will be included in payable towards supplier, but its should not be added to the value of Purchased item.
+
+Hence for tax or charge you wish to be added to transaction total but not to the valuation of item, it should be categorized as Total.
+
+When Purchase Invoice is submitted, value of tax/charge is booked in respective account.
+
+####Valuation:
+
+An amount of tax/charge categorized as Valuation will be added in the value of purchased item, but will not be added to the value of purchase transaction.
+
+Transportation charge of INR 100 should be categorized as valuation. With this, the value of purchased item will be increased from 800 to 900. Also, it will be not be added to the total of purchase transaction, because it should not be reflected to supplier, as it will be irrelevant for them.
+
+When Purchase Invoice is submitted, value of tax/charge is booked in respective account. Transportation expense will be booked
+
+####Total and Valuation:
+
+An amount of tax/charge categorized as for Total and Valuation will be added in the value of purchase item, as well as will be included in the totals of purchase transactions.
+
+Let's assume that transporter was arranged by our supplier, but we need to pay transportation charges to them. In that case, for transportation charges, category selected should be Total and Valuation. With this INR 100 transportation charges will be added to actual purchase amount of INR 800. Also, INR 100 will reflect in the total, as it will be payable for us towards supplier.
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/withdrawing-salary-from-owners-equity-account.md b/erpnext/docs/user/manual/en/accounts/articles/withdrawing-salary-from-owners-equity-account.md
index 860f6eb..b18ec6c 100644
--- a/erpnext/docs/user/manual/en/accounts/articles/withdrawing-salary-from-owners-equity-account.md
+++ b/erpnext/docs/user/manual/en/accounts/articles/withdrawing-salary-from-owners-equity-account.md
@@ -1,4 +1,4 @@
-<h1>WIthdrawing Salary from Owner's Equity Account</h1>
+#WIthdrawing Salary from Owner's Equity Account
 
 ### Question
 
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/set-precision.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/set-precision.md
index 8aa33f1..4ed070f 100644
--- a/erpnext/docs/user/manual/en/customize-erpnext/articles/set-precision.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/set-precision.md
@@ -14,14 +14,5 @@
 
 <img alt="Field-wise Precision" class="screenshot" src="{{docs_base_url}}/assets/img/articles/precision-2.png">
 
-**Note:**
-
-If you are changing precision of a field to a higher number, all the related field's precision should be updated as well. For example, if you want invoice total to be upto five decimals, you should set the precision of all related fields to five decimal places as well.
-
-    | Doctype | Fields |
-	|---------|-------:|
-	| Sales Invoice Item | price_list_rate, base_price_list_rate, rate, base_rate, amount and base_amount |
-    | Taxes and Charges | tax_amount, total and tax_amount_after_discount |
-    | Sales Invoice | net_total, other_charges_total, discount_amount and grand_total |
 
 <!-- markdown -->
\ No newline at end of file
