diff --git a/docs/docs.user.buying.purchase_taxes.md b/docs/docs.user.buying.purchase_taxes.md
new file mode 100644
index 0000000..31e58bf
--- /dev/null
+++ b/docs/docs.user.buying.purchase_taxes.md
@@ -0,0 +1,37 @@
+---
+{
+
+	"_label": "Purchase Taxes"
+}
+---
+For Tax Accounts that you want to use in the tax templates, you must mention them as type “Tax” in your Chart of Accounts.
+
+Similar to your Sales Taxes and Charges Master is the Purchase Taxes and Charges Master. This is the tax template that you can use in your Purchase Orders and Purchase Invoices. 
+
+> Buying > Purchase Taxes and Charges Master > New Purchase Taxes and Charges Master
+
+
+![Purchase-Taxes](img/purchase-taxes.png)
+
+
+<br>
+
+
+You can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
+
+If  you select a particular tax as your Default tax, the system will apply this tax to all the purchase transactions by default.
+Calculation Type:
+
+This can be on Net Total (that is the sum of basic amount).
+On Previous Row Total / Amount (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
+Actual (as mentioned).
+
+- **Account Head:** The Account ledger under which this tax will be booked.
+- **Cost Center:** If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
+- **Description:** Description of the tax (that will be printed in invoices / quotes).
+- **Rate:** Tax rate.
+- **Amount:** Tax amount.
+- **Total:** Cumulative total to this point.
+- **Enter Row:** If based on "Previous Row Total" you can select the row number which will be taken as a base for this calculation (default is the previous row).
+- **Consider Tax or Charge for:** In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
+- **Add or Deduct:** Whether you want to add or deduct the tax.
diff --git a/docs/docs.user.buying.supplier_type.md b/docs/docs.user.buying.supplier_type.md
new file mode 100644
index 0000000..deaf01f
--- /dev/null
+++ b/docs/docs.user.buying.supplier_type.md
@@ -0,0 +1,19 @@
+---
+{
+	"_label": "Supplier Type"
+}
+---
+
+Based on what the suppliers supply, they are classified into different categories called Supplier Type.
+There can be different types of suppliers. You can create your own category of Supplier Type.
+
+> Buying > Supplier Type > New Supplier Type
+
+![Buying](img/supplier-type.png)
+
+You can classify your suppliers from a range of choice available in ERPNext. Choose from a set of given options like Distributor, Electrical,Hardware, Local, Pharmaceutical, Raw material, Services etc.
+
+Classifying your supplier into different types facilitates accounting and payments. 
+
+
+Type your new supplier category and Save.
diff --git a/docs/docs.user.setup.price_lists.md b/docs/docs.user.setup.price_lists.md
new file mode 100644
index 0000000..36f00f4
--- /dev/null
+++ b/docs/docs.user.setup.price_lists.md
@@ -0,0 +1,16 @@
+---
+{
+	"_label": "Price Lists"
+}
+---
+
+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. 
+
+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.
+
+
+![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
diff --git a/docs/docs.user.stock.item_group.md b/docs/docs.user.stock.item_group.md
new file mode 100644
index 0000000..aca2a78
--- /dev/null
+++ b/docs/docs.user.stock.item_group.md
@@ -0,0 +1,9 @@
+---
+{
+	"_label": "Item Group"
+}
+---
+
+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.
diff --git a/docs/docs.user.stock.material_issue b/docs/docs.user.stock.material_issue
new file mode 100644
index 0000000..e372e7f
--- /dev/null
+++ b/docs/docs.user.stock.material_issue
@@ -0,0 +1,26 @@
+---
+{
+	"_label": "Material Issue"
+}
+---
+
+A Warehouse stocks materials required for manufacturing or trading. The Material Issue form has to be submitted to order materials out of a Warehouse by any department.
+
+> Stock > Stock Entry > New Stock Entry
+
+
+Go to Stock Entry.
+Click on New Stock Entry
+Select the option “Material Issue” under Purpose.
+Provide Source Warehouse details.
+Provide the BOM Number.
+Save
+
+
+![Material Issue](img/material-issue.png)
+
+
+
+
+
+Note: If you have done a stock entry and selected “Material Issue” under Purpose, that particular amount of stock will reflect as negative in stock details.
diff --git a/docs/docs.user.stock.material_issue.md b/docs/docs.user.stock.material_issue.md
new file mode 100644
index 0000000..45e3d98
--- /dev/null
+++ b/docs/docs.user.stock.material_issue.md
@@ -0,0 +1,26 @@
+---
+{
+	"_label": "Material Issue"
+}
+---
+
+A Warehouse stocks materials required for manufacturing or trading. The Material Issue form has to be submitted to order materials out of a Warehouse by any department.
+
+> Stock > Stock Entry > New Stock Entry
+
+
+Go to Stock Entry.
+Click on New Stock Entry
+Select the option “Material Issue” under Purpose.
+Provide Source Warehouse details.
+Provide the BOM Number.
+Save
+
+
+![Material Issue](img/material-issue.png)
+
+
+
+
+
+Note: If you have done a stock entry and selected “Material Issue” under Purpose, that particular amount of stock will reflect as negative in stock details.
\ No newline at end of file
diff --git a/docs/docs.user.stock.projected_quantity.md b/docs/docs.user.stock.projected_quantity.md
new file mode 100644
index 0000000..8fff133
--- /dev/null
+++ b/docs/docs.user.stock.projected_quantity.md
@@ -0,0 +1,27 @@
+---
+{
+	"_label": "Projected Quantity"
+}
+---
+
+Projected Quantity is the level of stock that is predicted for a particular Item, based on the current stock levels and other requirements.It is the quantity of gross inventory that includes supply and demand in the past which is done as part of the planning process.
+
+The projected inventory is used by the planning system to monitor the reorder point and to determine the reorder quantity. The projected Quantity is used by the planning engine to monitor the safety stock levels. These levels are maintained to serve unexpected demands.
+
+Having a tight control of the projected inventory is crucial to determine shortages and to calculate the right order quantity.
+
+
+
+![Projected Quantity Stock Report](img/projected-quantity-stock-report.png)
+
+
+
+
+
+> Projected Qty = Actual Qty + Planned Qty + Requested Qty + Ordered Qty - Reserved Qty
+
+- Actual Qty: Quantity available in the warehouse.
+- Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.
+- Requested Qty: Quantity requested for purchase, but not ordered.
+- Ordered Qty: Quantity ordered for purchase, but not received.
+- Reserved Qty: Quantity ordered for sale, but not delivered.
\ No newline at end of file
diff --git a/docs/docs.user.stock.purchase_receipt b/docs/docs.user.stock.purchase_receipt
new file mode 100644
index 0000000..fd934d2
--- /dev/null
+++ b/docs/docs.user.stock.purchase_receipt
@@ -0,0 +1,24 @@
+---
+{
+	"_label": "Purchase Return"
+}
+---
+ERPNext has an option to account for products that are returned to the supplier. This may be on account of a number of reasons like defects in goods, quality not matching, the buyer not needing the stock, etc. The transactions dealing with return of goods are also accounting transactions and have to be recorded in the books of accounts just like any other accounting transaction. 
+
+
+> Stock > Stock Entry > New Stock Entry
+
+
+![Purchase Return](img/purchase-return.png)
+
+
+
+
+
+
+- To select Purchase Return go to Stock Entry.
+- Select Purchase Return under Purpose.
+- Enter Purchase Receipt number.
+- Enter Source Warehouse details.
+- Provide Supplier Information.
+- Save the document.
\ No newline at end of file
diff --git a/docs/docs.user.stock.purchase_return.md b/docs/docs.user.stock.purchase_return.md
new file mode 100644
index 0000000..13a325a
--- /dev/null
+++ b/docs/docs.user.stock.purchase_return.md
@@ -0,0 +1,23 @@
+---
+{
+	"_label": "Purchase Return"
+}
+---
+ERPNext has an option to account for products that are returned to the supplier.This may be on account of a number of reasons like defects in goods, quality not matching, the buyer not needing the stock, etc. The transactions dealing with return of goods are also accounting transactions and have to be recorded in the books of accounts just like any other accounting transaction. 
+
+
+> Stock > Stock Entry > New Stock Entry
+
+
+![Purchase Return](img/purchase-return.png)
+
+
+
+
+- To select Purchase Return go to Stock Entry.
+- Select Purchase Return under Purpose.
+- Enter Purchase Receipt number.
+- Enter Source Warehouse details.
+- Provide Supplier Information.
+- Save the document.
+
diff --git a/docs/docs.user.stock.sales_return.md b/docs/docs.user.stock.sales_return.md
new file mode 100644
index 0000000..3198db0
--- /dev/null
+++ b/docs/docs.user.stock.sales_return.md
@@ -0,0 +1,21 @@
+---
+{
+	"_label": "Sales Return"
+}
+---
+Goods sold being returned is quite a common practice in Business. They could be returned by the customer on quality issues, non-delivery on agreed date, or any other reason. ERPNext allows this transaction for ease of accounting.
+
+> Stock > Stock Entry > New Stock Entry
+
+
+
+![Sales Return](img/sales-return.png)
+
+
+
+
+- For Sales Return click on Stock Entry
+- Select Sales Return under Purpose
+- Mention the Delivery Note number and the Sales Invoice number.
+- Mention Contact Information of the Customer.
+- Save the file.
\ No newline at end of file
diff --git a/docs/docs.user.stock.warehouse.md b/docs/docs.user.stock.warehouse.md
new file mode 100644
index 0000000..dd8273a
--- /dev/null
+++ b/docs/docs.user.stock.warehouse.md
@@ -0,0 +1,30 @@
+---
+{
+	"_label": "Warehouse"
+}
+---
+
+A warehouse is a commercial building for storage of goods. Warehouses are used by manufacturers, importers, exporters, wholesalers, transport businesses, customs, etc. They are usually large plain buildings in industrial areas of cities,towns, and villages. They usually have loading docks to load and unload goods from trucks.
+
+To go to Warehouse, click on Stock and go to Warehouse under Masters.
+
+
+> Stock > Warehouse > New Warehouse
+
+
+
+![Warehouse](img/warehouse.png)
+
+
+
+
+In ERPNext, every different company can have a separate Warehouse. Every Warehouse will belong to a specific company. User can get company wise accurate stock balance. The Warehouses are saved with their respective company’s abbreviations. This facilitates in identifying which Warehouse belongs to which company, at a glance.
+
+You can include user restrictions for these Warehouses. In case you do not wish a particular user to operate on a particular Warehouse, you can refrain the user from accessing that Warehouse.
+
+### Merge Warehouse
+
+In day to day transactions, if duplicate entries are done by mistake resulting in duplicate Warehouse, these mistakes can be rectified. Duplicate records can be merged into a single Warehouse. Enter the place where you want to keep all the warehouse records. Click on the Merge button. Once this transaction is done, delete the empty Warehouse.
+
+ERPNext system maintains stock balance for every distinct combination of Item and Warehouse. Thus you can get stock balance for any specific Item in a particular Warehouse on any particular date.
+
diff --git a/docs/user/accounts/docs.user.accounts.closing.md b/docs/user/accounts/docs.user.accounts.closing.md
index 2c40bfa..a825918 100644
--- a/docs/user/accounts/docs.user.accounts.closing.md
+++ b/docs/user/accounts/docs.user.accounts.closing.md
@@ -12,7 +12,7 @@
 
 etc. and book your Profit or Loss.
 
-By doing this, your Income and Expense Accounts become zero and you start a new Fiscal Year (or period) with a balanced Balance Sheet and fresh Profit and Loss.
+By doing this, your Income and Expense Accounts become zero .You start a new Fiscal Year (or period) with a balanced Balance Sheet and fresh Profit and Loss account.
 
 In ERPNext after making all the special entries via Journal Voucher, you can make all your Income and Expense accounts to zero via:
 
diff --git a/docs/user/accounts/docs.user.accounts.payments.md b/docs/user/accounts/docs.user.accounts.payments.md
index 4bb064c..d64d947 100644
--- a/docs/user/accounts/docs.user.accounts.payments.md
+++ b/docs/user/accounts/docs.user.accounts.payments.md
@@ -7,7 +7,7 @@
 
 1. Update the “Bank Account” (you can also set the default account in the Company master).
 1. Update posting date.
-1. Enter the check number, check date.
+1. Enter the cheque number, cheque date.
 1. Save and Submit.
 
 Payments can also be made independent of invoices by creating a new Journal Voucher and selecting the type of payment.
@@ -32,7 +32,7 @@
 
 ---
 
-### Reconciling Cheque (Check) Payments
+### Reconciling Cheque Payments
 
 If you are receiving payments or making payments via cheques, the bank statements will not accurately match the dates of your entry, this is because the bank usually takes time to “clear” these payments. Also you may have mailed a cheque to your Supplier and it may be a few days before it is received and deposited by the Supplier. In ERPNext you can synchronize your bank statements and your Journal Vouchers using the “Bank Reconciliation” tool.
 
@@ -42,13 +42,13 @@
 
 Select your “Bank” Account and enter the dates of your statement. Here you will get all the “Bank Voucher” type entries. In each of the entry on the right most column, update the “Clearance Date” and click on “Update”.
 
-This way you will be able to sync your bank statements and entries in the system.
+By doing this you will be able to sync your bank statements and entries into the system.
 
 ---
 
 ## Managing Outstanding Payments
 
-In most cases, apart from retail sales, billing and payment are separate activities. There are several combinations in which these payments are done. These cases apply to both sales and purchases.
+In most cases, apart from retail sales, billing and payments are separate activities. There are several combinations in which these payments are done. These cases apply to both sales and purchases.
 
 - They can be upfront (100% in advance).
 - Post shipment. Either on delivery or within a few days of delivery.
@@ -62,7 +62,7 @@
 
 ### Matching Payments to Invoices
 ￼
-In complex scenarios, especially in the capital goods industry, sometimes there is no direct link between payments and invoices. You send invoices to your Customers and your Customer send you block payments or payments based on some schedule that is not linked to your invoices. 
+In complex scenarios, especially in the capital goods industry, sometimes there is no direct link between payments and invoices. You send invoices to your Customers and your Customer sends you block payments or payments based on some schedule that is not linked to your invoices. 
 
 In such cases, you can use the Payment to Invoice Matching Tool.
 
diff --git a/docs/user/accounts/docs.user.accounts.pos.md b/docs/user/accounts/docs.user.accounts.pos.md
index a4ca430..9cb5079 100644
--- a/docs/user/accounts/docs.user.accounts.pos.md
+++ b/docs/user/accounts/docs.user.accounts.pos.md
@@ -3,7 +3,7 @@
 	"_label": "Point of Sale (POS) Invoice"
 }
 ---
-For retail operations, the delivery of goods, accrual of sale and payment all happens in one event, that is usually called the “Point of Sale”. 
+Point of sale (POS) is the place where a retail transaction is completed. It is the point at which a customer makes a payment to the merchant in exchange for goods or services. For retail operations, the delivery of goods, accrual of sale and payment all happens in one event, that is usually called the “Point of Sale”.
 
 You can make a Sales Invoice of type POS by checking on “Is POS”. When you check this, you will notice that some fields get hidden and some new ones emerge.
 
@@ -11,20 +11,74 @@
 
 #### Different sections of the POS
 
-- Update Stock: If this is checked, Stock Ledger Entries will be made when you “Submit” this Sales Invoice and there is no need for a separate Delivery Note. 
-- In your Items table, you will also have to update inventory information like “Warehouse” (can come as default), “Serial Number” or “Batch Number” if applicable. 
-- Update “Payment Details” like your Bank / Cash Account, paid amount etc. 
-- If you are writing off certain amount, for example change or you get extra change, check on “Write off Outstanding Amount” and set the Account.
+- Update Stock: If this is checked, Stock Ledger Entries will be made when you “Submit” this Sales Invoice thereby eliminating the need for a separate Delivery Note. 
+- In your Items table, update inventory information like Warehouse  (saved as default), Serial Number, or Batch Number if applicable. 
+- Update Payment Details like your Bank / Cash Account, paid amount etc. 
+- If you are writing off certain amount. For example when you receive extra cash as a result of not having exact denomination of change, check on ‘Write off Outstanding Amount’ and set the Account.
 
 #### POS Settings
 
+POS includes advanced features to cater to different functionality, such as inventory management, CRM, financials, warehousing, etc., all built into the POS software. Prior to the modern POS, all of these functions were done independently and required the manual re-keying of information, which could lead to entry errors.
+
 If you are in retail operations, you want your Point of Sale to be as quick and efficient as possible. To do this, you can create a POS Setting for a user from:
 
-Accounts > Point of Sale (POS) Setting
+> Accounts > Point-of-Sale Setting
 
-and set default values as defined.
+Set default values as defined.
 
----
+![POS Settings](img/settings-pos-view.png)
+
+#### Enable POS View
+
+Sales Invoice has 2 different interfaces, Invoice View and POS View. The current view used by most users is the Invoice View. This view is preferred by non-retailing companies.The POS view is used by retailing companies. For retailers it is very important to provide bill or sales invoice at the point of sale. Their customers cannot wait to receive the bill by post. The customers want an immediate bill for the payment which they make. In such cases, the POS View is preferred.
+
+ > Setup  > Show/Hide Features
+
+![POS View](img/enable-pos-view.png)
+
+### Adding an Item
+
+At the billing counter, the retailer needs to select Items which the consumer buys. In the POS interface you can select an Item by two methods. One, is by clicking on the Item image and the other, is through the Barcode. 
+
+**Select Item** - To select a  product click on the Item image and add it into the cart. A cart is an area that prepares a customer for checkout by allowing to edit product information, adjust taxes and add discounts.
+
+![POS](img/add-item-image-click.png)
+
+**Barcode** - A Barcode is an optical machine-readable representation of data relating to the object to which it is attached. Enter Barcode in the barcode box and pause for a second. The  Item will be automatically added to the cart.
+
+![POS](img/add-item-barcode.png)
+
+> Tip: To change the quantity of an Item, enter your desired quantity in the quantity box. These are mostly used if the same Item is purchased in bulk.
+
+
+If your product list is very long use the universal search field, to type the  product name and select faster. 
+
+### Removing an Item
+
+There are two ways to remove an Item.
+
+- Select an Item by clicking on the row of that Item from Item cart. Then click on “Del” button. OR
+
+
+- Type 0 in  the ‘select quantity’ field to delete the record.
+
+To remove multiple Items together, select multiple rows & click on “Del” button. 
+
+> Delete button appears only when Items are selected.
+
+![POS](img/delete-item.png)
+
+### Make Payment
+
+After all the Items and their quantities are added into the cart, you are ready to make the Payment. Payment process is divided into 3 steps - 
+
+1. Click on “Make Payment” to get the Payment window.
+1. Select your “Mode of Payment”.
+1. Click on “Pay” button to Save the Sales Invoice.
+
+![POS Payment](img/make-payment.png)
+
+Submit the document to finalise the record. After the Invoice is submitted, you can either print an invoice or email it directly to the customer.
 
 #### Accounting entries (GL Entry) for a Point of Sale:
 
@@ -40,5 +94,5 @@
 - Customer (payment)
 - Write Off (optional)
 
-To see entries after “Submit”, click on “View Ledger”.
-￼
+To see entries after “Submit”, click on “View Ledger”.￼
+
diff --git a/docs/user/accounts/docs.user.accounts.purchase_invoice.md b/docs/user/accounts/docs.user.accounts.purchase_invoice.md
index 371a26f..8a49353 100644
--- a/docs/user/accounts/docs.user.accounts.purchase_invoice.md
+++ b/docs/user/accounts/docs.user.accounts.purchase_invoice.md
@@ -11,11 +11,11 @@
 
 or click on “Make Purchase Invoice” in Purchase Order or Purchase Receipt.
 
-The concept of “Posting Date” is again same as Sales Invoice. “Bill No” and “Bill Date” help you  to track the bill number as set by your Supplier for reference.
+The concept of “Posting Date” is again same as Sales Invoice. “Bill No” and “Bill Date” helps to track the bill number as set by your Supplier for reference.
 
 #### Accounting Impact
 
-Like in Sales Invoice, you have to enter an Expense or Asset account for each row in your Items table to indicate if the Item is an Asset or an Expense. You must also enter a Cost Center.  These can also be set in the Item master.
+Like in Sales Invoice, you have to enter an Expense or an Asset account for each row in your Items table. This helps to indicate if the Item is an Asset or an Expense. You must also enter a Cost Center. These can also be set in the Item master.
 
 The Purchase Invoice will affect your accounts as follows:
 
@@ -36,17 +36,15 @@
 
 #### Is a purchase an “Expense” or “Asset”?
 
-If the Item is consumed immediately on purchase or if it is a service, then the purchase becomes an “Expense”. For example, a telephone bill or travel bill is an “Expense” - it is already consumed.
+If the Item is consumed immediately on purchase, or if it is a service, then the purchase becomes an “Expense”. For example, a telephone bill or travel bill is an “Expense” - it is already consumed.
 
 For inventory Items, that have a value, these purchases are not yet “Expense”, because they still have a value while they remain in your stock. They are “Assets”. If they are raw-materials (used in a process), they will become “Expense” the moment they are consumed in the process. If they are to be sold to a Customer, they become “Expense” when you ship them to the Customer.
 
-Note: In ERPNext, this conversion from “Asset” to “Expense” is not clear. As of the current version, you will have to manually convert an item from an “Asset” to “Expense” via a Journal Voucher. We know its a shortcoming and will be fixed in an upcoming version pretty soon.
-
 ---
 
 #### Deducting Taxes at Source
 
-In many countries, your laws may require to deduct taxes by a standard rate when you make payments to your Suppliers. Under these type of schemes, typically if a Supplier crosses a certain threshold of payment and if the type of product is taxable, you may have to deduct some tax (that you pay back to your government, on your Supplier’s behalf).
+In many countries, the law may require you to deduct taxes, while paying your suppliers. These taxes could be based on a standard rate. Under these type of schemes, typically if a Supplier crosses a certain threshold of payment, and if the type of product is taxable, you may have to deduct some tax (which you pay back to your government, on your Supplier’s behalf).
 
 To do this, you will have to make a new Tax Account under “Tax Liabilities” or similar and credit this Account by the percent you are bound to deduct for every transaction.
 
diff --git a/docs/user/accounts/docs.user.accounts.reports.md b/docs/user/accounts/docs.user.accounts.reports.md
index 84356f6..9d4ec1b 100644
--- a/docs/user/accounts/docs.user.accounts.reports.md
+++ b/docs/user/accounts/docs.user.accounts.reports.md
@@ -28,4 +28,4 @@
 
 ### Sales and Purchase Register
 
-This is useful for making your tax statements invoice and Item wise. In this report, each tax Account is transposed in columns and for each Invoice and invoice Item, you will get the amount of individual tax that has been paid based on the Taxes and Charges table.
+In this report, each tax Account is transposed in columns.For each Invoice and invoice Item, you will get the amount of individual tax that has been paid, based on the Taxes and Charges table.
diff --git a/docs/user/accounts/docs.user.accounts.sales_invoice.md b/docs/user/accounts/docs.user.accounts.sales_invoice.md
index c30b166..3130fbe 100644
--- a/docs/user/accounts/docs.user.accounts.sales_invoice.md
+++ b/docs/user/accounts/docs.user.accounts.sales_invoice.md
@@ -3,9 +3,9 @@
 	"_label": "Sales Invoice"
 }
 ---
