diff --git a/docs/user/accounts/docs.user.accounts.md b/docs/user/accounts/docs.user.accounts.md
index 21a43e3..01ce425 100644
--- a/docs/user/accounts/docs.user.accounts.md
+++ b/docs/user/accounts/docs.user.accounts.md
@@ -15,6 +15,9 @@
 }
 ---
 
+![Accounts](img/accounts-image.png)
+
+
 
 At end of the sales and purchase cycle is billing and payments. You may have an accountant in your team, or you may be doing accounting yourself or you may have outsourced your accounting. Financial accounting forms the core of any business management system like an ERP.
 
diff --git a/docs/user/accounts/docs.user.accounts.opening_entry.md b/docs/user/accounts/docs.user.accounts.opening_entry.md
new file mode 100644
index 0000000..f8d0841
--- /dev/null
+++ b/docs/user/accounts/docs.user.accounts.opening_entry.md
@@ -0,0 +1,10 @@
+---
+{
+	"_label": "Opening Entry"
+}
+---
+
+If you are a new company you can start using ERPNext accounting module by going to chart of accounts.
+
+However, if you are migrating from a legacy accounting system like Tally or a Fox Pro based software, please visit [Opening Entry](docs.user.setup.opening.html)
+
diff --git a/docs/user/accounts/docs.user.accounts.opening_stock.md b/docs/user/accounts/docs.user.accounts.opening_stock.md
new file mode 100644
index 0000000..3ba5025
--- /dev/null
+++ b/docs/user/accounts/docs.user.accounts.opening_stock.md
@@ -0,0 +1,21 @@
+---
+{
+	"_label": "Opening Stock"
+}
+---
+
+
+You can upload your opening stock in the system using Stock Reconciliation. Stock Reconciliation will update your stock for a given Item on a given date for a given Warehouse to the given quantity.
+
+Stock Reconciliation will make a “difference entry” (the difference between the system stock and the actual stock in your file) for the Item.
+
+Tip: Stock Reconciliation can also be used to update the “value” of an Item.
+
+To make a Stock Reconciliation, go to:
+
+> Stock > Stock Reconciliation > New Stock Reconciliation
+
+and follow the steps mentioned on the page.
+
+![Stock Reconciliation](img/stock-reconciliation1.png)
+
diff --git a/docs/user/accounts/docs.user.accounts.purchase_invoice.md b/docs/user/accounts/docs.user.accounts.purchase_invoice.md
index 32be689..9f43d4b 100644
--- a/docs/user/accounts/docs.user.accounts.purchase_invoice.md
+++ b/docs/user/accounts/docs.user.accounts.purchase_invoice.md
@@ -44,7 +44,7 @@
 
 ---
 
-#### Is a purchase an “Expense” or “Asset”?
+#### Is purchase an “Expense” or an “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.
 
diff --git a/docs/user/customize/docs.user.customize.custom_field.md b/docs/user/customize/docs.user.customize.custom_field.md
index 1dd2340..a457f07 100644
--- a/docs/user/customize/docs.user.customize.custom_field.md
+++ b/docs/user/customize/docs.user.customize.custom_field.md
@@ -7,6 +7,10 @@
 
 > Setup > Custom Field > New Custom Field
 
+![Custome Field](img/custom-field.png)
+
+
+
 In the form:
 
 - Select the Document on which you want to add the Custom Field.
diff --git a/docs/user/customize/docs.user.customize.custom_form.md b/docs/user/customize/docs.user.customize.custom_form.md
index 2e649ae..6b37bd1 100644
--- a/docs/user/customize/docs.user.customize.custom_form.md
+++ b/docs/user/customize/docs.user.customize.custom_form.md
@@ -9,9 +9,13 @@
 
 > Setup > Customize ERPNext > Customize Forms
 
+
+![Customize Forms](img/customize-form-1.png)
+
+
 Select the Form you want to customize and the fields table will be updated with the fields from that form. Here you can:
 
-- Change field types (for e.g. you want to increase the number of decimal places, you can convert come fields from Float to Currency).
+- Change field types (for e.g. you want to increase the number of decimal places, you can convert some fields from Float to Currency).
 - Change labels to suit your industry / language.
 - Make certain fields mandatory.
 - Hide certain fields.
@@ -20,4 +24,12 @@
 
 You can also allow attachments, set max number of attachments and set the default Print Format.
 
+
+![Customize Forms](img/customize-form-2.png)
+
+
+<br>
+
+
+
 > Though we want you to do everything you can to customize your ERP based on your business needs, we recommend that you do not make “wild” changes to the forms. This is because, these changes may affect certain operations and may mess up your forms. Make small changes and see its effect before doing some more.
\ No newline at end of file
diff --git a/docs/user/customize/docs.user.customize.custom_scripts.md b/docs/user/customize/docs.user.customize.custom_scripts.md
index 9b6c91f..d885ba5 100644
--- a/docs/user/customize/docs.user.customize.custom_scripts.md
+++ b/docs/user/customize/docs.user.customize.custom_scripts.md
@@ -3,4 +3,10 @@
 	"_label": "Custom Scripts"
 }
 ---
+If you wish to change any ERPNext form formats, you can do so by using Custom Scripts. For example, if you wish to add a submit button after saving, to a Lead form, you can do so by creating your own script.
+
+> Setup > Customization > Custom Script
+
+
+![Custom Script](img/custom-script.png)
 
diff --git a/docs/user/customize/docs.user.customize.hide_unhide.md b/docs/user/customize/docs.user.customize.hide_unhide.md
index ff64b24..8edf8f6 100644
--- a/docs/user/customize/docs.user.customize.hide_unhide.md
+++ b/docs/user/customize/docs.user.customize.hide_unhide.md
@@ -7,7 +7,10 @@
 
 As you have seen from this manual that ERPNext contains tons of features which you may not use. We have observed that most users start with using 20% of the features, though a different 20%. To hide fields belonging to features you dont require, go to:
 
-> Setup > Customize ERPNext > Disable Features.
+> Setup > Tools > Hide/Unhide Features
+
+![Hide Features](img/hide-features.png)
+
 
 Check / uncheck the features you want to use and refresh your page for the changes to take effect.
 
@@ -17,6 +20,9 @@
 
 To hide modules (icons) from the home page, go to:
 
-Setup > Customize ERPNext > Modules Setup
+Setup > Tools> Modules Setup
+
+![Hide/Unhide Modules](img/hide-module.png)
+
 
 > Note: Modules are automatically hidden for users that have no permissions on the documents within that module. For example, if a user has no permissions on Purchase Order, Purchase Request, Supplier, the “Buying” module will automatically be hidden.
diff --git a/docs/user/customize/docs.user.customize.print_format.md b/docs/user/customize/docs.user.customize.print_format.md
index f8970c4..eed52bd 100644
--- a/docs/user/customize/docs.user.customize.print_format.md
+++ b/docs/user/customize/docs.user.customize.print_format.md
@@ -8,11 +8,18 @@
 - The auto-generated “Standard” Print Format: This type of format follows the same layout as the form and is generated automatically by ERPNext.
 - Based on the Print Format document. There are templates in HTML that will be rendered with data.
 
