diff --git a/docs/user/customize/docs.user.customize.custom_form.md b/docs/user/customize/docs.user.customize.custom_form.md
index b64d2ff..6b37bd1 100644
--- a/docs/user/customize/docs.user.customize.custom_form.md
+++ b/docs/user/customize/docs.user.customize.custom_form.md
@@ -10,7 +10,7 @@
 > Setup > Customize ERPNext > Customize Forms
 
 
-![Customize Forms](img/customize-form.png)
+![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:
@@ -24,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.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 7ce156e..4576304 100644
--- a/docs/user/docs.user.md
+++ b/docs/user/docs.user.md
@@ -132,6 +132,9 @@
 	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)
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/support/docs.user.support.support_ticket.md b/docs/user/support/docs.user.support.support_ticket.md
index 8232514..c750462 100644
--- a/docs/user/support/docs.user.support.support_ticket.md
+++ b/docs/user/support/docs.user.support.support_ticket.md
@@ -7,6 +7,17 @@
 
 > 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.
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
