diff --git a/docs/docs.user.accounts.pos.md b/docs/docs.user.accounts.pos.md
index a4ca430..9cb5079 100644
--- a/docs/docs.user.accounts.pos.md
+++ b/docs/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/docs.user.help.md b/docs/docs.user.help.md
index 55d12d2..9563ce1 100644
--- a/docs/docs.user.help.md
+++ b/docs/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/docs.user.implement.concepts.md b/docs/docs.user.implement.concepts.md
index ac481d4..31b4358 100644
--- a/docs/docs.user.implement.concepts.md
+++ b/docs/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/docs.user.implement.md b/docs/docs.user.implement.md
index f42d661..59f2c49 100644
--- a/docs/docs.user.implement.md
+++ b/docs/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/docs.user.implement.strategy.md b/docs/docs.user.implement.strategy.md
index 3abb91a..9ec58e8 100644
--- a/docs/docs.user.implement.strategy.md
+++ b/docs/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/docs.user.intro.md b/docs/docs.user.intro.md
index a6debe8..5c1cb56 100644
--- a/docs/docs.user.intro.md
+++ b/docs/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/docs.user.intro.open_source.md b/docs/docs.user.intro.open_source.md
index 37e23c4..bc36ce4 100644
--- a/docs/docs.user.intro.open_source.md
+++ b/docs/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/docs.user.intro.try.md b/docs/docs.user.intro.try.md
index 051caab..2a53ca5 100644
--- a/docs/docs.user.intro.try.md
+++ b/docs/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/docs.user.md b/docs/docs.user.md
index 1d22e8c..4086521 100644
--- a/docs/docs.user.md
+++ b/docs/docs.user.md
@@ -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)