-ERPNext comes with a number of pre-defined templates in three styles: Modern, Classic and Spartan. You modify these templates or create their own. Editing ERPNext templates is not allowed because they may be over-written in an upcoming release.
+ERPNext comes with a number of pre-defined templates in three styles: Modern, Classic and Spartan. You modify these templates or create your own. Editing ERPNext templates is not allowed because they may be over-written in an upcoming release.
 
 To create your own versions, open an existing template from:
 
-> Setup > Branding and Printing > Print Formats
+> Setup > Printing > Print Formats
+
+
+![Print Format](img/print-format.png)
+
+<br>
+
+
 
 Select the type of Print Format you want to edit and click on the “Copy” button on the right column. A new Print Format will open up with “Is Standard” set as “No” and you can edit the Print Format.
 
diff --git a/docs/user/docs.user.md b/docs/user/docs.user.md
index a4e996c..22ea4a7 100644
--- a/docs/user/docs.user.md
+++ b/docs/user/docs.user.md
@@ -15,7 +15,8 @@
 		"docs.user.projects",
 		"docs.user.website",
 		"docs.user.tools",
-		"docs.user.customize"
+		"docs.user.customize",
+		"docs.user.knowledge"
 	],
 	"_no_toc": 1
 }
@@ -99,9 +100,9 @@
 	1. [Payment Entry](docs.user.accounts.payments.html)
 	1. [Journal Voucher](docs.user.accounts.journal_voucher.html)
 	1. [Opening Entry](docs.user.accounts.opening_entry.html)
+	1. [Opening Stock](docs.user.accounts.opening_stock.html)
 	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)
@@ -121,10 +122,11 @@
 	1. [Maintenance Schedule](docs.user.support.maintenance_schedule.html)
 	1. [Maintenance Visit](docs.user.support.maintenance_visit.html)
 	1. [Maintenance Schedule](docs.user.support.maintenance_schedule.html)
+	1. [Newsletter](docs.user.support.newsletter.html)
 1. [Projects](docs.user.projects.html)
 	1. [Projects](docs.user.projects.projects.html)
 	1. [Task](docs.user.projects.task.html)
-	1. [Time Log](docs.user.projects.time_log.html)
+	1. [Time Log](docs.user.projects.timelog.html)
 1. [Website](docs.user.website.html)
 	1. [Setup](docs.user.website.setup.html)
 	1. [Web Pages](docs.user.website.web_page.html)
@@ -136,9 +138,15 @@
 	1. [Calendar](docs.user.tools.calendar.html)
 	1. [Assignments](docs.user.tools.assignment.html)
 	1. [Tags](docs.user.tools.tags.html)
+	1. [Forms](docs.user.tools.form_tools.html)
+	1. [Messages](docs.user.tools.messages.html)
+	1. [Notes](docs.user.tools.notes.html)
 1. [Customize](docs.user.customize.html)
 	1. [Custom Fields](docs.user.customize.custom_field.html)
 	1. [Customize Form](docs.user.customize.custom_form.html)
 	1. [Hide / Unhide modules](docs.user.customize.hide_unhide.html)
 	1. [Print Formats](docs.user.customize.print_formats.html)
-	1. [Custom Scripts](docs.user.customize.custom_scripts.html)
\ No newline at end of file
+	1. [Custom Scripts](docs.user.customize.custom_scripts.html)
+1. [Knowledge Library](docs.user.knowledge.html)
+	1. [Fiscal Year](docs.user.knowledge.fiscal_year.html)
+	1. [Accounting Knowledge](docs.user.knowledge.accounting.html)
\ No newline at end of file
diff --git a/docs/user/hr/docs.user.hr.payroll.md b/docs/user/hr/docs.user.hr.payroll.md
index 598be00..9da590d 100644
--- a/docs/user/hr/docs.user.hr.payroll.md
+++ b/docs/user/hr/docs.user.hr.payroll.md
@@ -17,7 +17,7 @@
 
 
 ![Salary Structure](img/salary-structure.png)
-s
+
 
 ### In the Salary Structure,
 
diff --git a/docs/user/intro/docs.user.implement.concepts.md b/docs/user/intro/docs.user.implement.concepts.md
index 31b4358..9fc4012 100644
--- a/docs/user/intro/docs.user.implement.concepts.md
+++ b/docs/user/intro/docs.user.implement.concepts.md
@@ -13,7 +13,7 @@
 
 This represents the Company records for which ERPNext is setup. With this same setup, you can create multiple Company records, each representing a different legal entity. The accounting for each Company will be different, but they will share the Customer, Supplier and Item records.
 
-> Setup > Company > Companies
+> Setup > Company 
 
 #### Customer
 
@@ -59,11 +59,11 @@
 
 #### Price List
 
-A table of sale price for an Item. An Item can have multiple prices based on Customer / Supplier or Territory etc..
+A Price List is a place where different rate plans can be stored. It’s a name you give to a set of Item Prices stored under a particular List.
 
-> Selling > Setup > Price List
+> Selling > Price List
 
-> Buying > Setup > Price List
+> Buying > Price List
 
 ---
 
@@ -73,7 +73,7 @@
 
 Represents a Financial Year or Accounting Year. You can operate multiple Fiscal Years at the same time. Each Fiscal Year has a start date and an end date and transactions can only be recorded in this period. When you “close” a fiscal year, it's balances are transferred as “opening” balances for the next fiscal year.
 
-> Setup > Company > Fiscal Years
+> Setup > Company > Fiscal Year
 
 #### Cost Center
 
@@ -85,7 +85,7 @@
 
 A document that contains General Ledger (GL) entries and the sum of Debits and Credits of those entries is the same. In ERPNext you can update Payments, Returns etc using Journal Vouchers.
 
-> Accounts > Journal Vouchers
+> Accounts > Journal Voucher
 
 #### Sales Invoice
 
@@ -103,7 +103,7 @@
 
 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
+> Setup > Currency
 
 ---
 
@@ -113,7 +113,7 @@
 
 A classification of Customers, usually based on market segment.
 
-> Selling > Setup (sidebar) > Customer Group
+> Selling > Setup > Customer Group
 
 #### Lead
 
@@ -215,19 +215,19 @@
 
 Update Stock of multiple Items from a spreadsheet (CSV) file.
 
-> Stock > Stock Reconciliation (in sidebar)
+> Stock > Stock Reconciliation
 
 #### Quality Inspection
 
 A note prepared to record certain parameters of an Item at the time of Receipt from Supplier, or Delivery to Customer.
 
-> Stock > Tools > Quality Inspection
+> Stock > Quality Inspection
 
 #### Item Group
 
 A classification of Item.
 
-> Stock > Setup (sidebar) > Item Group
+> Stock > Setup > Item Group
 
 ---
 