-A Sales Invoice is a bill you send to your Customers against which they will process your payment. 
+A Sales Invoice is a bill that you send to your Customers, against which they will process your payment. 
 
-If you have managed to create Sales Orders or Delivery Notes, creating a Sales Invoice should be more of the same. 
+If you have managed to create Sales Orders or Delivery Notes, creating a Sales Invoice follows the same process. 
 
 You can create a Sales Invoice directly from
 
@@ -21,7 +21,7 @@
 
 The other account that is affected is the Account of the Customer. That is automatically set from “Debit To” in the heading section.
 
-You must also mention the Cost Centers in which your Income must be booked. Remember that your Cost Centers tell you the profitability of the different lines of business or product. Again, you can set a default Cost Center in your Item master.
+You must also mention the Cost Centers in which your Income must be booked. Remember that your Cost Centers tell you the profitability of the different lines of business or product. You can also set a default Cost Center in the Item master.
 
 #### Accounting entries (GL Entry) for a typical double entry “Sale”:
 
diff --git a/docs/user/buying/docs.user.buying.material_request.md b/docs/user/buying/docs.user.buying.material_request.md
index 2ccb399..c6a7785 100644
--- a/docs/user/buying/docs.user.buying.material_request.md
+++ b/docs/user/buying/docs.user.buying.material_request.md
@@ -5,6 +5,23 @@
 ---
 A Material Request is a simple document identifying a requirement of a set of Items (products or services) for a particular reason.
 
