diff --git a/docs/user/accounts/docs.user.accounts.pos.md b/docs/user/accounts/docs.user.accounts.pos.md
index 654a5d6..7bd668e 100644
--- a/docs/user/accounts/docs.user.accounts.pos.md
+++ b/docs/user/accounts/docs.user.accounts.pos.md
@@ -13,33 +13,34 @@
 
 - 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. 
+- 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.
 
-Setup [POS Setting](docs.user.setup.pos_setting.html)
 
 #### 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.
+- Every Sales & Purchase documents 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/pos-features-setup.png)
 
+- Setup [POS Setting](docs.user.setup.pos_setting.html)
+
 ### 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. 
+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 / Serial No. 
 
 **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.
 
-**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.
+**Barcode / Serial No** - A Barcode / Serial No is an optical machine-readable representation of data relating to the object to which it is attached. Enter Barcode / Serial No in the box as shown in the image below and pause for a second, the item will be automatically added to the cart.
 
 ![POS](img/pos-add-item.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. 
+If your product list is very long use the Search field, type the product name in Search box. 
 
 ### Removing an Item
 
@@ -48,7 +49,7 @@
 - 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.
+- Enter 0(zero) quantity of any item to delete that item.
 
 To remove multiple Items together, select multiple rows & click on “Del” button. 
 
@@ -62,11 +63,11 @@
 
 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.
+1. Click on “Pay” button to Save the document.
 
 ![POS Payment](img/pos-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.
+Submit the document to finalise the record. After the document is submitted, you can either print or email it directly to the customer.
 
 #### Accounting entries (GL Entry) for a Point of Sale:
 
diff --git a/docs/user/setup/docs.user.setup.price_list.md b/docs/user/setup/docs.user.setup.price_list.md
index 021df09..7214fff 100644
--- a/docs/user/setup/docs.user.setup.price_list.md
+++ b/docs/user/setup/docs.user.setup.price_list.md
@@ -7,7 +7,7 @@
 
 An Item can have multiple prices based on customer, currency, region, shipping cost etc, which can be stored as different rate plans. In ERPNext, you are required to store all the lists seperately. Buying Price List is different from Selling Price List and thus is stored separately. 
 
-> Selling > Price List
+> Setup > Price List
 
 
 ![Price-List](img/price-lists.png)
@@ -15,7 +15,14 @@
 
 > For multiple currencies, maintain multiple Price Lists.
 
+<br>
+### Add Item in Price List
 
-To add a new Item to the Price List, add the Item Code and its rate in the Item Prices table.
+> Setup > Item Price
 
-You can also import Item Prices via [Data Import Tool](docs.user.setup.data_import.html)
\ No newline at end of file
+- Enter Price List and Item Code, Valid for Buying or Selling, Item Name & Item Description will be automatically fetched.
+- Enter Rate and save the document.
+
+![Item-Price](img/item-price.png)
+
+For bulk upload of Item Prices, use [Data Import Tool](docs.user.setup.data_import.html)
\ No newline at end of file