@@ -249,7 +249,7 @@
 
 A type of leave (for example, Sick Leave, Maternity Leave etc.)
 
-> Human Resource > Leave and Attendance (sidebar) > Leave Type
+> Human Resource > Leave and Attendance > Leave Type
 
 #### Salary Manager
 
@@ -357,7 +357,7 @@
 
 Text of your terms of contract.
 
-> Selling > Setup > Terms and Conditions Template
+> Selling > Setup > Terms and Conditions 
 
 #### Unit of Measure (UOM)
 
diff --git a/docs/user/intro/docs.user.implement.md b/docs/user/intro/docs.user.implement.md
index 59f2c49..79c8576 100644
--- a/docs/user/intro/docs.user.implement.md
+++ b/docs/user/intro/docs.user.implement.md
@@ -7,6 +7,11 @@
 	]
 }
 ---
+
+![Implementation](img/implementation-image.png)
+
+
+
 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.**
diff --git a/docs/user/knowledge/docs.user.knowledge.accounting.md b/docs/user/knowledge/docs.user.knowledge.accounting.md
new file mode 100644
index 0000000..e100923
--- /dev/null
+++ b/docs/user/knowledge/docs.user.knowledge.accounting.md
@@ -0,0 +1,109 @@
+---
+{
+	"_label": "Accounting Knowledge"
+}
+---
+
+Chart of Accounts represents a tree like representation of all accounting heads, used to represent company's financial information. There are two types of accounts: Balance Sheet and Profit and Loss Statement accounts. Balance Sheet consists of Assets and Liabilities accounts and Profit and Loss Statement accounts consists of Incomes and Expenses.
+
+**Assets:** Bank and Cash balances, outstanding amounts of customers and all other assets are recorded here.
+
+**Liabilities:** All the company's liabilities like shareholder's capital, outstanding amount to be paid to suppliers, taxes to be paid to concerned to authorities are recorded under this group.
+
+**Income:** Income from direct/indirect sales.
+
+**Expenses:** All the expenses to run the business, like salaries, purchases, rent etc. are recorded here.
+
+### Debit and Credit
+
+Each of these accounts are either "Debit" or "Credit" type. Assets, Expenses are "Debit" accounts and Liabilities, Incomes are "Credit" accounts.
+
+Accounting Entries
+
+The balance of account can be increased / decreased, depending on account type and transaction type.
+
+<table class="table table-bordered">
+    <thead>
+        <tr class="active">
+            <td style="text-align: center;">Account Type</td>
+            <td style="text-align: center;">Transaction Type</td>
+            <td style="text-align: center;">Effect on account balance</td>
+        </tr>
+    </thead>
+    <tbody>
+        <tr>
+            <td style="text-align: center;">Debit</td>
+            <td style="text-align: center;">Debit</td>
+            <td style="text-align: center;">Increases</td>
+        </tr>
+        <tr>
+            <td style="text-align: center;">Debit</td>
+            <td style="text-align: center;">Credit</td>
+            <td style="text-align: center;">Decreases</td>
+        </tr>
+        <tr>
+            <td style="text-align: center;">Credit</td>
+            <td style="text-align: center;">Credit</td>
+            <td style="text-align: center;">Increases</td>
+        </tr>
+        <tr>
+            <td style="text-align: center;">Credit</td>
+            <td style="text-align: center;">Debit</td>
+            <td style="text-align: center;">Decreases</td>
+        </tr>
+    </tbody>
+</table>
+
+### Double Entry
+
+This means that every accounting entry has two parts, one debit and one credit and must affect two separate accounts. If you add or deduct to one account, some other account somewhere else must also be affected. See the example below:
+
+1. Company sells a laptop worth 50000 to Customer A and delivers that with an invoice.
+
+As the company will receive a payment from customer, the customer is considered as an asset account. For booking income, company maintains an account called "Sales of Laptop". So, entries will be done in the following manner: 
+
+<table class="table table-bordered">
+    <thead>
+        <tr class="active">
+            <td style="text-align: center;">Account</td>
+            <td style="text-align: center;">Debit</td>
+            <td style="text-align: center;">Credit</td>
+        </tr>
+    </thead>
+    <tbody>
+        <tr>
+            <td style="text-align: center;">Customer A</td>
+            <td style="text-align: center;">50000</td>
+            <td style="text-align: center;"></td>
+        </tr>
+        <tr>
+            <td style="text-align: center;">Sales of Laptop</td>
+            <td style="text-align: center;"></td>
+            <td style="text-align: center;">50000</td>
+        </tr>
+    </tbody>
+</table>
+
+Customer A has made the payment, so customer balance should decreased based on the paid amount, which will increase "Cash" balance.
+
+<table class="table table-bordered">
+    <thead>
+        <tr class="active">
+            <td style="text-align: center;">Account</td>
+            <td style="text-align: center;">Debit</td>
+            <td style="text-align: center;">Credit</td>
+        </tr>
+    </thead>
+    <tbody>
+        <tr>
+            <td style="text-align: center;">Customer A</td>
+            <td style="text-align: center;"></td>
+            <td style="text-align: center;">50000</td>
+        </tr>
+        <tr>
+            <td style="text-align: center;">Cash</td>
+            <td style="text-align: center;">50000</td>
+            <td style="text-align: center;"></td>
+        </tr>
+    </tbody>
+</table>
\ No newline at end of file
diff --git a/docs/user/knowledge/docs.user.knowledge.fiscal_year.md b/docs/user/knowledge/docs.user.knowledge.fiscal_year.md
new file mode 100644
index 0000000..980872c
--- /dev/null
+++ b/docs/user/knowledge/docs.user.knowledge.fiscal_year.md
@@ -0,0 +1,10 @@
+---
+{
+	"_label": "Fiscal-Year"
+}
+---
+
+A fiscal year is also known as a financial year or a budget year. It is used for calculating financial statements in businesses and other organisations. The fiscal year may or may not be the same as a calendar year. For tax purposes, companies can choose to be calendar-year taxpayers or fiscal-year taxpayers.  In many jurisdictions, regulatory laws regarding accounting and taxation require such reports once per twelve months. However, it is not mandatory that the period should be  a calendar year (that is, 1 January to 31 December).
+
+A fiscal year usually starts at the beginning of a quarter, such as April 1, July 1 or October 1. However, most companies' fiscal year also coincides with the calendar year, which starts January 1. For the most part, it is simpler and easier that way. For some organizations, there are advantages in starting the fiscal year at a different time. For example, businesses that are seasonal might start their fiscal year on July 1 or October 1. A business that has most of its income in the fall and most of its expenses in the spring might also choose to start its fiscal year on October 1. That way, they know what their income will be for that year, and can adjust their expenses to maintain their desired profit margins.
+
diff --git a/docs/user/knowledge/docs.user.knowledge.md b/docs/user/knowledge/docs.user.knowledge.md
new file mode 100644
index 0000000..8e6b05f
--- /dev/null
+++ b/docs/user/knowledge/docs.user.knowledge.md
@@ -0,0 +1,10 @@
+---
+{
+	"_label": "Knowledge Library",
+	"_toc": [
+		"docs.user.knowledge.fiscal_year",
+		"docs.user.knowledge.accounting"		
+	]
+}
+---
+Knowledge Library contains definitions and explanations of various management concepts. This page is created for users who wish to elaborate their conceptual knowledge.
\ No newline at end of file
diff --git a/docs/user/mfg/docs.user.mfg.bom.md b/docs/user/mfg/docs.user.mfg.bom.md
index 7d1085d..9436f86 100644
--- a/docs/user/mfg/docs.user.mfg.bom.md
+++ b/docs/user/mfg/docs.user.mfg.bom.md
@@ -3,16 +3,26 @@
 	"_label": "Bill of Materials"
 }
 ---