+
+![Workflow](img/material-request-workflow.jpg)
+
+
+
+
+To generate a Material Request manually go to:
+
+> Buying > Material Request > New Material Request
+
+**Step 1**
+
+![Material Request](img/material-request-1.png)
+
+
+
+
 A Material Request can be generated:
 
 - By a User.
@@ -12,20 +29,25 @@
 - Automatically when the Projected Quantity of an Item in stores reaches a particular level.
 - Automatically from your Bill of Materials if you use Production Plan to plan your manufacturing activities.
 
-To generate a Material Request manually go to:
+**Step 2**
 
-> Buying > Material Request > New Material Request
+![Material Request 2](img/material-request-2.png)
+
+
+
 
 In the Material Request form, 
 
 - Fill in the Items you want and their quantities.
-- If your Items are inventory items, you must also mention the Warehouse where you expect these Items to be delivered. This helps to keep track of the Projected Quantity for this Item.
-- You can also automatically get the Items from a Sales Order.
+
+- If your Items are inventory items, you must also mention the Warehouse where you expect these Items to be delivered. This helps to keep track of the [Projected Quantity](docs.user.stock.projected_quantity.html)for this Item.
+
+
 - You can optionally add the Terms, using the Terms and Conditions master and also the reason.
 
+
 > Info: Material Request is not mandatory. It is ideal if you have centralized buying so that you can collect this information from various departments.
 
 #### Authorization
 
-If you want your Material Request to be authorized by a senior person like a Purchase Manager then you can give “Submit” rights only to that person. Everyone can create requests, but only the authorized person can “Submit”.
-
+If you want your Material Request to be authorized by a senior person like a Purchase Manager then you can give “Submit” rights only to that person. Everyone can create requests, but only the authorized person can “Submit”.
\ No newline at end of file
diff --git a/docs/user/buying/docs.user.buying.md b/docs/user/buying/docs.user.buying.md
index 55e8437..8247475 100644
--- a/docs/user/buying/docs.user.buying.md
+++ b/docs/user/buying/docs.user.buying.md
@@ -1,10 +1,28 @@
 ---
 {
-	"_label": "Buying"
+	"_label": "Buying",
+	"_toc": [
+		"docs.user.buying.supplier_type",
+		"docs.user.buying.supplier",
+		"docs.user.buying.material_request",
+		"docs.user.buying.supplier_quotation",
+		"docs.user.buying.purchase_order",
+		"docs.user.buying.purchase_taxes",
+		"docs.user.buying.price_lists",
+		"docs.user.buying.sub_contracting"
+	]
 }
 ---
