diff --git a/erpnext/docs/assets/img/accounts/opening-2.png b/erpnext/docs/assets/img/accounts/opening-2.png
new file mode 100644
index 0000000..866e351
--- /dev/null
+++ b/erpnext/docs/assets/img/accounts/opening-2.png
Binary files differ
diff --git a/erpnext/docs/assets/img/accounts/opening-3.png b/erpnext/docs/assets/img/accounts/opening-3.png
new file mode 100644
index 0000000..18dcf18
--- /dev/null
+++ b/erpnext/docs/assets/img/accounts/opening-3.png
Binary files differ
diff --git a/erpnext/docs/assets/img/accounts/opening-4.png b/erpnext/docs/assets/img/accounts/opening-4.png
new file mode 100644
index 0000000..f9ac607
--- /dev/null
+++ b/erpnext/docs/assets/img/accounts/opening-4.png
Binary files differ
diff --git a/erpnext/docs/assets/img/accounts/opening-5.png b/erpnext/docs/assets/img/accounts/opening-5.png
new file mode 100644
index 0000000..3722fd1
--- /dev/null
+++ b/erpnext/docs/assets/img/accounts/opening-5.png
Binary files differ
diff --git a/erpnext/docs/assets/img/accounts/opening-6.png b/erpnext/docs/assets/img/accounts/opening-6.png
new file mode 100644
index 0000000..52b08f7
--- /dev/null
+++ b/erpnext/docs/assets/img/accounts/opening-6.png
Binary files differ
diff --git a/erpnext/docs/assets/img/accounts/opening-7.png b/erpnext/docs/assets/img/accounts/opening-7.png
new file mode 100644
index 0000000..9a63504
--- /dev/null
+++ b/erpnext/docs/assets/img/accounts/opening-7.png
Binary files differ
diff --git a/erpnext/docs/assets/img/accounts/perpetual-1.png b/erpnext/docs/assets/img/accounts/perpetual-1.png
new file mode 100644
index 0000000..d9e9342
--- /dev/null
+++ b/erpnext/docs/assets/img/accounts/perpetual-1.png
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/accounting-for-stock-1.png b/erpnext/docs/assets/old_images/erpnext/accounting-for-stock-1.png
deleted file mode 100644
index 462c3f1..0000000
--- a/erpnext/docs/assets/old_images/erpnext/accounting-for-stock-1.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/image-temp-opening.png b/erpnext/docs/assets/old_images/erpnext/image-temp-opening.png
deleted file mode 100644
index 52d0d5a..0000000
--- a/erpnext/docs/assets/old_images/erpnext/image-temp-opening.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/opening-entry-2.png b/erpnext/docs/assets/old_images/erpnext/opening-entry-2.png
deleted file mode 100644
index 57e0fb3..0000000
--- a/erpnext/docs/assets/old_images/erpnext/opening-entry-2.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/trial-balance-1.png b/erpnext/docs/assets/old_images/erpnext/trial-balance-1.png
deleted file mode 100644
index a4322e9..0000000
--- a/erpnext/docs/assets/old_images/erpnext/trial-balance-1.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/user/manual/en/accounts/index.txt b/erpnext/docs/user/manual/en/accounts/index.txt
index f06bb19..d7c405a 100644
--- a/erpnext/docs/user/manual/en/accounts/index.txt
+++ b/erpnext/docs/user/manual/en/accounts/index.txt
@@ -1,21 +1,19 @@
-journal-entry
-sales-invoice
-purchase-invoice
-payment-request
 chart-of-accounts
+opening-accounts
+sales-invoice
+point-of-sale-pos-invoice
+purchase-invoice
+journal-entry
 payment-entry
+multi-currency-accounting
 advance-payment-entry
 payment-request
 credit-limit
-opening-entry
 accounting-reports
 accounting-entries
 managing-fixed-assets
 budgeting
-opening-accounts
-item-wise-tax
-point-of-sale-pos-invoice
-multi-currency-accounting
+item-wise-taxation
 recurring-orders-and-invoices
 pricing-rule
 tools