-At the heart of the Manufacturing system is the **Bill of Materials** (BOM). The **BOM** is a list of all material (either bought or made) and operations that go into a finished product or sub-Item. In ERPNext, the component could have its own BOM hence forming a tree of Items with multiple levels.
+At the heart of the Manufacturing system is the **Bill of Materials** (BOM). The **BOM** is a list of all materials (either bought or made) and operations that go into a finished product or sub-Item. In ERPNext, the component could have its own BOM hence forming a tree of Items with multiple levels.
 
-To make accurate Purchase Requests, you must always maintain your correct BOMs. To make a new BOM:
+To make accurate Purchase Requests, you must always maintain correct BOMs. To make a new BOM:
 
 > Manufacturing > Bill of Materials > New BOM
 
+
+![Bill of Materials](img/bom.png)
+
+
+
 In the BOM form:
 
 - Select the Item for which you want to make the BOM.
 - Add the operations that you have to go through to make that particular Item in the “Operations” table. For each operation, you will be asked to enter a Workstation. You must create new Workstations as and when necessary. 
+
+![Bill of Materials with Operations](img/mfg-bom-3.png)
+
+
+
 - Add the list of Items you require for each operation, with its quantity. This Item could be a purchased Item or a sub-assembly with its own BOM. If the row Item is a manufactured Item and has multiple BOMs, select the appropriate BOM.  You can also define if a part of the Item goes into scrap.
 
 Workstations are defined only for product costing purposes not inventory. Inventory is tracked in Warehouses not Workstations.
diff --git a/docs/user/mfg/docs.user.mfg.md b/docs/user/mfg/docs.user.mfg.md
index 84bf08d..5522ec8 100644
--- a/docs/user/mfg/docs.user.mfg.md
+++ b/docs/user/mfg/docs.user.mfg.md
@@ -8,13 +8,13 @@
 	]
 }
 ---
-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).
+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 floors and planing your inventory by getting your material requirement via BOMs (also called Material Requirements Planning MRP).
 
 ### Types of Production Planning
 
 Broadly there are three types of Production Planning Systems
 
-- Make-to-Stock: In these systems, production is planned based on a forecast and then the Items are sold to distributors or customers. All fast moving consumer goods that are sold in retail shops like soaps, packaged water etc and electronics like phones etc are Made to Stock.
+- Make-to-Stock: In these systems, production is planned based on a forecast and the Items are then sold to distributors or customers. All fast moving consumer goods that are sold in retail shops like soaps, packaged water etc and electronics like phones etc are Made to Stock.
 - Make-to-Order: In these systems, manufacturing takes place after a firm order is placed by a Customer.
 - Engineer-to-Order:  In this case each sale is a separate Project and has to be designed and engineered to the requirements of the Customer. Common examples of this are any custom business like furniture, machine tools, speciality devices, metal fabrication etc.
 
@@ -26,7 +26,7 @@
 ￼
 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.
+ERPNext will help you track material movement by automatically creating Stock Entries from your Production Orders by building from Bill of Materials.
 
 
 ---
@@ -35,7 +35,7 @@
 
 The earliest ERP systems were made for manufacturing. The earliest adopters were automobile companies who had thousands of raw materials and sub-assemblies and found it very hard to keep track of requirements and plan purchases. They started using computers to build the material requirements from forecasts and Bill of Materials. 
 
-Later these systems were expanded to include Financial, Payroll, Order Processing and Purchasing and became the more generic Enterprise Resource Systems (ERP). More recently Customer Relationship Management (CRM) was added as a function and is now an integral part of ERP systems.
+Later these systems were expanded to include Finances, Payroll, Order Processing, and Purchasing and thus became the more generic Enterprise Resource Systems (ERP). More recently Customer Relationship Management (CRM) was added as a function and is now an integral part of ERP systems.
 
 These days the term ERP is used to describe systems that help manage any kind of organization like education institutes (Education ERP) or Hospitals (Hospital ERP) and so on. 
 
@@ -43,7 +43,7 @@
 
 ### Best Practice: Lean Manufacturing
 
-The state of art manufacturing philosophy (the rationale behind the planning processes) comes from Japanese auto major Toyota. At the time when American manufacturers depended on MRP systems to plan their manufacturing based on their sales forecasts, they turned the problem on its head and discovered a leaner way of planning their production. They realized that:
+The state of art manufacturing philosophy (the rationale behind the planning processes) comes from Japanese auto major Toyota. At the time when American manufacturers depended on MRP systems to plan their manufacturing based on their sales forecasts, they turned around the problem by discovering a leaner way of planning their production. They realized that:
 
 The biggest cause of wastage in manufacturing is variation (in product and quantity).
 
@@ -53,6 +53,4 @@
 
 They combined this system with neatly managed factories with well labeled racks.
 
-Like we discussed before, small manufacturing companies are usually make-to-order or engineer-to-order and can hardly afford to have a high level of standardization. But that should be the aim. Small manufacturing businesses should aim for repeatability by innovating processes so that there is a common platform for products.
-
-
+Small manufacturing companies are usually make-to-order or engineer-to-order and can hardly afford to have a high level of standardization. Thus small manufacturing businesses should aim for repeatability by innovating processes and creating a common platform for products.
\ No newline at end of file
diff --git a/docs/user/mfg/docs.user.mfg.planning.md b/docs/user/mfg/docs.user.mfg.planning.md
index 31de071..8d43ab8 100644
--- a/docs/user/mfg/docs.user.mfg.planning.md
+++ b/docs/user/mfg/docs.user.mfg.planning.md
@@ -14,6 +14,11 @@
 
 > Manufacturing > Production Planning Tool
 
+
+![Production Planning Tool](img/production-planning-tool.png)
+
+
+
 The Production Planning Tool is used in two stages:
 
 - Selection of Open Sales Orders for the period based on “Expected Delivery Date”.
diff --git a/docs/user/mfg/docs.user.mfg.production_order.md b/docs/user/mfg/docs.user.mfg.production_order.md
index 46e719c..5cbcf84 100644
--- a/docs/user/mfg/docs.user.mfg.production_order.md
+++ b/docs/user/mfg/docs.user.mfg.production_order.md
@@ -9,6 +9,11 @@
 
 > Manufacturing > Production Order > New Production Order
 