+
+
+
+![Buying](img/buying-home.png)
+
+
+
+
 If your business involves physical goods, buying is one of your core business activity. Your suppliers are as important as your customers and they must be provided with as much accurate information as possible.
 
 Buying in right amounts, in right quantities, can affect your cash flow and profitability.
 
-ERPNext contains a set of transactions that will make your buying process as efficient and seamless as possible.
+ERPNext contains a set of transactions that will make your buying process as efficient and seamless as possible.
\ No newline at end of file
diff --git a/docs/user/buying/docs.user.buying.purchase_order.md b/docs/user/buying/docs.user.buying.purchase_order.md
index 90db2bd..d78b2b5 100644
--- a/docs/user/buying/docs.user.buying.purchase_order.md
+++ b/docs/user/buying/docs.user.buying.purchase_order.md
@@ -11,6 +11,12 @@
 ￼
 A Purchase Order can also be automatically created from a Purchase Request or  Supplier Quotation.
 
+
+![Purchase Order](img/purchase-order.png)
+
+
+
+
 Entering a Purchase Order is very similar to a Purchase Request, additionally you will have to set:
 
 - Supplier. 
diff --git a/docs/user/buying/docs.user.buying.purchase_taxes.md b/docs/user/buying/docs.user.buying.purchase_taxes.md
new file mode 100644
index 0000000..31e58bf
--- /dev/null
+++ b/docs/user/buying/docs.user.buying.purchase_taxes.md
@@ -0,0 +1,37 @@
+---
+{
+
+	"_label": "Purchase Taxes"
+}
+---
+For Tax Accounts that you want to use in the tax templates, you must mention them as type “Tax” in your Chart of Accounts.
+
+Similar to your Sales Taxes and Charges Master is the Purchase Taxes and Charges Master. This is the tax template that you can use in your Purchase Orders and Purchase Invoices. 
+
+> Buying > Purchase Taxes and Charges Master > New Purchase Taxes and Charges Master
+
+
+![Purchase-Taxes](img/purchase-taxes.png)
+
+
+<br>
+
+
+You can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
+
+If  you select a particular tax as your Default tax, the system will apply this tax to all the purchase transactions by default.
+Calculation Type:
+
+This can be on Net Total (that is the sum of basic amount).
+On Previous Row Total / Amount (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
+Actual (as mentioned).
+
+- **Account Head:** The Account ledger under which this tax will be booked.
+- **Cost Center:** If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
+- **Description:** Description of the tax (that will be printed in invoices / quotes).
+- **Rate:** Tax rate.
+- **Amount:** Tax amount.
+- **Total:** Cumulative total to this point.
+- **Enter Row:** If based on "Previous Row Total" you can select the row number which will be taken as a base for this calculation (default is the previous row).
+- **Consider Tax or Charge for:** In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
+- **Add or Deduct:** Whether you want to add or deduct the tax.
diff --git a/docs/user/buying/docs.user.buying.supplier.md b/docs/user/buying/docs.user.buying.supplier.md
index aa53a78..e477fa2 100644
--- a/docs/user/buying/docs.user.buying.supplier.md
+++ b/docs/user/buying/docs.user.buying.supplier.md
@@ -5,13 +5,29 @@
 ---
 Suppliers are companies or individuals who provide you with products or services. They are treated in exactly the same manner as Customers in ERPNext.
 
-1. Separate Account Ledgers are created for the Supplier in the Company under “Accounts Payable”.
-1. You can have multiple Addresses and Contacts for Suppliers.
-1. Suppliers are categorized as Supplier Type.
-1. If you set “Credit Days”, ERPNext will automatically set the due date in Purchase Invoices.
 
 You can create a new Supplier via:
 
 > Buying > Supplier > New Supplier
 
-or import from the Data Import Tool
+![Supplier](img/supplier.png)
+
+
+### Contacts and Addresses
+
+ Contacts and Addresses in ERPNext are stored separately so that you can attach multiple Contacts or Addresses to Customers and Suppliers. To add a Contact or Address go to Buying and click on “New Contact” or “New Address”.
+
+
+> Tip: When you select a Supplier in any transaction, one Contact and Address gets pre-selected. This is the “Default Contact or Address”. So make sure you set your defaults correctly!
+
+
+
+
+> Buying > Contact > New Contact
+
+![Contact](img/contact.png)
+
+
+
+
+You can also import from the Data Import Tool
\ No newline at end of file
diff --git a/docs/user/buying/docs.user.buying.supplier_quotation.md b/docs/user/buying/docs.user.buying.supplier_quotation.md
index 37431f3..1308182 100644
--- a/docs/user/buying/docs.user.buying.supplier_quotation.md
+++ b/docs/user/buying/docs.user.buying.supplier_quotation.md
@@ -3,6 +3,21 @@
 	"_label": "Supplier Quotation"
 }
 ---
+A Supplier Quotation is a formal statement of promise by potential supplier to supply the goods or services required by a buyer, at specified prices, and within a specified period. A quotation may also contain terms of sale and payment, and warranties. Acceptance of quotation by the buyer constitutes an agreement binding on both parties.
+
+
+You can make a Supplier Quotation directly from:
+
+> Buying > Supplier Quotation > New Supplier Quotation
+
+or directly from the Purchase Request.
+
+
+
+![Supplier Quotation](img/supplier-quotation.png)
+
+
+
 If you have multiple **Suppliers** who supply you with the same **Item**, you usually send out a message (Request for Quote) to various **Suppliers**. In many cases, especially if you have centralized buying, you may want to record all the quotes so that 
 
 - You can easily compare prices in the future 
@@ -10,8 +25,3 @@
 
 Supplier Quotations are not necessary for most small businesses. Always evaluate the cost of collecting information to the value it really provides! You could only do this for high value items.
 
-You can make a Supplier Quotation directly from:
-
-> Buying > Supplier Quotation > New Supplier Quotation
-
-or directly from the Purchase Request.
diff --git a/docs/user/buying/docs.user.buying.supplier_type.md b/docs/user/buying/docs.user.buying.supplier_type.md
new file mode 100644
index 0000000..deaf01f
--- /dev/null
+++ b/docs/user/buying/docs.user.buying.supplier_type.md
@@ -0,0 +1,19 @@
+---
+{
+	"_label": "Supplier Type"
+}
+---
+
+Based on what the suppliers supply, they are classified into different categories called Supplier Type.
+There can be different types of suppliers. You can create your own category of Supplier Type.
+
+> Buying > Supplier Type > New Supplier Type
+
+![Buying](img/supplier-type.png)
+
+You can classify your suppliers from a range of choice available in ERPNext. Choose from a set of given options like Distributor, Electrical,Hardware, Local, Pharmaceutical, Raw material, Services etc.
+
+Classifying your supplier into different types facilitates accounting and payments. 
+
+
+Type your new supplier category and Save.
diff --git a/docs/user/docs.user.help.md b/docs/user/docs.user.help.md
index 55d12d2..9563ce1 100644
--- a/docs/user/docs.user.help.md
+++ b/docs/user/docs.user.help.md
@@ -4,11 +4,12 @@
 	"_icon": "question"
 }
 ---
-If you are stuck and have searched all the help that is available online and need to talk to someone, here is how you do it:
+If you are stuck, have searched all the posible help that is available online, and need to talk to someone, here is how you do it:
 
 ### 1. Head to the Forums
 
-- If you are a user or evaluating and want to talk to other ERPNext users, go to the [ERPNext User Forum](groups.google.com/group/erpnext-user-forum/)
+- If you are a user or you are evaluating and want to talk to other ERPNext users, go to the [ERPNext User Forum](groups.google.com/group/erpnext-user-forum/)
+
 - If you are a developer and want help in customizing or extending ERPNext, head to the developer forums [ERPNext Developer Forum](groups.google.com/group/erpnext-developer-forum/)
 
 ### 2. Report an Issue / Suggestion at GitHub
@@ -19,7 +20,7 @@
 
 ### 3. Get in touch with a local partner.
 