diff --git a/erpnext/docs/user/manual/en/accounts/item-wise-tax.md b/erpnext/docs/user/manual/en/accounts/item-wise-taxation.md
similarity index 99%
rename from erpnext/docs/user/manual/en/accounts/item-wise-tax.md
rename to erpnext/docs/user/manual/en/accounts/item-wise-taxation.md
index 8c1fc86..bc51de9 100644
--- a/erpnext/docs/user/manual/en/accounts/item-wise-tax.md
+++ b/erpnext/docs/user/manual/en/accounts/item-wise-taxation.md
@@ -1,4 +1,3 @@
-
 Taxes selected in the Tax and Other Charges in transactions are applied on all the items. If you need different taxes applied on items selected in the same transaction, you should setup you item and tax master as explained in the steps below.
 
 ####Step 1: Mention Tax Applicable in the Item master
diff --git a/erpnext/docs/user/manual/en/accounts/opening-accounts.md b/erpnext/docs/user/manual/en/accounts/opening-accounts.md
index c473119..11e4acb 100644
--- a/erpnext/docs/user/manual/en/accounts/opening-accounts.md
+++ b/erpnext/docs/user/manual/en/accounts/opening-accounts.md
@@ -1,80 +1,99 @@
-There are two important sets of data you need to enter before you start your
-operations.
+#Updating Opening Balance in Accounts
 
-  * Opening Account balances.
-  * Opening Stock balances.
+If you are a new company you can start using ERPNext accounting module by going to chart of accounts. However, if you are migrating from a legacy accounting system like Tally or a Fox Pro based software
 
-To setup your accounts and stock correctly you will need accurate data to work
-with. Make sure you have the data setup for this.
+We recommend that you start using accounting in a new financial year, but you could start midway too. To setup your accounts, you will need the following for the “day” you start using accounting in ERPNext:
 
-### Opening Accounts
+* Opening capital accounts - like your shareholder’s (or owner’) capital, loans, bank balances on that day.
 
-We usually recommend that you start using accounting in a new financial year,
-but you could start midway too. To setup your accounts, you will need the
-following for the “day” you start using accounting in ERPNext:
+* List of outstanding sales and purchase invoices (Payables and Receivables).
 
-Opening capital accounts - like your shareholder’s (or owner’) capital, loans,
-bank balances on that day. List of outstanding sales and purchase invoices
-(Payables and Receivables).
+If you were using another accounting software before, firstly you should close financial statements in that software. The closing balance of the accounts should be updated as an opening balance in the ERPNext. Before starting to update opening balance, ensure that your [Chart of Accounts]({{docs_base_url}}/user/manual/en/accounts/chart-of-accounts.html) has all the Accounts required.
 
-Based on Voucher Type
+> Opening entry is only for Balance Sheet accounts and not for the Accounts in the Profit and Loss statement.
 
-You can select accounts based on the voucher type. In such a scenario, your balance sheet should be balanced.
+  * For all assets (excluding Accounts Receivables): This entry will contain all your assets except the amounts you are expecting from your Customers against outstanding Sales Invoices. You will have to update your receivables by making an individual entry for each Invoice (this is because, the system will help you track the invoices which are yet to be paid). You can credit the sum of all these debits against the **Temporary Opening** account.
+  
+  * For all liabilities: Similarly you need to pass a Journal Entry for your Opening Liabilities (except for the bills you have to pay) against **Temporary Opening** account.
+
+###Opening Entry
+
+####Step 1: New Journal Entry
+
+To open new Journal Entry, go to:
+
+`Explore > Accounts > Journal Entry`
+
+####Step 2: Entry Type
+
+If Entry Type is selected as Opening Entry, all the Balance Sheet Accounts will be auto-fetched in the Journal Entry.
 
 <img class="screenshot" alt="Opening Account" src="{{docs_base_url}}/assets/img/accounts/opening-account-1.png">
 
- Also, note that if there are more than 300 ledgers, the system will crash. Thus to avoid such a situation, you can open accounts by using temporary accounts.
+####Step 3: Posting Date
 
-#### Temporary Accounts
+Select Posting Date on which Accounts Opening Balance will be updated.
 
-A nice way to simplify opening is to use a temporary account just for opening. These accounts will become zero once all your old invoices and opening balances of bank, debt stock etc are entered. In the standard chart of accounts, a **Temporary Opening** account is created under assets
+####Step 4: Enter Debit/Credit Value
 