+
+![Production Order](img/production-order.png)
+
+
+
 - Select the Item to be produced (must have a Bill of Materials).
 - Select the BOM
 - Select Quantities
@@ -19,9 +24,13 @@
 
 Once you “Submit”, you will see two more buttons:
 
-1. Make Transfer: This will create a Stock Entry with all the Items required to complete this Production Order to be added to the WIP Warehouse. (this will add sub-Items with BOM as one Item or explode their children based on your setting above). 
-1. Back Flush: This will create a Stock Entry that will deduct all the sub-Items from the WIP Warehouse and add them to the Finished Goods Warehouse.
+![Production Order](img/production-order-2.png)
 
-When you Back Flush your Items back to the Finished Goods Warehouse, the “Produced Quantity” will be updated in the Production Order.
 
-> Tip: You can also partially complete a Production Order by updating the Finished Goods stock creating a Stock Entry and selecting “Back flush” as the type.
\ No newline at end of file
+1. Transfer Raw Material: This will create a Stock Entry with all the Items required to complete this Production Order to be added to the WIP Warehouse. (this will add sub-Items with BOM as one Item or explode their children based on your setting above). 
+1. Update Finished Goods: This will create a Stock Entry that will deduct all the sub-Items from the WIP Warehouse and add them to the Finished Goods Warehouse.
+
+> Tip: You can also partially complete a Production Order by updating the Finished Goods stock creating a Stock Entry.
+
+When you Update Finished Goods to the Finished Goods Warehouse, the “Produced Quantity” will be updated in the Production Order.
+
diff --git a/docs/user/selling/docs.user.selling.md b/docs/user/selling/docs.user.selling.md
index 5c0a5ae..9794556 100644
--- a/docs/user/selling/docs.user.selling.md
+++ b/docs/user/selling/docs.user.selling.md
@@ -17,6 +17,11 @@
 	]
 }
 ---
+
+![Selling](img/selling-image.png)
+
+
+
 Selling is the communication that happens with the customer prior to and during the sale. You might be managing all the communication yourself or you may have a small team of sales people to handle this. ERPNext helps you track the communication leading up to the sale, by keeping all your documents in an organized and searchable manner.
 
 ERPNext helps you track business **Opportunities** from **Leads** and **Customers**, send them **Quotations** and make confirmed **Sales Orders**.
diff --git a/docs/user/setup/docs.user.setup.cost_centers.md b/docs/user/setup/docs.user.setup.cost_centers.md
index e4841d8..3df26e1 100644
--- a/docs/user/setup/docs.user.setup.cost_centers.md
+++ b/docs/user/setup/docs.user.setup.cost_centers.md
@@ -23,12 +23,19 @@
 
 Thus 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.
 
+To understand chart of cost centers in detail visit [Accounting Knowledge](docs.user.knowledge.accounting.html)
+
+
 ### Chart of Cost Centers
 
 To setup your Chart of Cost Centers go to:
 
 > Accounts > Chart of Cost Centers
 
+
+![Chart of Cost Center](img/chart-of-cost-centers.png)
+
+
 Cost centers help you in one more activity, budgeting.
 
 ### Budgeting
diff --git a/docs/user/setup/docs.user.setup.first.md b/docs/user/setup/docs.user.setup.first.md
index 5e1c5d8..4784a69 100644
--- a/docs/user/setup/docs.user.setup.first.md
+++ b/docs/user/setup/docs.user.setup.first.md
@@ -11,7 +11,7 @@
 
 Some definitions:
 
-- Fiscal Year: This is your financial year, the fiscal year usually starts on 1st Jan or 1st March for most regions. If you are not sure, consult an accountant.
+- [Fiscal Year](docs.user.knowledge.fiscal_year.html): This is your financial year, the fiscal year usually starts on 1st Jan or 1st March for most regions. If you are not sure, consult an accountant.
 - Abbreviation: In a multi-company setup, the abbreviation is appended to each account, so keep it small (2-4) characters and all caps.
 
 This will also set the default **Currency** and time zone for your account. Once you complete this, your first **Company** and **Chart of Accounts** will be created.
diff --git a/docs/user/setup/docs.user.setup.md b/docs/user/setup/docs.user.setup.md
index bd5c499..fa9680a 100644
--- a/docs/user/setup/docs.user.setup.md
+++ b/docs/user/setup/docs.user.setup.md
@@ -25,6 +25,7 @@
 	]
 }
 ---
+
 Setting up an ERP system is like starting your business all over again, although in the virtual world. Thankfully it is not as hard as the real business and you get to do a trial too!
 
 Implementation requires the implementer to take a step back and set aside some time to do this right. This is usually not a couple-of-hours, after-work kind of a project.
diff --git a/docs/user/setup/docs.user.setup.opening.md b/docs/user/setup/docs.user.setup.opening.md
index dcb2320..4c30306 100644
--- a/docs/user/setup/docs.user.setup.opening.md
+++ b/docs/user/setup/docs.user.setup.opening.md
@@ -36,8 +36,26 @@
 > Setup > Opening Accounts and Stock > Opening Accounting Entries.
 
 
+
+#### Step 1: Select Opening Entry in the Voucher Type section.
+
 ![Opening Entry](img/opening-entry.png)
 
+<br>
+
+#### Step 2: Complete Journal Entries on the Debit and Credit side. 
+
+
+![Opening Entry](img/opening-entry-1.png)
+
+<br>
+
+
+#### Step 2: Select Yes in the "Is Opening " record under More Info.
+
+
+![Opening Entry](img/opening-entry-2.png)
+
 
 
 You can make two Opening Journal Vouchers:
@@ -45,6 +63,13 @@
 - For all assets (excluding Accounts Receivables): This entry will contain all your assets except the amounts you are expecting from your Customers against outstanding Sales Invoices. You will have to update your receivables by making an individual entry for each Invoice (this is because, the system will help you track the invoices which are yet to be paid). Since all the entries in this voucher will be of type “Debit”, you can credit the sum of all these debits against the “Temp Opening Liabilities” account.
 - For all liabilities: Similarly you need to pass a Journal Voucher for your Opening Liabilities (except for the bills you have to pay). This can be made against the “Temp Opening Assets” account.
 
+After completing the accounting entries, the trial balance report will look like the one given below:
+
+
+![Trial Balance](img/trial-balance-1.png)
+
+
+
 #### Outstanding Invoices
 
 After your Opening Journal Vouchers are made, you will need to enter each Sales Invoice and Purchase Invoice that is yet to be paid. 
@@ -57,21 +82,3 @@
 
 Once all your invoices are entered, your “Temp Opening Assets” will be same as “Temp Opening Liabilities” and you can pass another “Is Opening” type of Journal Voucher and cancel them to zero!
 