-ERPNext has an expanding partner community so check this page out if there is a local partner  in your region.
+ERPNext has an expanding partner community. So check this page out if there is a local partner in your region.
 
 - [ERPNext Parter List](https://erpnext.com/partners)
 
diff --git a/docs/user/docs.user.md b/docs/user/docs.user.md
index 00128f0..4086521 100644
--- a/docs/user/docs.user.md
+++ b/docs/user/docs.user.md
@@ -74,7 +74,7 @@
 	1. [Price Lists](docs.user.setup.price_lists.html)
 	1. [Sub Contracting](docs.user.stock.sub_contracting.html)
 1. [Stock (Inventory)](docs.user.stock.html)
-	1. [Warehouse](docs.user.stock.item.html)
+	1. [Warehouse](docs.user.stock.warehouse.html)
 	1. [Item Group](docs.user.stock.item_group.html)
 	1. [Item](docs.user.stock.item.html)
 	1. [Serialized Inventory](docs.user.stock.serialized.html)
@@ -82,9 +82,9 @@
 	1. [Delivery Note](docs.user.stock.delivery_note.html)
 	1. [Stock Entry / Material Transfer](docs.user.stock.stock_entry.html)
 	1. [Material Issue](docs.user.stock.material_issue.html)
-	1. [Material Issue](docs.user.stock.material_issue.html)
 	1. [Sales Return](docs.user.stock.sales_return.html)
-	1. [Purchase Return](docs.user.stock.sales_return.html)
+	1. [Purchase Return](docs.user.stock.purchase_return.html)
+	1. [Projected Quantity](docs.user.stock.projected_quantity.html)
 1. [Accounting](docs.user.accounting.html)
 	1. [Chart of Accounts](docs.user.setup.accounting.html)
 	1. [Chart of Cost Centers](docs.user.setup.cost_centers.html)
@@ -96,6 +96,7 @@
 	1. [Period Closing](docs.user.accounts.closing.html)
 	1. [Accounting Reports](docs.user.accounts.reports.html)
 	1. [Upload Journal Entries in Bulk](docs.user.accounts.voucher_import.html)
+	1. [Point of Sale (POS) Invoice](docs.user.accounts.pos.html)
 1. [Human Resources (HR)](docs.user.hr.html)
 	1. [HR Setup](docs.user.hr.setup.html)
 	1. [Employee](docs.user.hr.employee.html)
diff --git a/docs/user/hr/docs.user.hr.employee.md b/docs/user/hr/docs.user.hr.employee.md
index a3f065d..f63b9ac 100644
--- a/docs/user/hr/docs.user.hr.employee.md
+++ b/docs/user/hr/docs.user.hr.employee.md
@@ -3,7 +3,7 @@
 	"_label": "Employee Master"
 }
 ---
-There are many fields you can add in your Employee records and the more information you update it will be useful as your organization keeps growing and more and more people come and go.
+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.
 
diff --git a/docs/user/hr/docs.user.hr.expense_claim.md b/docs/user/hr/docs.user.hr.expense_claim.md
index 37c63cc..53218b2 100644
--- a/docs/user/hr/docs.user.hr.expense_claim.md
+++ b/docs/user/hr/docs.user.hr.expense_claim.md
@@ -3,7 +3,7 @@
 	"_label": "Expense Claim"
 }
 ---
-When Employee’s make expenses out of their pocket on behalf of the company, for example, if they take a customer out for lunch, they can make a request for reimbursement via the Expense Claim form. 
+Expense Claim is made when Employee’s make expenses out of their pocket on behalf of the company. For example, if they take a customer out for lunch, they can make a request for reimbursement via the Expense Claim form. 
 
 To make a new Expense Claim, go to:
 
diff --git a/docs/user/hr/docs.user.hr.md b/docs/user/hr/docs.user.hr.md
index e6f88b7..8657454 100644
--- a/docs/user/hr/docs.user.hr.md
+++ b/docs/user/hr/docs.user.hr.md
@@ -3,10 +3,6 @@
 	"_label": "Human Resource Management"
 }
 ---
-The Human Resources (HR) Module covers the processes linked to administering a team of co-workers. Most common among this is processing payroll by using the Salary Manager to generate Salary Slips. Most countries have complex tax rules stating what expenses can the company make on behalf of Employees and also expect the company to deduct taxes and social security from their payroll.
+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 the Salary Manager 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 their calculation.
 
-Apart from that you can also track Leave Applications and balances, Expense Claims and upload Attendance data (even though the world has moved to a result-oriented culture, some countries still mandate companies to maintain an attendance register to ensure you are not over-working your team).
-
-You can also create a template for Appraisals and also record the performance using the Appraisal record.
-
-> Confession: No, we don’t like the terms human “resources” and “employees” either, but since this terms are widely used and accepted for administrative procedures, we will use them here.
\ No newline at end of file
+It  also maintains a complete employee database including contact information, salary details, attendance, performance evaluation, and appraisal records.
\ No newline at end of file
diff --git a/docs/user/intro/docs.user.implement.concepts.md b/docs/user/intro/docs.user.implement.concepts.md
index ac481d4..31b4358 100644
--- a/docs/user/intro/docs.user.implement.concepts.md
+++ b/docs/user/intro/docs.user.implement.concepts.md
@@ -3,7 +3,7 @@
 	"_label": "Concepts and Terms"
 }
 ---
-Before you start implementation, lets get familiar with the terminology used and some basic concepts in ERPNext.
+Before you start implementation, lets get familiar with the terminology that is used and some basic concepts in ERPNext.
 
 ---
 
@@ -77,7 +77,7 @@
 
 #### Cost Center
 
-A Cost Center is like an Account, but the only difference is that it's structure represents your business more closely than Accounts. For example in your Chart of Accounts, you separate your expenses by type (say travel, marketing etc). In your Chart of Cost Centers, you can separate them by product line or business group (for example online sales, retail sales)
+A Cost Center is like an Account, but the only difference is that its structure represents your business more closely than Accounts. For example in your Chart of Accounts, you separate your expenses by type (say travel, marketing etc). In your Chart of Cost Centers, you can separate them by product line or business group (for example online sales, retail sales)
 
 > Accounts > Chart of Cost Centers
 
@@ -101,7 +101,7 @@
 
 #### Currency
 
-ERPNext allows you to book transactions in multiple currencies. There is only one currency for your books of accounts though. While posting your Invoices, payments in different currencies, the amounts are converted to the default currency by the specified conversion rate.
+ERPNext allows you to book transactions in multiple currencies. There is only one currency for your book of accounts though. While posting your Invoices, payments in different currencies, the amount is converted to the default currency by the specified conversion rate.
 
 > Setup > Company > Currencies
 
@@ -209,7 +209,7 @@
 
 #### Stock Ledger Entry
 
-A unified table for all material movement from one warehouse to another. This is the table that is updated when a Stock Entry, Delivery Note, Purchase Receipt, Sales Invoice (POS) is made.
+A unified table for all material movement from one warehouse to another. This is the table that is updated when a Stock Entry, Delivery Note, Purchase Receipt, and Sales Invoice (POS) is made.
 
 #### Stock Reconciliation
 
@@ -265,7 +265,7 @@
 
 #### Salary Structure
 
-A template identifying all the components of an Employee’s salary (earnings) and tax and other social security deductions.
+A template identifying all the components of an Employees' salary (earnings) and tax and other social security deductions.
 
 > Human Resource > Salary and Payroll > Salary Structure
 
diff --git a/docs/user/intro/docs.user.implement.md b/docs/user/intro/docs.user.implement.md
index f42d661..59f2c49 100644
--- a/docs/user/intro/docs.user.implement.md
+++ b/docs/user/intro/docs.user.implement.md
@@ -7,7 +7,7 @@
 	]
 }
 ---
-We have seem dozens of ERP implementations over the past few years and we realize that successful implementations are a lot about intangibles and attitude.
+We have seen dozens of ERP implementations over the past few years and we realize that successful implementation is a lot about intangibles and attitude.
 
 **ERPs are not required.**
 
@@ -23,12 +23,12 @@
 
 ## The Champion
 
-ERP means organization wide change and it does not happen without effort. Every change requires a champion and it is the duty of the champion to organize and energize the entire team towards implementation. The champion is all the fall guy (or fall gal) incase something goes wrong and hence needs to be resilient. Who becomes a champion without putting effort anyways?
+ERP means organization wide change and it does not happen without effort. Every change requires a champion and it is the duty of the champion to organize and energize the entire team towards implementation. The champion needs to be resilient incase something goes wrong .
 
-In many organizations we have seen, the champion is most often the owner or a senior manager. Occasionally, the champion is an outsider who is hired for the purpose.
+In many organizations we have seen, the champion is most often the owner or a senior manager. Occasionally, the champion is an outsider who is hired for a particular purpose.
 
 In either case, you must identify your champion first.
 
-Most likely its **you!** 
+Most likely it's **you!** 
 
-Lets Begin!
+Lets Begin!
\ No newline at end of file
diff --git a/docs/user/intro/docs.user.implement.strategy.md b/docs/user/intro/docs.user.implement.strategy.md
index 3abb91a..9ec58e8 100644
--- a/docs/user/intro/docs.user.implement.strategy.md
+++ b/docs/user/intro/docs.user.implement.strategy.md
@@ -10,7 +10,7 @@
 ### Test Phase
 
 - Read the Manual
-- Create your first Customer, Supplier and Item. Add a few more so you get familiar.
+- Create your first Customer, Supplier and Item. Add a few more so you get familiar with them.
 - Create Customer Groups, Item Groups, Warehouses, Supplier Groups, so that you can classify your Items.
 - Complete a standard sales cycle - Lead > Opportunity > Quotation > Sales Order > Delivery Note > Sales Invoice > Payment (Journal Voucher)
 - Complete a standard purchase cycle - Purchase Request > Purchase Order > Purchase Receipt > Payment (Journal Voucher).
@@ -20,11 +20,10 @@
 
 ### Live Phase
 
-Once you have made yourself familiar with ERPNext, start entering your live data!
+Once you are familiar with ERPNext, start entering your live data!
 
 - Clean up the account of test data or better, start a fresh install.
 - Setup all the modules with Customer Groups, Item Groups, Warehouses, BOMs etc.
 - Import Customers, Suppliers, Items, Contacts and Addresses using Data Import Tool.
 - Import opening stock using Stock Reconciliation Tool.