-#### The Opening Entry
+For each Account, enter opening value in the Debit or Credit column. As per the double entry valuation system, Total Debit value in a entry must be equal to Total Credit value.
 
-In ERPNext Opening Accounts are setup by submitting a special Journal Entries
-(Journal Entry).
+<img class="screenshot" alt="Opening Account" src="{{docs_base_url}}/assets/img/accounts/opening-6.png">
 
-Note: Make sure to set “Is Opening” as “Yes” in the More Info section.
+####Step 5: Is Opening
 
-> Setup > Opening Accounts and Stock > Opening Accounting Entries.
+Set field `Is Opening` as `Yes`.
 
-Complete Journal Entries on the Debit and Credit side.
+<img class="screenshot" alt="Opening Account" src="{{docs_base_url}}/assets/img/accounts/opening-3.png">
 
-![Opening Entry]({{docs_base_url}}/assets/old_images/erpnext/opening-entry-1.png)
+####Step 6: Save and Submit
 
- To update opening balance is to make Journal Entry for an individual/group of accounts.
+After enter opening balance for each account, Save and Submit Journal Entry. To check if Opening Balance for an account is updated correctly, you can check Trial Balance report.
 
-For example, if you want to update balance in three bank accounts, then make Journal Entries in this manner.
+###Selecting Accounts Manually
 
-![Opening Temp Entry]({{docs_base_url}}/assets/old_images/erpnext/image-temp-opening.png)
+If your Balance Sheet has many Accounts, then updating Account Opening balance from single Journal Entry can lead to performance issues. In such a scenario, you can multiple Journal Entries to update opening balance in all the Accounts.
 
-![Opening Entry]({{docs_base_url}}/assets/old_images/erpnext/opening-entry-2.png)
+If you are updating account opening balance in few accounts at a time, you can use **Temporary Opening** account for balancing purpose. In the standard chart of accounts, a Temporary Opening Account is auto-created under Assets.
 
-Temporary Asset and Liability account is used for balancing purpose. When you update opening balance in Liability Account, you can use Temporary Asset Account for balancing.
+<img class="screenshot" alt="Opening Account" src="{{docs_base_url}}/assets/img/accounts/opening-7.png">
 
-This way, you can update opening balance in Asset and Liability accounts.
+In the Journal Entry, manually select an Account for which opening balance is to be updated. For each Account, enter opening balance value in the Debit or Credit column, based on it's Account Type (Asset or Liability).
 
-You can make two Opening Journal Entries:
+For example, if you want to update balance in bank accounts, create Journal Entry as following.
 
-  * For all assets (excluding Accounts Receivables): This entry will contain all your assets except the amounts you are expecting from your Customers against outstanding Sales Invoices. You will have to update your receivables by making an individual entry for each Invoice (this is because, the system will help you track the invoices which are yet to be paid). You can credit the sum of all these debits against the **Temporary Opening** account.
-  * For all liabilities: Similarly you need to pass a Journal Entry for your Opening Liabilities (except for the bills you have to pay) against **Temporary Opening** account.
-  * In this method you can update opening balance of specific balance sheet accounts and not for all.
-  * Opening entry is only for balance sheet accounts and not for expense or Income accounts.
+<img class="screenshot" alt="Opening Account" src="{{docs_base_url}}/assets/img/accounts/opening-2.png">
+
+Once all your invoices are entered, your **Temporary Opening** account will have a balance of zero!
+
+###Trial Balance
 
 After completing the accounting entries, the trial balance report will look like the one given below:
 
-![Trial Balance]({{docs_base_url}}/assets/old_images/erpnext/trial-balance-1.png)
+<img class="screenshot" alt="Opening Account" src="{{docs_base_url}}/assets/img/accounts/opening-4.png">
 
-#### Outstanding Invoices
+###Stock Opening
 
-After your Opening Journal Entries are made, you will need to enter each Sales Invoice and Purchase Invoice that is yet to be paid.
+To track stock balance in the Chart of Account, an Account is created for each Warehouse.
 