----
-
-## Opening Stock
-
-You can upload your opening stock in the system using Stock Reconciliation. Stock Reconciliation will update your stock for a given Item on a given date for a given Warehouse to the given quantity.
-
-Stock Reconciliation will make a “difference entry” (the difference between the system stock and the actual stock in your file) for the Item.
-
-Tip: Stock Reconciliation can also be used to update the “value” of an Item.
-
-To make a Stock Reconciliation, go to:
-
-> Stock > Stock Reconciliation > New Stock Reconciliation
-
-and follow the steps mentioned on the page.
-
-
-![Stock Reconciliation](img/stock-reconciliation1.png)
diff --git a/docs/user/setup/docs.user.setup.taxes.md b/docs/user/setup/docs.user.setup.taxes.md
index 52c82bc..91ed591 100644
--- a/docs/user/setup/docs.user.setup.taxes.md
+++ b/docs/user/setup/docs.user.setup.taxes.md
@@ -7,7 +7,14 @@
 
 ### Tax Accounts
 
-For Tax Accounts that you want to use in the tax templates, you must mention them as type “Tax” in your Chart of Accounts.
+For Tax Accounts that you want to use in the tax templates, you must mention them as type “Tax” in your Chart of Accounts. Some Item-tax features are given below :
+
+- **Discount**: The maximum Discount that can be applied on an Item can be fixed in the Item master. Read [Discount](docs.user.selling.discount.html)
+- **Inclusive and Exclusive Tax**: ERPNext allows you to enter Item rates which are tax inclusive.
+- **Flat Discount**: This feature will be added soon.
+- **Exception to the rule**: Item tax settings are required only if a particular Item has a different tax rate than the rate defined in the standard tax Account
+
+
 
 ## Sales Taxes and Charges Master
 
diff --git a/docs/user/stock/docs.user.stock.item.md b/docs/user/stock/docs.user.stock.item.md
index c5c58bd..6aa3587 100644
--- a/docs/user/stock/docs.user.stock.item.md
+++ b/docs/user/stock/docs.user.stock.item.md
@@ -29,7 +29,7 @@
 
 ### Item Pricing
 
-Item Price and Price Lists: ERPNext lets you maintain multiple selling prices for an Item using Price Lists. 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. A Price List is formed when you create different Item Prices. To import Item Price visit “Import Item Price”.
+Item Price and Price Lists: ERPNext lets you maintain multiple selling prices for an Item using Price Lists. 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. A Price List is formed when you create different Item Prices. To import Item Price see [Importing Data](docs.user.data_import.md).
 
 ## Inventory : Warehouse and Stock Setting
 
@@ -56,10 +56,29 @@
 
 ### Item Tax
 
-These settings are required only if a particular Item has a different tax rate than the rate defined in the standard tax Account. For example,  If you have a tax Account, “VAT 10%” and this particular Item is exempted from tax, then you select “VAT 10%” in the first column, and set “0” as the tax rate in the second column.
+These settings are required only if a particular Item has a different tax rate than the rate defined in the standard tax Account. For example,  If you have a tax Account, “VAT 10%” and this particular Item is exempted from tax, then you select “VAT 10%” in the first column, and set “0” as the tax rate in the second column. 
+
+Go to [Setting Up Taxes](docs.user.setup.taxes.html) to understand this topic in detail.
 
 ### Inspection
 
 Inspection Required: If an incoming inspection (at the time of delivery from the Supplier) is mandatory for this Item, mention “Inspection Required” as “Yes”. The system will ensure that a Quality Inspection will be prepared and approved before a Purchase 	Receipt is submitted.
 
 Inspection Criteria: If a Quality Inspection is prepared for this Item, then this template of criteria will automatically be updated in the Quality Inspection table of the Quality Inspection. Examples of Criteria are: Weight, Length, Finish etc.
+
+### Purchase Details
+
+**Lead time days:** Lead time days are the number of days required for the Item to reach the warehouse.
+
+
+**Default Expense Account:** It is the account in which cost of the Item will be debited.
+
+**Default Cost Centre:** It is used for tracking expense for this Item.
+
+### Sales Details
+
+**Default Income Account:**  Income account selected here will be fetched automatically in sales invoice for this item.
+
+**Cost Centre:** Cost center selected here will be fetched automatically in sales invoice for this item.
+
+Visit [Manufacturing](docs.user.mfg.html) and [Website](docs.user.website.html) to understand these topics in detail.
diff --git a/docs/user/support/docs.user.support.customer_issue.md b/docs/user/support/docs.user.support.customer_issue.md
index 92cb29a..4c5afd1 100644
--- a/docs/user/support/docs.user.support.customer_issue.md
+++ b/docs/user/support/docs.user.support.customer_issue.md
@@ -3,7 +3,7 @@
 	"_label": "Customer Issue"
 }
 ---
-If you are selling **Items** under warranty or if you have sold and extended service contract Annual Maintenance Contract (AMC), your **Customer** may call you about an issue or a bread-down and give you the Serial No of this Item.
+If you are selling **Items** under warranty or if you have sold and extended service contract like the Annual Maintenance Contract (AMC), your **Customer** may call you about an issue or a break-down and give you the Serial No of this Item.
 
 To record this, you can create a new **Customer Issue** and add the **Customer** and **Item** / **Serial No**. The system will then automatically fetch the Serial No’s details and indicate whether this is under warranty or AMC.
 
@@ -13,5 +13,10 @@
 
 > Support > Customer Issue > New Customer Issue
 
+
+![Customer Issue](img/customer-issue.png)
+
+
+
 If a Customer visit is required to address the issue, you can create a new Maintenance Visit record from this.
 
diff --git a/docs/user/support/docs.user.support.maintenance_schedule.md b/docs/user/support/docs.user.support.maintenance_schedule.md
index 82bf8f9..a2bf5ea 100644
--- a/docs/user/support/docs.user.support.maintenance_schedule.md
+++ b/docs/user/support/docs.user.support.maintenance_schedule.md
@@ -11,6 +11,26 @@
 
 > Support > Maintenance Schedule > New Maintenance Schedule
 
+#### Step 1: Enter Customer Details
+
+
+![Maintenance Schedule](img/maintenance-schedule-1.png)
+
+
+
+<br>
+
+
+
+#### Step 2: Fill Item and Maintenance Details
+
+
+
+![Maintenance Schedule](img/maintenance-schedule-2.png)
+
+
+<br>
+
 In the Maintenance Schedule, there are two sections:
 
 In the first section, you select the Items for which you want to generate the schedule and set how frequently you want to plan a visit or a maintenance. These can be optionally fetched from a Sales Order. After selecting the Items, “Save” the record.
diff --git a/docs/user/support/docs.user.support.maintenance_visit.md b/docs/user/support/docs.user.support.maintenance_visit.md
index dc115e2..210277a 100644
--- a/docs/user/support/docs.user.support.maintenance_visit.md
+++ b/docs/user/support/docs.user.support.maintenance_visit.md
@@ -7,6 +7,10 @@
 
 > Support > Maintenance Visit > New Maintenance Visit
 