-- Create opening accounting entries via Journal Voucher and create outstanding Sales Invoices and Purchase Invoices.
-
+- Create opening accounting entries via Journal Voucher and create outstanding Sales Invoices and Purchase Invoices.
\ No newline at end of file
diff --git a/docs/user/intro/docs.user.intro.md b/docs/user/intro/docs.user.intro.md
index a6debe8..5c1cb56 100644
--- a/docs/user/intro/docs.user.intro.md
+++ b/docs/user/intro/docs.user.intro.md
@@ -11,18 +11,15 @@
 ---
 ## What is an ERP and why should I care?
 
-(If you are already convinced you need an all-in-one system for your organization, you can skip this.)
+(If you are already convinced you need an all-in-one system for your organization, you can skip this page.)
 
-If you are running a small business that has some employees, you understand its hard to manage the dynamic nature of doing businesses. 
-You are already using software like Accounting, and may be some other one to manage your inventory and sales (or CRM). 
+If you are running a small business that has a few employees, you understand that it's hard to manage the dynamic nature of doing businesses. You are already using a software like Accounting, and may be some more to manage your inventory and sales (or CRM). 
+
 An ERP brings all of this together in one place.
 
-Small businesses are not so different from large ones. They contain most of the complexities of a large business along with many other constraints. 
-Small businesses have to communicate with customers, do accounts, pay taxes, do payroll, manage timelines, deliver quality, answer questions 
-and keep everyone happy just like in large businesses.
+Small businesses are not so different from large ones. They contain most of the complexities of a large business along with many other constraints. Small businesses have to communicate with customers, do accounts, pay taxes, do payroll, manage timelines, deliver quality, answer questions, and keep everyone happy just like in large businesses.
 
-Large businesses have the advantage of using advanced data systems to manage their process efficiently. 
-Small businesses typically struggle to keep things organized. They often use a mix of apps like spreadsheets, accounting software, web CRM etc to manage.The problem is, not everyone is on the same page. An ERP changes that.
+Large businesses have the advantage of using advanced data systems to manage their process efficiently. Small businesses, on the other hand, typically struggle to keep things organized. They often use a mix of apps like spreadsheets, accounting software, web CRM etc to manage.The problem is, not everyone is on the same page. An ERP changes that.
 
 ---
 
@@ -30,6 +27,13 @@
 
 ERPNext helps you to manage all your business information in one application and use it to manage operations and take decisions based on data.
 
+
+
+![ERPNext-Introduction](img/erpnext-introduction.png)
+
+
+
+
 Among other things, ERPNext will help you to:
 
 - Track all Invoices and Payments.
@@ -48,19 +52,19 @@
 
 ## Why Should I Use ERPNext?
 
-ERPNext is a modern tool that covers not only accounting but also all other business functions on an integrated platform. It has many benefits over both traditional accounting as well as ERP applications.
+ERPNext is a modern tool that covers not only accounting but also all other business functions, on an integrated platform. It has many benefits over both traditional accounting as well as ERP applications.
 
 ### Benefits over traditional accounting software:
 
 - Do a lot more than just accounting! Manage inventory, billing, quotes, leads, payroll and a lot more.
 - Keep all your data safe and in one place. Don’t keep hunting for data when you need it across spreadsheets and different computers.
 -Manage everyone on the same page. All users get the same updated data.
-- Stop repetitive work. Don’t enter the same information from your word processor to your accounting tool. Its all integrated.
+- Stop repetitive work. Don’t enter the same information from your word processor to your accounting tool. It's all integrated.
 - Keep track. Get the entire history of a customer or a deal in one place.
 
 ### Benefits over big ERPs
 
-- $$$ - Save money.
-- Easier to configure. Big ERPs are notoriously hard to setup and will ask you a zillion questions before you can do something meaningful.
-- Easier to use. Modern web like user interface will keep your users happy and in familiar territory.
-- Open Source. This software is always free and you can host it anywhere you like.
+- $$$ - Saves money.
+- **Easier to configure:** Big ERPs are notoriously hard to setup and will ask you a zillion questions before you can do something meaningful.
+- **Easier to use:** Modern web like user interface will keep your users happy and in familiar territory.
+- **Open Source :** This software is always free and you can host it anywhere you like.
\ No newline at end of file
diff --git a/docs/user/intro/docs.user.intro.open_source.md b/docs/user/intro/docs.user.intro.open_source.md
index 37e23c4..bc36ce4 100644
--- a/docs/user/intro/docs.user.intro.open_source.md
+++ b/docs/user/intro/docs.user.intro.open_source.md
@@ -8,9 +8,9 @@
 Advantages of an Open Source software are:
 
 1. You can choose to change your service provider anytime.
-1. You can host the application anywhere, including your own server so you have complete ownership and privacy of the data.
-1. There will always be a community to support you incase you need help and you are not dependant  only on your service provider.
-1. The product is critiqued and used by a wide range of people who have reported hundreds of issues and suggestions to make this product better, and this will always continue.
+1. You can host the application anywhere, including your own server to gain complete ownership and privacy of the data.
+1. You can access a community to support you, incase you need help. You are not dependant on your service provider.
+1. You can benefit from using a product that is critiqued and used by a wide range of people, who have reported hundreds of issues and suggestions to make this product better, and this will always continue.
 
 ---
 
@@ -22,5 +22,4 @@
 1. OpenBravo
 1. Apache OfBiz
 1. xTuple
-1. Compiere (and forks)
-
+1. Compiere (and forks)
\ No newline at end of file
diff --git a/docs/user/intro/docs.user.intro.try.md b/docs/user/intro/docs.user.intro.try.md
index 051caab..2a53ca5 100644
--- a/docs/user/intro/docs.user.intro.try.md
+++ b/docs/user/intro/docs.user.intro.try.md
@@ -7,7 +7,7 @@
 
 ### 1. See the Demo
 
-If you just want to check out the user interface and **feel** the application, just see the demo at:
+If you want to check out the user interface and **feel** the application, just see the demo at:
 
 - [https://demo.erpnext.com](https://demo.erpnext.com)
 
diff --git a/docs/user/mfg/docs.user.mfg.md b/docs/user/mfg/docs.user.mfg.md
index 9f01f76..3755987 100644
--- a/docs/user/mfg/docs.user.mfg.md
+++ b/docs/user/mfg/docs.user.mfg.md
@@ -3,7 +3,7 @@
 	"_label": "Manufacturing"
 }
 ---
-The Manufacturing module in ERPNext helps you maintain multi-level Bill of Materials (BOMs) for your Items, help you in Product Costing, plan your production via Production Plan, create Production Orders for your manufacturing shop floor and plan your inventory by getting your material requirement via your BOMs (also called Material Requirements Planning MRP).
+The Manufacturing module in ERPNext helps you to maintain multi-level Bill of Materials (BOMs) for your Items. It helps you in Product Costing, planing your production via Production Plan, creating Production Orders for your manufacturing shop floor,s and planing your inventory by getting your material requirement via BOMs (also called Material Requirements Planning MRP).
 
 ### Types of Production Planning
 
@@ -19,7 +19,7 @@
 
 #### Manufacturing and Inventory
 ￼
-You can track you work-in-progress by creating work-in-progress Warehouses. 
+You can track work-in-progress by creating work-in-progress Warehouses. 
 
 ERPNext will help you track material movement by automatically creating Stock Entries from your Production Orders by building form Bill of Materials.
 
diff --git a/docs/user/setup/docs.user.setup.accounting.md b/docs/user/setup/docs.user.setup.accounting.md
index af91539..10c7a15 100644
--- a/docs/user/setup/docs.user.setup.accounting.md
+++ b/docs/user/setup/docs.user.setup.accounting.md
@@ -9,15 +9,15 @@
 ---
 The Chart of Accounts forms the blueprint of your organization. The overall structure of your Chart of Accounts is based on a system of double entry accounting that has become a standard all over the world to quantify how a company is doing financially. 
 
-The Chart of Accounts helps you answer:
+The Chart of Accounts helps you to answer:
 
-- What is your organization worth?
+- What is your organisation worth?
 - How much debt have you taken?
 - How much profit are you making (and hence paying tax)?
 - How much are you selling?
-- What is your expense break- up
+- What is your expense break-up
 
- You may note that as a business manager,it is very valuable  to see how well your business is doing. 
+ You may note that as a business manager,it is very valuable to see how well your business is doing. 
 
 > Tip: If you can’t read a Balance Sheet (I confess it took me a long time to figure this out) its a good opportunity to start learning about this. It will be worth the effort. You can also take the help of your accountant to setup your Chart of Accounts.
 
@@ -39,7 +39,7 @@
 
 > Accounting: If you are new to accounting, you might be wondering, how can Assets be equal to Liabilities? That would mean the company has nothing of its own. Thats right. All the “investment” made in the company to buy assets (like land, furniture, machines) is made by the owners and is a liability to the company. If the company would want to shut down, it would need to sell all the assets and pay back all the liabilities (including profits) to the owners, leaving itself with nothing.
 
