diff --git a/docs/docs.user.selling.customer.md b/docs/docs.user.selling.customer.md
index 1c2c22d..05c4d96 100644
--- a/docs/docs.user.selling.customer.md
+++ b/docs/docs.user.selling.customer.md
@@ -10,7 +10,6 @@
 
 or upload it via the Data Import Tool.
 
-In your normal operations, you can also create Customers from Leads.
 
 > Note: Customers are separate from Contacts and Addresses. A Customer can have multiple Contacts and Addresses.
 
@@ -20,7 +19,7 @@
 
 To add a Contact or Address directly from the Customer record, click on “New Contact” or “New Address”.
 
-> Tip: When you select a Customer 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!
+> Tip: When you select a Customer in any transaction, one Contact and Address gets pre-selected. This is the “Default Contact or Address”. 
 
 To Import multiple Contacts and Addresses from a spreadsheet, use the Data Import Tool.
 
diff --git a/docs/docs.user.setup.email.md b/docs/docs.user.setup.email.md
index 371ef93..17ef4b6 100644
--- a/docs/docs.user.setup.email.md
+++ b/docs/docs.user.setup.email.md
@@ -27,7 +27,7 @@
 
 A very useful email integration is to sync the incoming emails from support inbox into Support Ticket, so that you can track, assign and monitor support issues.
 
-> **Case Study:** Here are ERPNext, we have regularly tracking incoming support issues via email at “support@erpnext.com”. At the time of writing we have answered more than 3000 tickets via this system.
+> **Case Study:** Here at ERPNext, we have regularly tracked incoming support issues via email at “support@erpnext.com”. At the time of writing we had answered more than 3000 tickets via this system.
 
 To setup your Support integration, go to:
 
@@ -35,7 +35,7 @@
 
 To make ERPNext pull emails from your mail box, enter the POP3 settings. (POP3 is a way of extracting emails from your mailbox. It should be fairly easy to find out what your POP3 settings are. If you have problems, contact your email service provider).
 If you want to setup an auto reply, check on the “Send Autoreply” box and whenever someone sends an email, an autoreply will be sent.
-Add a custom signature you want to send with your replies. 
+Add a custom signature which you want to send with your replies. 
 
 ### Setting Auto-notification on Documents
 
@@ -49,7 +49,7 @@
 
 Email Digests allow you to get regular updates about your sales, expenses and other critical numbers directly in your Inbox. 
 
-Set your frequency, check all the items you want to receive in your weekly update and select the user ids who you want to send the Digest to.
+Set your frequency, check all the items you want to receive in your weekly update and select the user ids whom you want to send the Digest to.
 
 Email Digests are a great way for top managers to keep track of the big numbers like “Sales Booked” or “Amount Collected” or “Invoices Raised” etc.
 