+
+![Maintenance Visit](img/maintenance-visit.png)
+
+
 The Maintenance Visit contains information about the:
 
 - Customer.
diff --git a/docs/user/support/docs.user.support.md b/docs/user/support/docs.user.support.md
index 775c030..acd693f 100644
--- a/docs/user/support/docs.user.support.md
+++ b/docs/user/support/docs.user.support.md
@@ -5,10 +5,11 @@
 		"docs.user.support.support_ticket",
 		"docs.user.support.customer_issue",
 		"docs.user.support.maintenance_visit",
-		"docs.user.support.maintenance_schedule"
+		"docs.user.support.maintenance_schedule",
+		"docs.user.support.newsletter"
 	]
 }
 ---
-Great customer support and maintenance is at the heart of any successful small business and ERPNext gives you the tools to track all incoming requests and issues from your customers so that you can respond quickly. Your database of incoming queries will also help you track where are the biggest opportunities for improvements.
+Great customer support and maintenance is at the heart of any successful small business.ERPNext gives you the tools to track all incoming requests and issues from your customers so that you can respond quickly. Your database of incoming queries will also help you track where the biggest opportunities are for improvements.
 
-In this module, you can track incoming queries from your email using Support Ticket, keep track on Customer Issues raised by Customers on specific Serial No and respond to them based on their warranty and other information, make Maintenance Schedules for Serial Nos and keep a record of all Maintenance Visits made to your Customers.
+In this module, you can track incoming queries from your email using Support Ticket. You can keep track on Customer Issues raised by Customers on specific Serial No and respond to them based on their warranty and other information. You can also make Maintenance Schedules for Serial Nos and keep a record of all Maintenance Visits made to your Customers.
diff --git a/docs/user/support/docs.user.support.newsletter.md b/docs/user/support/docs.user.support.newsletter.md
new file mode 100644
index 0000000..443a6e5
--- /dev/null
+++ b/docs/user/support/docs.user.support.newsletter.md
@@ -0,0 +1,14 @@
+---
+{
+	"_label": "Newsletter"
+}
+---
+
+A newsletter is a short written report that tells about the recent activities of an organization. It is generally sent to members of the organization, potential clients customers or potential leads.
+
+In ERPNext, you can use this UI to send any type of communication to a large number of audience. The process of sending bulk email to a target audience is very simple and easy. 
+
+Select  the list that you want to send the email to. Fill in your content in the message box, and send your newsletter.If you wish to test your email, to see how it looks to the recepient, you can use the test function.Save the document before testing. A test email will be sent to your email id. You can send the email to all the intended receipients by clicking on the send button.
+
+
+![Newsletter](img/newsletter.png)
diff --git a/docs/user/support/docs.user.support.support_ticket.md b/docs/user/support/docs.user.support.support_ticket.md
index b4a496b..c750462 100644
--- a/docs/user/support/docs.user.support.support_ticket.md
+++ b/docs/user/support/docs.user.support.support_ticket.md
@@ -3,15 +3,26 @@
 	"_label": "Support Ticket"
 }
 ---
-Support Ticket is an incoming query from your Customer, usually via email of from the “Contact” section of your website. (To fully integrate the Support Ticket to email, see the Email Settings section). 
+Support Ticket is an incoming query from your Customer, usually via email or from the “Contact” section of your website. (To fully integrate the Support Ticket to email, see the Email Settings section). 
 
 > Tip: A dedicated support email id is a good way to integrate incoming queries via email. For example, you can send support queries to ERPNext at support@erpnext.com and it will automatically create a Support Ticket in the Web Notes system.
 
+<br>
+
+
+> Support > Support Ticket > New Support Ticket
+
+
+
+![Support Ticket](img/support-ticket.png)
+
+
+
 #### Discussion Thread
 
 When a new email is fetched from your mailbox, a new Support Ticket record is created and an automatic reply is sent to the sender indicating the Support Ticket Number. The sender can send additional information to this email. All subsequent emails containing this Support Ticket number in the subject will be added to this Support Ticket thread. The sender can also add attachments to the email.
 
-Support Ticket maintains all the emails sent back and forth against this issue in the system so that you can track what transpired between the sender and the person responding. 
+Support Ticket maintains all the emails which are sent back and forth against this issue in the system so that you can track what transpired between the sender and the person responding. 
 
 #### Status
 
@@ -19,7 +30,7 @@
 
 #### Closing
 
-You can either “Close” the Support Ticket manually by clicking on “Close Ticket” in the toolbar or if its status is “Waiting For Reply” and the sender did not reply in 7 days, then the Support Ticket closes automatically.
+You can either “Close” the Support Ticket manually by clicking on “Close Ticket” in the toolbar or if its status is “Waiting For Reply” . If the sender does not reply in 7 days, then the Support Ticket closes automatically.
 
 #### Allocation
 
diff --git a/docs/user/tools/docs.user.tools.assignment.md b/docs/user/tools/docs.user.tools.assignment.md
new file mode 100644
index 0000000..8ec04ea
--- /dev/null
+++ b/docs/user/tools/docs.user.tools.assignment.md
@@ -0,0 +1,22 @@
+---
+{
+	"_label": "Assignment"
+}
+---
+
+You can assign any transaction to any user by clicking on the “Assign” button on the right hand column and adding a user.
+
+#### Step 1: Click on the Assign To Button
+
+![Assigned To](img/assigned-to.png)
+
+
+
+#### Step 2: Add the User and other details￼
+
+
+![Assign User](img/assignment.png)
+
+
+This transaction will appear in the To-do list of the user in “My List” section. It will also appear 
+in the “Assigned by me” section of the user, who has assigned this activity.
diff --git a/docs/user/tools/docs.user.tools.form_tools.md b/docs/user/tools/docs.user.tools.form_tools.md
index 65943d7..1c88f5f 100644
--- a/docs/user/tools/docs.user.tools.form_tools.md
+++ b/docs/user/tools/docs.user.tools.form_tools.md
@@ -3,9 +3,15 @@
 	"_label": "Collaborating around Forms"
 }
 ---
-### Email
+### Assigned to
 
-You can email any transaction from the system by clicking on the “Email” button in the right sidebar. A log of all your sent emails will be maintained in Communication.
+You can email any transaction from the system by clicking on the “Assigned to” button in the right sidebar. A log of all your sent emails will be maintained in Communication.
+
+
+
+![Forms](img/forms.png)
+
+
 
 ### Comments
 
@@ -13,4 +19,5 @@
 
 ### Tags
 
-Like Assignments and Comments, you can also add your own tags to each type of transactions. These tags can help you search a document and also classify it. ERPNext will also show you all the important tags in the document list.
+[Tags](docs.user.tools.tags.html)
+
diff --git a/docs/user/tools/docs.user.tools.md b/docs/user/tools/docs.user.tools.md
index 891b756..68abb96 100644
--- a/docs/user/tools/docs.user.tools.md
+++ b/docs/user/tools/docs.user.tools.md
@@ -5,7 +5,10 @@
 		"docs.user.tools.todo",
 		"docs.user.tools.form_tools",
 		"docs.user.tools.messages",