-All the accounts under this represent an asset owned by company like "Bank Account", "Land and Property", "Furniture" or a liability (funds that the company owes to others) like "Owners funds", "Debt" etc.
+All the accounts under this represent an asset owned by the company like "Bank Account", "Land and Property", "Furniture" or a liability (funds that the company owes to others) like "Owners funds", "Debt" etc.
 
 Two special accounts to note here are Accounts Receivable (money you have to collect from your customers) and Accounts Payable (money you have to pay to your suppliers) under Assets and Liabilities respectively.
 
diff --git a/docs/user/setup/docs.user.setup.cost_centers.md b/docs/user/setup/docs.user.setup.cost_centers.md
index ca5e595..4e36ced 100644
--- a/docs/user/setup/docs.user.setup.cost_centers.md
+++ b/docs/user/setup/docs.user.setup.cost_centers.md
@@ -8,9 +8,9 @@
 }
 ---
 
-Your Chart of Accounts is mainly for reporting your information for governmental purposes and less for how your business actually performs. Though you can tweak it a bit to resemble your business.
+Your Chart of Accounts is mainly designed to provide reports to the government and tax authorities.
 ￼
-Most businesses have multiple activities like different product lines, market segments, areas of business that share some common overheads but should ideally have their own structure to report whether they are profitable or not. For this purpose, there is an alternate structure, called the Chart of Cost Centers.
+Most businesses have multiple activities like different product lines, market segments, areas of business, etc that share some common overheads.They should ideally have their own structure to report, whether they are profitable or not. For this purpose, there is an alternate structure, called the Chart of Cost Centers.
 
 You can create a tree of Cost Centers to represent your business better. Each Income / Expense entry is also tagged against a Cost Center. 
 
@@ -21,7 +21,7 @@
 
 You may not have shipping expenses for your walk-in customers, and no shop-rent for your online customers. If you want to get the profitability of each of these separately, you create the two as Cost Centers and you can mark all sales as either "Walk-in" or "Online" and also all your purchases in the same way.
 
-So when you do your analysis you get a better understanding as to which side of your business is doing better.  Since ERPNext has an option to add multiple Companies, you can create Cost Centers for each Company and manage it separately.
+So when you do your analysis you get a better understanding as to which side of your business is doing better. Since ERPNext has an option to add multiple Companies, you can create Cost Centers for each Company and manage it separately.
 
 ### Chart of Cost Centers
 
@@ -35,7 +35,7 @@
 
 ERPNext will help you set and manage budgets on your Cost Centers. This is useful when, for example, you are doing online sales. You have a budget for search ads, and you want ERPNext to stop or warn you from over spending, based on that budget. 
 
-Budgets are also great for planning purposes. When you are making your plans for the next financial year, you would typically target a revenue based on which you would set your expenses. Setting a budget will ensure that your expenses do not get out of hand, at any point,as per your plans.
+Budgets are also great for planning purposes. When you are making plans for the next financial year, you would typically target a revenue based on which you would set your expenses. Setting a budget will ensure that your expenses do not get out of hand, at any point, as per your plans.
 
 You can define it in the Cost Center. If you have seasonal sales you can also define a budget distribution that the budget will follow.
 ￼
diff --git a/docs/user/setup/docs.user.setup.price_list.md b/docs/user/setup/docs.user.setup.price_list.md
index c746ee7..0103cc3d 100644
--- a/docs/user/setup/docs.user.setup.price_list.md
+++ b/docs/user/setup/docs.user.setup.price_list.md
@@ -2,4 +2,14 @@
 {
 	"_label": "Price Lists"
 }
----
\ No newline at end of file
+---
+
+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. 
+
+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.
+
+
+![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
diff --git a/docs/user/stock/docs.user.stock.delivery_note.md b/docs/user/stock/docs.user.stock.delivery_note.md
index b1d1736..3017a1b 100644
--- a/docs/user/stock/docs.user.stock.delivery_note.md
+++ b/docs/user/stock/docs.user.stock.delivery_note.md
@@ -13,6 +13,16 @@
 
 or from a “Submitted” Sales Order (that is not already shipped) by clicking on “Make Delivery Note”.
 
+
+
+
+![Delivery Note](img/delivery-note.png)
+
+
+
+
+
+
 You can also “fetch” the details from an unshipped Sales Order. 
 
 You will notice that all the information about unshipped Items and other details are carried over from your Sales Order.
diff --git a/docs/user/stock/docs.user.stock.item_group.md b/docs/user/stock/docs.user.stock.item_group.md
new file mode 100644
index 0000000..aca2a78
--- /dev/null
+++ b/docs/user/stock/docs.user.stock.item_group.md
@@ -0,0 +1,9 @@
+---
+{
+	"_label": "Item Group"
+}
+---
+
+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.
diff --git a/docs/user/stock/docs.user.stock.material_issue b/docs/user/stock/docs.user.stock.material_issue
new file mode 100644
index 0000000..e372e7f
--- /dev/null
+++ b/docs/user/stock/docs.user.stock.material_issue
@@ -0,0 +1,26 @@
+---
+{
+	"_label": "Material Issue"
+}
+---
+
+A Warehouse stocks materials required for manufacturing or trading. The Material Issue form has to be submitted to order materials out of a Warehouse by any department.
+
+> Stock > Stock Entry > New Stock Entry
+
+
+Go to Stock Entry.
+Click on New Stock Entry
+Select the option “Material Issue” under Purpose.
+Provide Source Warehouse details.
+Provide the BOM Number.
+Save
+
+
+![Material Issue](img/material-issue.png)
+
+
+
+
+
+Note: If you have done a stock entry and selected “Material Issue” under Purpose, that particular amount of stock will reflect as negative in stock details.
diff --git a/docs/user/stock/docs.user.stock.material_issue.md b/docs/user/stock/docs.user.stock.material_issue.md
new file mode 100644
index 0000000..45e3d98
--- /dev/null
+++ b/docs/user/stock/docs.user.stock.material_issue.md
@@ -0,0 +1,26 @@
+---
+{
+	"_label": "Material Issue"
+}
+---
+
+A Warehouse stocks materials required for manufacturing or trading. The Material Issue form has to be submitted to order materials out of a Warehouse by any department.
+
+> Stock > Stock Entry > New Stock Entry
+
+
+Go to Stock Entry.
+Click on New Stock Entry
+Select the option “Material Issue” under Purpose.
+Provide Source Warehouse details.
+Provide the BOM Number.
+Save
+
+
+![Material Issue](img/material-issue.png)
+
+
+
+
+
+Note: If you have done a stock entry and selected “Material Issue” under Purpose, that particular amount of stock will reflect as negative in stock details.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.md b/docs/user/stock/docs.user.stock.md
index 820a4c7..85392ea 100644
--- a/docs/user/stock/docs.user.stock.md
+++ b/docs/user/stock/docs.user.stock.md
@@ -3,6 +3,13 @@
 	"_label": "Stock / Inventory"
 }
 ---
+
+![Stock-Inventory](img/stock-inventory.png)
+
+
+
+
+
 For most small business that deal in physical goods, a large part of their net worth is invested in the stock in hand. 
 
 ### Best Practice
@@ -10,7 +17,7 @@
 There are two aspects to good material management:
 
 - **Good housekeeping / visual control:** Keep all your items in separate bins,neatly stacked and labelled.  “A place for everything and everything in its place” 
-- **Accurate Data:** Accurate data comes from good processes and recording each and every transaction. If you are only partially recording your inventory then your reports will be incorrect  “Garbage In Garbage Out”
+- **Accurate Data:** Accurate data comes from good processes and recording each and every transaction. If you are only partially recording your inventory then your reports will be incorrect   “Garbage In Garbage Out”
 
 If you have good processes to control movement of goods within your organization, implementation in ERPNext will be a breeze.
 
@@ -30,5 +37,4 @@
 - Stock has to be valued based on First-in-First-out: ERPNext needs to maintain a sequence of all transactions to know the exact value of your Items.
 - Stock reports are required at any point in time in the past: You have to lookup what was the quantity / value your stock of Item X on date Y. 
 