-Since you have already booked the income or expense on these invoices in the previous period, select the temp opening account **Temporary Opening** in the “Income” and “Expense” accounts.
+`Chart of Accounts > Assets > Current Asset > StocK Assets > (Warehouse Account)`
+
+<img class="screenshot" alt="Opening Account" src="{{docs_base_url}}/assets/img/accounts/opening-5.png">
+
+To update stock opening balance, create [Stock Reconciliation entry]({{docs_base_url}}/user/manual/en/stock/opening-stock.html). Based on the valuation of items's update in the Warehouse, balance will be updated in the Warehouse account.
+
+###Fixed Asset Opening
+
+Opening balance for the fixed asset account should be updated via Journal Entry. Assets which are not fully depreciated should be added in the [Asset master]({{docs_base_url}}/user/manual/en/accounts/managing-fixed-assets.html). For adding Assets in your possession, ensure to check **Is Existing Asset** field.
+
+### Outstanding Invoices
+
+After opening Journal Entries are made, you will need to enter each Sales Invoice and Purchase Invoice that is yet to be paid.
+
+Since you have already booked the income or expense on these invoices in the previous period, select **Temporary Opening** in the “Income” and “Expense” accounts.
 
 > Note: Make sure to set each invoice as “Is Opening”!
 
 If you don’t care what items are in that invoice, just make a dummy item entry in the Invoice. Item code in the Invoice is not necessary, so it should not be such a problem.
 
-Once all your invoices are entered, your **Temporary Opening** account will have a balance of zero!
-
 {next}
diff --git a/erpnext/docs/user/manual/en/accounts/opening-entry.md b/erpnext/docs/user/manual/en/accounts/opening-entry.md
deleted file mode 100644
index da0b0f9..0000000
--- a/erpnext/docs/user/manual/en/accounts/opening-entry.md
+++ /dev/null
@@ -1,7 +0,0 @@
-If you are a new company you can start using ERPNext accounting module by
-going to chart of accounts.
-
-However, if you are migrating from a legacy accounting system like Tally or a
-Fox Pro based software, please visit [Opening Entry.]({{docs_base_url}}/user/manual/en/accounts/opening-accounts.html)
-
-{next}
diff --git a/erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md b/erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md
index ffc5f40..38ae897 100644
--- a/erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md
+++ b/erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md
@@ -1,8 +1,8 @@
-Existing Users, need to follow some steps to activate the new Perpetual
-Inventory system. As Perpetual Inventory always maintains a sync between stock
-and account balance, it is not possible to enable it with existing Warehouse
-setup. You have to create a whole new set of Warehouses, each linked to
-relevant account.
+Perpetual Inventory Valuation is activated by default in the system.
+
+For the users who are currently following periodic inventory valuation system, and wish to migrate to perpetual inventory valuation system, please follow the steps explained below.
+
+As Perpetual Inventory always maintains a sync between stock and account balance, it is not possible to enable it with existing Warehouse setup. You have to create a whole new set of Warehouses, each linked to relevant account.
 
 Steps:
 
@@ -18,21 +18,14 @@
     * Cost Center
   * Activate Perpetual Inventory
 
-> Setup > Accounts Settings > Make Accounting Entry For Every Stock Movement
-
-![Activation]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-1.png)  
+	`Explore > Accounts > Accounts Settings`
+	
+	<img class="screenshot" alt="Perpetual Inventory" src="{{docs_base_url}}/assets/img/accounts/perpetual-1.png">
   
 
   * Create Stock Entry (Material Transfer) to transfer available stock from existing warehouse to new warehouse. As stock will be available in the new warehouse, you should select the new warehouse for all the future transactions.
 
-System will not post any accounting entries for existing stock transactions
-submitted prior to the activation of Perpetual Inventory as those old
-warehouses will not be linked to any account. If you create any new
-transaction or modify/amend existing transactions, with old warehouse, there
-will be no corresponding accounting entries. You have to manually sync stock
-and account balance through Journal Entry.
+System will not post any accounting entries for existing stock transactions submitted prior to the activation of Perpetual Inventory as those old warehouses will not be linked to any account. If you create any new transaction or modify/amend existing transactions, with old warehouse, there will be no corresponding accounting entries. You have to manually sync stock and account balance through Journal Entry.
 
-> Note: If you are already using old Perpetual Inventory system, it will be
-deactivated automatically. You need to follow the above steps to reactivate
-it.
+> Note: If you are already using old Perpetual Inventory system, it will be deactivated automatically. You need to follow the above steps to reactivate it.
 