-		"docs.user.tools.notes"
+		"docs.user.tools.notes",
+		"docs.user.tools.calendar",
+		"docs.user.tools.assignment",
+		"docs.user.tools.tags"
 	]
 }
 ---
diff --git a/docs/user/tools/docs.user.tools.notes.md b/docs/user/tools/docs.user.tools.notes.md
index fcb8fce..8cad69a 100644
--- a/docs/user/tools/docs.user.tools.notes.md
+++ b/docs/user/tools/docs.user.tools.notes.md
@@ -2,4 +2,21 @@
 {
 	"_label": "Notes"
 }
----
\ No newline at end of file
+---
+
+You can store your long notes under this section. It can contain your partner lists, frequently used passwords, terms and conditions , or any other document which needs to be shared. 
+
+#### Step 1: Enter Title and Content
+
+
+![Notes](img/notes.png)
+
+<br>
+
+
+#### Step 2: Set Permissions to select Users
+
+
+
+![Notes](img/notes-1.png)
+
diff --git a/docs/user/tools/docs.user.tools.tags.md b/docs/user/tools/docs.user.tools.tags.md
new file mode 100644
index 0000000..34e7f27
--- /dev/null
+++ b/docs/user/tools/docs.user.tools.tags.md
@@ -0,0 +1,10 @@
+---
+{
+	"_label": "Tags"
+}
+---
+
+Like Assignments and Comments, you can also add your own tags to each type of transactions. These tags can help you search a document and also classify it. ERPNext will also show you all the important tags in the document list.
+
+
+![Tags](img/tags.png)
diff --git a/docs/user/tools/docs.user.tools.todo.md b/docs/user/tools/docs.user.tools.todo.md
index 131af69..46be2e2 100644
--- a/docs/user/tools/docs.user.tools.todo.md
+++ b/docs/user/tools/docs.user.tools.todo.md
@@ -1,23 +1,12 @@
 ---
 {
-	"_label": "Assignment and To Do"
+	"_label": "To Do"
 }
 ---
-### Assignment
 
-You can assign any transaction to any user by clicking on the “Assign” button on the right hand column and adding a user.
-
-Step 1: Click on the Assign To Button
-
-Step 2: Add the User and other details￼
-
-This transaction will appear in:
-
-The To-do list of the user whom this is assigned to in “My List” section
-In the “Assigned by me” section of the user who has assigned this activity.
-
-### To Do
 
 To Do is a simple tool where all the activities assigned to you and assigned by you are listed. You can also add your own to-do items in the list.
 
 
+![To Do](img/to-do.png)
+
diff --git a/docs/user/website/docs.user.website.blog.md b/docs/user/website/docs.user.website.blog.md
index 4e2a782..ec035a0 100644
--- a/docs/user/website/docs.user.website.blog.md
+++ b/docs/user/website/docs.user.website.blog.md
@@ -11,6 +11,10 @@
 
 > Website > Blog > New Blog
 
+
+![Blog](img/blog.png)
+
+
 You can format the blog using the same Markdown format
 
 You can access your blog by going to the page “blog.html”
diff --git a/docs/user/website/docs.user.website.md b/docs/user/website/docs.user.website.md
index e3fa449..b628e71 100644
--- a/docs/user/website/docs.user.website.md
+++ b/docs/user/website/docs.user.website.md
@@ -11,8 +11,8 @@
 ---
 Websites are a core component of any business and having a good website usually means:
 
-- Lot of money.
-- Hard to update.
+- Invest lot of money.
+- Difficult to update.
 - Not interactive.
 
 Unless you are a web designer yourself. 
@@ -29,4 +29,4 @@
 
 Though not necessary, to make a good website, you might have to know a bit of HTML / CSS or hire the services of a professional. The good part is that once this is setup, you can add and edit content, blogs and products directly from your ERP.
 
-> The ERPNext website (www.erpnext.com) is generated from the Website Module! In the world of startups, its called eating-your-own-dog-food!
\ No newline at end of file
+> The ERPNext website (www.erpnext.com) is generated from the Website Module! In the world of startups, it's called eating-your-own-dog-food!
\ No newline at end of file
diff --git a/docs/user/website/docs.user.website.setup.md b/docs/user/website/docs.user.website.setup.md
index 23df928..3249637 100644
--- a/docs/user/website/docs.user.website.setup.md
+++ b/docs/user/website/docs.user.website.setup.md
@@ -29,6 +29,12 @@
 
 > Website > Website Settings
 
+
+![Website Setting](img/website-settings.png)
+
+<br>
+
+
 #### Top Menu
 
 Add each top menu item on a new link.
@@ -45,4 +51,4 @@
 
 ##### What is Website Analytics?
 
-Website analytics help you track each visitor on your website. The analytics will tell you from which country, at what time, and what pages the visitor viewed. This will help you understand who your visitors are and what are they looking for. There are many analytics engines available and the most popular and Free service is Google Analytics. We definitely recommend using one of them to gain insight into your website visitors.
\ No newline at end of file
+Website analytics helps you to track each visitor on your website. The analytics will tell you from which country, at what time, and which pages the visitor viewed. This will help you understand who your visitors are and what they are looking for. There are many analytics engines available and the most popular and Free service is Google Analytics. We definitely recommend using one of them to gain insight into your website visitors.
\ No newline at end of file
diff --git a/docs/user/website/docs.user.website.web_page.md b/docs/user/website/docs.user.website.web_page.md
index e856775..a8f0e13 100644
--- a/docs/user/website/docs.user.website.web_page.md
+++ b/docs/user/website/docs.user.website.web_page.md
@@ -7,6 +7,10 @@
 
 > Website > Web Page > New Web Page
 
+![Web Page](img/webpage.png)
+
+
+
 #### Title
 
 The first thing to set is the title of your page. The title has the maximum weight for search engines so choose a title that reflects the keywords that you are targeting for your audience.
diff --git a/patches/may_2013/p03_update_support_ticket.py b/patches/may_2013/p03_update_support_ticket.py
index 005c9a3..d8e37236 100644
--- a/patches/may_2013/p03_update_support_ticket.py
+++ b/patches/may_2013/p03_update_support_ticket.py
@@ -11,4 +11,4 @@
 		tic = webnotes.get_obj("Support Ticket", d.name)
 		tic.set_lead_contact(d.raised_by)
 		webnotes.conn.sql("""update `tabSupport Ticket` set lead = %s, contact = %s, company = %s 
-			where name = %s""", (tic.doc.lead, tic.doc.contact, tic.doc.company, d.name))
\ No newline at end of file
+			where name = %s""", (tic.doc.lead, tic.doc.contact, tic.doc.company, d.name
\ No newline at end of file