-To manage this, ERPNext collects all inventory transactions in a table called the Stock Ledger Entry. All Purchase Receipts, Stock Entries and Delivery Notes update this table.
-
+To manage this, ERPNext collects all inventory transactions in a table called the Stock Ledger Entry. All Purchase Receipts, Stock Entries and Delivery Notes update this table.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.projected_quantity.md b/docs/user/stock/docs.user.stock.projected_quantity.md
new file mode 100644
index 0000000..8fff133
--- /dev/null
+++ b/docs/user/stock/docs.user.stock.projected_quantity.md
@@ -0,0 +1,27 @@
+---
+{
+	"_label": "Projected Quantity"
+}
+---
+
+Projected Quantity is the level of stock that is predicted for a particular Item, based on the current stock levels and other requirements.It is the quantity of gross inventory that includes supply and demand in the past which is done as part of the planning process.
+
+The projected inventory is used by the planning system to monitor the reorder point and to determine the reorder quantity. The projected Quantity is used by the planning engine to monitor the safety stock levels. These levels are maintained to serve unexpected demands.
+
+Having a tight control of the projected inventory is crucial to determine shortages and to calculate the right order quantity.
+
+
+
+![Projected Quantity Stock Report](img/projected-quantity-stock-report.png)
+
+
+
+
+
+> Projected Qty = Actual Qty + Planned Qty + Requested Qty + Ordered Qty - Reserved Qty
+
+- Actual Qty: Quantity available in the warehouse.
+- Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.
+- Requested Qty: Quantity requested for purchase, but not ordered.
+- Ordered Qty: Quantity ordered for purchase, but not received.
+- Reserved Qty: Quantity ordered for sale, but not delivered.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.purchase_receipt b/docs/user/stock/docs.user.stock.purchase_receipt
new file mode 100644
index 0000000..fd934d2
--- /dev/null
+++ b/docs/user/stock/docs.user.stock.purchase_receipt
@@ -0,0 +1,24 @@
+---
+{
+	"_label": "Purchase Return"
+}
+---
+ERPNext has an option to account for products that are returned to the supplier. This may be on account of a number of reasons like defects in goods, quality not matching, the buyer not needing the stock, etc. The transactions dealing with return of goods are also accounting transactions and have to be recorded in the books of accounts just like any other accounting transaction. 
+
+
+> Stock > Stock Entry > New Stock Entry
+
+
+![Purchase Return](img/purchase-return.png)
+
+
+
+
+
+
+- To select Purchase Return go to Stock Entry.
+- Select Purchase Return under Purpose.
+- Enter Purchase Receipt number.
+- Enter Source Warehouse details.
+- Provide Supplier Information.
+- Save the document.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.purchase_receipt.md b/docs/user/stock/docs.user.stock.purchase_receipt.md
index 1d403d5..a2e428d 100644
--- a/docs/user/stock/docs.user.stock.purchase_receipt.md
+++ b/docs/user/stock/docs.user.stock.purchase_receipt.md
@@ -13,6 +13,14 @@
 
 or from a “Submitted” Purchase Order, by clicking on “Make Purchase Receipt”.
 
+
+
+![Purchase Receipt](img/purchase-receipt.png)
+
+
+
+
+
 ### Rejections
 
 In the Purchase Receipt, you are required to enter whether all the materials you receive are of accepted quality (in case you check). If you have any rejections, update the “Rejected Quantity” column in the Items table.
@@ -21,7 +29,7 @@
 
 ### Quality Inspections
 
-If for certain Items it is mandatory for you to record Quality Inspections (you have set it in your Item master), you will need to update the “Quality Inspection No” (QA No) column. The system will only allow you to “Submit” the Purchase Receipt if you update the “Quality Inspection No”.
+If for certain Items, it is mandatory to record Quality Inspections (if you have set it in your Item master), you will need to update the “Quality Inspection No” (QA No) column. The system will only allow you to “Submit” the Purchase Receipt if you update the “Quality Inspection No”.
 
 ### UOM Conversions
 
diff --git a/docs/user/stock/docs.user.stock.purchase_return.md b/docs/user/stock/docs.user.stock.purchase_return.md
new file mode 100644
index 0000000..13a325a
--- /dev/null
+++ b/docs/user/stock/docs.user.stock.purchase_return.md
@@ -0,0 +1,23 @@
+---
+{
+	"_label": "Purchase Return"
+}
+---
+ERPNext has an option to account for products that are returned to the supplier.This may be on account of a number of reasons like defects in goods, quality not matching, the buyer not needing the stock, etc. The transactions dealing with return of goods are also accounting transactions and have to be recorded in the books of accounts just like any other accounting transaction. 
+
+
+> Stock > Stock Entry > New Stock Entry
+
+
+![Purchase Return](img/purchase-return.png)
+
+
+
+
+- To select Purchase Return go to Stock Entry.
+- Select Purchase Return under Purpose.
+- Enter Purchase Receipt number.
+- Enter Source Warehouse details.
+- Provide Supplier Information.
+- Save the document.
+
diff --git a/docs/user/stock/docs.user.stock.sales_return.md b/docs/user/stock/docs.user.stock.sales_return.md
new file mode 100644
index 0000000..3198db0
--- /dev/null
+++ b/docs/user/stock/docs.user.stock.sales_return.md
@@ -0,0 +1,21 @@
+---
+{
+	"_label": "Sales Return"
+}
+---
+Goods sold being returned is quite a common practice in Business. They could be returned by the customer on quality issues, non-delivery on agreed date, or any other reason. ERPNext allows this transaction for ease of accounting.
+
+> Stock > Stock Entry > New Stock Entry
+
+
+
+![Sales Return](img/sales-return.png)
+
+
+
+
+- For Sales Return click on Stock Entry
+- Select Sales Return under Purpose
+- Mention the Delivery Note number and the Sales Invoice number.
+- Mention Contact Information of the Customer.
+- Save the file.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.stock_entry.md b/docs/user/stock/docs.user.stock.stock_entry.md
index 8eda743..0b49585 100644
--- a/docs/user/stock/docs.user.stock.stock_entry.md
+++ b/docs/user/stock/docs.user.stock.stock_entry.md
@@ -5,6 +5,20 @@
 ---
 A Stock Entry is a simple document that lets you record Item movement from a Warehouse, to a Warehouse and between Warehouses.
 
+To make a Stock Entry you have to go to:
+
+> Stock > Stock Entry
+
+
+
+
+
+![Stock Entry](img/stock-entry.png)
+
+
+
+
+
 This can also be useful in tracking:
 
 - Material Issues from Stores
@@ -13,11 +27,7 @@
 
 We will look into the special features of the Stock Entry later when we discuss Accounting and Manufacturing processes.
 
-To make a Stock Entry you have to go to:
-
-> Stock > Stock Entry
 
 In the Stock Entry you have to update the Items table with all your transactions. For each row, you must enter a “Source Warehouse” or a “Target Warehouse” or both (if you are recording a movement).
 
-> **Note:** To update Stock from a spreadsheet, see Stock Reconciliation.
-
+> **Note:** To update Stock from a spreadsheet, see Stock Reconciliation.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.sub_contracting.md b/docs/user/stock/docs.user.stock.sub_contracting.md
index 7538404..23a102c 100644
--- a/docs/user/stock/docs.user.stock.sub_contracting.md
+++ b/docs/user/stock/docs.user.stock.sub_contracting.md
@@ -10,7 +10,17 @@
 1. Create separate Items for the unprocessed and the processed product. For example if you supply unpainted X to your Supplier and the Supplier returns you X, you can create two Items: “X-unpainted” and “X”.
 1. Create a Warehouse for your Supplier so that you can keep track of Items supplied. (you may supply a months worth of Items in one go).
 1. For the processed Item, in the Item master, set “Is Sub Contracted Item” to “Yes”.
-1. Make a Bill of Materials for the processed Item, with the unprocessed Items as sub-items.
+
+
+
+![Subcontract](img/subcontract.png)
+
+
+
+
+
+
+1. Make a Bill of Materials for the processed Item, with the unprocessed Items as sub-items.For example, If you are manufacturing a pen, the processed pen will be named under Bill of Materials(BOM), whereas, the refill, knob, and other items which go into the making of pen, will be categorised as sub-items.
 1. Make a Purchase Order for the processed Item. When you “Save”, in the “Raw Materials Detail”, all your un-processed Items will be updated based on your Bill of Materials.
 	1. Make sure that the “Rate” of this Item is the processing rate (excluding the raw material rate).
 	1. ERPNext will automatically add the raw material rate for your valuation purpose when you receive the finished Item in your stock. 
diff --git a/docs/user/stock/docs.user.stock.warehouse.md b/docs/user/stock/docs.user.stock.warehouse.md
new file mode 100644
index 0000000..dd8273a
--- /dev/null
+++ b/docs/user/stock/docs.user.stock.warehouse.md
@@ -0,0 +1,30 @@
+---
+{
+	"_label": "Warehouse"
+}
+---
+
+A warehouse is a commercial building for storage of goods. Warehouses are used by manufacturers, importers, exporters, wholesalers, transport businesses, customs, etc. They are usually large plain buildings in industrial areas of cities,towns, and villages. They usually have loading docks to load and unload goods from trucks.
+
+To go to Warehouse, click on Stock and go to Warehouse under Masters.
+
+
+> Stock > Warehouse > New Warehouse
+
+
+
+![Warehouse](img/warehouse.png)
+
+
+
+
+In ERPNext, every different company can have a separate Warehouse. Every Warehouse will belong to a specific company. User can get company wise accurate stock balance. The Warehouses are saved with their respective company’s abbreviations. This facilitates in identifying which Warehouse belongs to which company, at a glance.
+
+You can include user restrictions for these Warehouses. In case you do not wish a particular user to operate on a particular Warehouse, you can refrain the user from accessing that Warehouse.
+
+### Merge Warehouse
+
+In day to day transactions, if duplicate entries are done by mistake resulting in duplicate Warehouse, these mistakes can be rectified. Duplicate records can be merged into a single Warehouse. Enter the place where you want to keep all the warehouse records. Click on the Merge button. Once this transaction is done, delete the empty Warehouse.
+
+ERPNext system maintains stock balance for every distinct combination of Item and Warehouse. Thus you can get stock balance for any specific Item in a particular Warehouse on any particular date.
+
