diff --git a/erpnext/docs/assets/img/customize/custom-field-1.gif b/erpnext/docs/assets/img/customize/custom-field-1.gif
new file mode 100644
index 0000000..3e8077c
--- /dev/null
+++ b/erpnext/docs/assets/img/customize/custom-field-1.gif
Binary files differ
diff --git a/erpnext/docs/assets/img/customize/custom-field-2.gif b/erpnext/docs/assets/img/customize/custom-field-2.gif
new file mode 100644
index 0000000..ef07ed1
--- /dev/null
+++ b/erpnext/docs/assets/img/customize/custom-field-2.gif
Binary files differ
diff --git a/erpnext/docs/assets/img/customize/custom-field-3.png b/erpnext/docs/assets/img/customize/custom-field-3.png
new file mode 100644
index 0000000..b84b35a
--- /dev/null
+++ b/erpnext/docs/assets/img/customize/custom-field-3.png
Binary files differ
diff --git a/erpnext/docs/assets/img/customize/custom-field-4.png b/erpnext/docs/assets/img/customize/custom-field-4.png
new file mode 100644
index 0000000..c0c763d
--- /dev/null
+++ b/erpnext/docs/assets/img/customize/custom-field-4.png
Binary files differ
diff --git a/erpnext/docs/assets/img/customize/custom-field-5.png b/erpnext/docs/assets/img/customize/custom-field-5.png
new file mode 100644
index 0000000..99303ae
--- /dev/null
+++ b/erpnext/docs/assets/img/customize/custom-field-5.png
Binary files differ
diff --git a/erpnext/docs/assets/img/customize/custom-field-6.png b/erpnext/docs/assets/img/customize/custom-field-6.png
new file mode 100644
index 0000000..df14f07
--- /dev/null
+++ b/erpnext/docs/assets/img/customize/custom-field-6.png
Binary files differ
diff --git a/erpnext/docs/assets/img/customize/custom-script-1.png b/erpnext/docs/assets/img/customize/custom-script-1.png
new file mode 100644
index 0000000..498ecc2
--- /dev/null
+++ b/erpnext/docs/assets/img/customize/custom-script-1.png
Binary files differ
diff --git a/erpnext/docs/assets/img/customize/customize-form-edit-property.gif b/erpnext/docs/assets/img/customize/customize-form-edit-property.gif
new file mode 100644
index 0000000..edea72c
--- /dev/null
+++ b/erpnext/docs/assets/img/customize/customize-form-edit-property.gif
Binary files differ
diff --git a/erpnext/docs/assets/img/customize/customize-form-from-list-view.gif b/erpnext/docs/assets/img/customize/customize-form-from-list-view.gif
new file mode 100644
index 0000000..1f18b53
--- /dev/null
+++ b/erpnext/docs/assets/img/customize/customize-form-from-list-view.gif
Binary files differ
diff --git a/erpnext/docs/assets/img/customize/customize-form-select-doctype.png b/erpnext/docs/assets/img/customize/customize-form-select-doctype.png
new file mode 100644
index 0000000..0bdaaa5
--- /dev/null
+++ b/erpnext/docs/assets/img/customize/customize-form-select-doctype.png
Binary files differ
diff --git a/erpnext/docs/assets/img/customize/feature-setup.png b/erpnext/docs/assets/img/customize/feature-setup.png
new file mode 100644
index 0000000..200d138
--- /dev/null
+++ b/erpnext/docs/assets/img/customize/feature-setup.png
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/customize/print-format.png b/erpnext/docs/assets/img/customize/print-format.png
similarity index 100%
rename from erpnext/docs/assets/old_images/erpnext/customize/print-format.png
rename to erpnext/docs/assets/img/customize/print-format.png
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/customize/print-settings.png b/erpnext/docs/assets/img/customize/print-settings.png
similarity index 100%
rename from erpnext/docs/assets/old_images/erpnext/customize/print-settings.png
rename to erpnext/docs/assets/img/customize/print-settings.png
Binary files differ
diff --git a/erpnext/docs/assets/img/customize/show-hide-modules.png b/erpnext/docs/assets/img/customize/show-hide-modules.png
new file mode 100644
index 0000000..19b24be
--- /dev/null
+++ b/erpnext/docs/assets/img/customize/show-hide-modules.png
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/custom-field-label.png b/erpnext/docs/assets/old_images/erpnext/custom-field-label.png
deleted file mode 100644
index 948b705..0000000
--- a/erpnext/docs/assets/old_images/erpnext/custom-field-label.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/custom-field-link.png b/erpnext/docs/assets/old_images/erpnext/custom-field-link.png
deleted file mode 100644
index d2ee056..0000000
--- a/erpnext/docs/assets/old_images/erpnext/custom-field-link.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/custom-field-option.png b/erpnext/docs/assets/old_images/erpnext/custom-field-option.png
deleted file mode 100644
index 712cf27..0000000
--- a/erpnext/docs/assets/old_images/erpnext/custom-field-option.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/custom-field-properties.png b/erpnext/docs/assets/old_images/erpnext/custom-field-properties.png
deleted file mode 100644
index 0c0554d..0000000
--- a/erpnext/docs/assets/old_images/erpnext/custom-field-properties.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/custom-field-type.png b/erpnext/docs/assets/old_images/erpnext/custom-field-type.png
deleted file mode 100644
index f642b1c..0000000
--- a/erpnext/docs/assets/old_images/erpnext/custom-field-type.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/custom-script.png b/erpnext/docs/assets/old_images/erpnext/custom-script.png
deleted file mode 100644
index f8612b0..0000000
--- a/erpnext/docs/assets/old_images/erpnext/custom-script.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/customize-form-document.png b/erpnext/docs/assets/old_images/erpnext/customize-form-document.png
deleted file mode 100644
index e6773d5..0000000
--- a/erpnext/docs/assets/old_images/erpnext/customize-form-document.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/customize-form-list-view.png b/erpnext/docs/assets/old_images/erpnext/customize-form-list-view.png
deleted file mode 100644
index fd42fd5..0000000
--- a/erpnext/docs/assets/old_images/erpnext/customize-form-list-view.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/customize-form-mandatory.png b/erpnext/docs/assets/old_images/erpnext/customize-form-mandatory.png
deleted file mode 100644
index 1da1811..0000000
--- a/erpnext/docs/assets/old_images/erpnext/customize-form-mandatory.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/customize-form-update.png b/erpnext/docs/assets/old_images/erpnext/customize-form-update.png
deleted file mode 100644
index 64431a5..0000000
--- a/erpnext/docs/assets/old_images/erpnext/customize-form-update.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/hide-features.png b/erpnext/docs/assets/old_images/erpnext/hide-features.png
deleted file mode 100644
index 3f86470..0000000
--- a/erpnext/docs/assets/old_images/erpnext/hide-features.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/old_images/erpnext/hide-module.png b/erpnext/docs/assets/old_images/erpnext/hide-module.png
deleted file mode 100644
index f3f26a4..0000000
--- a/erpnext/docs/assets/old_images/erpnext/hide-module.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/user/manual/en/buying/articles/purchasing-in-different-unit.md b/erpnext/docs/user/manual/en/buying/articles/purchasing-in-different-unit.md
index e95f0e3..81b1aab 100644
--- a/erpnext/docs/user/manual/en/buying/articles/purchasing-in-different-unit.md
+++ b/erpnext/docs/user/manual/en/buying/articles/purchasing-in-different-unit.md
@@ -1,6 +1,6 @@
 #Purchasing in Different Unit (UoM)
 
-Each item has stock unit of measument (UoM) associated to it. For example UoM of pen is nos. and sand stocked kgs. But item could be purchased in different UoM, like 1 set/box of pen, or one truck of sand. In ERPNex, you can create purchase transaction for an item having different UoM than item's stock UoM.
+Each item has stock unit of measument (UoM) associated to it. For example UoM of pen could be numbers (Nos) and sand could be stocked kgs. However, when we place an order with Supplier, UoM for an item could change. Like we can order 1 set/box of Pen, or one truck of sand to our Supplier. When creating purchase transacton, you can change Purchase UoM for an item.
 
 ### Scenario:
 
@@ -19,7 +19,7 @@
 
 #### Step 2: Update UoM Conversion Factors
 
-In one Box, if you get 20 Nos. of Pen, UoM Conversion Factor would be 20. 
+In one Box, if you get 20 Nos. of Pen, UoM Conversion Factor would be 20.
 
 <img alt="Item Conversion Factor" class="screenshot" src="{{docs_base_url}}/assets/img/articles/po-conversion-factor.png">
 
diff --git a/erpnext/docs/user/manual/en/buying/setup/buying-settings.md b/erpnext/docs/user/manual/en/buying/setup/buying-settings.md
index d4c390b..3d5dbb9 100644
--- a/erpnext/docs/user/manual/en/buying/setup/buying-settings.md
+++ b/erpnext/docs/user/manual/en/buying/setup/buying-settings.md
@@ -12,7 +12,7 @@
 
 You can define or select the Naming Series pattern from:
 
-> Setup > Settings > Naming Series
+`Setup > Data > Naming Series`
 
 [Click here to know more about defining a Naming Series.]({{docs_base_url}}/user/manual/en/setting-up/settings/naming-series.html)
 
diff --git a/erpnext/docs/user/manual/en/buying/supplier.md b/erpnext/docs/user/manual/en/buying/supplier.md
index 455e060..45ec6b1 100644
--- a/erpnext/docs/user/manual/en/buying/supplier.md
+++ b/erpnext/docs/user/manual/en/buying/supplier.md
@@ -1,37 +1,35 @@
-Suppliers are companies or individuals who provide you with products or
-services. They are treated in exactly the same manner as Customers in ERPNext.
+Suppliers are companies or individuals who provide you with products or services.
 
-You can create a new Supplier via:
+You can create a new Supplier from:
 
-> Buying > Documents > Supplier > New Supplier
+`Buying > Documents > Supplier > New Supplier`
 
 <img class="screenshot" alt="Supplier Master" src="{{docs_base_url}}/assets/img/buying/supplier-master.png">
 
 ### Contacts and Addresses
 
-Contacts and Addresses in ERPNext are stored separately so that you can attach
-multiple Contacts or Addresses to Customers and Suppliers. To add a Contact or
-Address go to Buying and click on “New Contact” or “New Address”.
+Contacts and Addresses in ERPNext are stored separately so that you can create multiple Contacts and Addresses for a Suppliers. Once Supplier is saved, you will find option to create Contact and Address for that Supplier.
 
-> Tip: When you select a Supplier 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!
+<img class="screenshot" alt="Supplier Master" src="{{docs_base_url}}/assets/img/buying/supplier-new-address-contact.png">
+
+> Tip: When you select a Supplier in any transaction, Contact for which "Is Primary" field id checked, it will auto-fetch with the Supplier details.
 
 ### Integration with Accounts
 
-In ERPNext, there is a separate Account record for each Supplier, of Each
-company.
+For all the Supplier, "Creditor" account is set as default payable Account. When Purchase Invoice is created, payable towards the supplier is booked against "Creditors" account.
 
-When you create a new Supplier, ERPNext will automatically create an Account
-Ledger for the Supplier under “Accounts Payable” in the Company set in the
-Supplier record.
+If you want to customize payable account for the Supplier, you should first add a payable Account in the Chart of Account, and then select that Payable Account in the Supplier master.
 
-> Advanced Tip: If you want to change the Account Group under which the
-Supplier Account is created, you can set it in the Company master.
+<img class="screenshot" alt="Supplier Master" src="{{docs_base_url}}/assets/img/buying/supplier-payable-account.png">
 
-If you want to create an Account in another Company, just change the Company
-value and “Save” the Supplier again.
+If you don't want to customize payable account, and proceed with default payable account "Creditor", then do not update any value in the Default Supplier Account's table.
 
-> Tip: You can also import from the Data Import Tool
+> Advanced Tip: Default Payable Account is set in the Company master. If you want to set another account as Account as default for payable instead of Creditors Account, go to Company master, and set that account as "Default Payable Account".
+
+You can add multiple companies in your ERPNext instance, and one Supplier can be used across multiple companies. In this case, you should define Companywise Payable Account for the Supplier in the "Default Payable Accounts" table.
+
+<iframe width="660" height="371" src="https://www.youtube.com/embed/anoGi_RpQ20" frameborder="0" allowfullscreen></iframe>
+
+(Check from 2:20)
 
 {next}
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/custom-doctype.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-doctype.md
index fdca8da..316fe2b 100644
--- a/erpnext/docs/user/manual/en/customize-erpnext/custom-doctype.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/custom-doctype.md
@@ -19,7 +19,7 @@
 not be able to re-produce.
 1. Custom?: This field will be checked by default when adding Custom Doctype.
 
-![Doctype Basic]({{docs_base_url}}/assets/img/setup/customize/doctype-basics.png)
+<img alt="Doctype Basic" class="screenshot" src="{{docs_base_url}}/assets/img/setup/customize/doctype-basics.png">
 
 #### Fields
 
@@ -34,7 +34,7 @@
 1. Actions (button)
 1. Attachments or Images
 
-![Doctype fields]({{docs_base_url}}/assets/img/setup/customize/Doctype-all-fields.png)
+<img alt="Doc fields" class="screenshot" src="{{docs_base_url}}/assets/img/setup/customize/doctype-all-fields.png">
 
 When you add fields, you need to enter the **Type**. **Label** is optional for Section Break and Column Break. **Name** (`fieldname`) is the name of the database table column.
 
@@ -44,19 +44,19 @@
 
 In this section, you can define criteria based on which document for this doctype will be named. There are multiple criterion based on which document can be named, like naming based on the value in the specific field, or based on Naming Series, or based on value provided by the user in the prompt, which will be shown when saving document. In the following example, we are doing naming based on the value in the field **book_name**.
 
-![Doctype Naming]({{docs_base_url}}/assets/img/setup/customize/doctype-field-naming.png)
+<img alt="Doctype Naming" class="screenshot" src="{{docs_base_url}}/assets/img/setup/customize/doctype-field-naming.png">
 
 #### Permission
 
 In this table, you should select roles and define permission roles for them for this Doctype.
 
-![Doctype Permissions]({{docs_base_url}}/assets/img/setup/customize/Doctype-permissions.png)
+<img alt="Doctype Permissions" class="screenshot" src="{{docs_base_url}}/assets/img/setup/customize/doctype-permissions.png">
 
 #### Save Doctype
 
 On saving doctype, you will get pop-up to provide name for this Doctype.
 
-![Doctype Save]({{docs_base_url}}/assets/img/setup/customize/Doctype-save.png)
+<img alt="Doctype Save" class="screenshot" src="{{docs_base_url}}/assets/img/setup/customize/Doctype-save.png">
 
 #### Doctype in System
 
@@ -65,10 +65,12 @@
 
 `Human Resource > Document > Book`
 
-![Doctype List]({{docs_base_url}}/assets/img/setup/customize/Doctype-list-view.png)
+<img alt="Doctype List" class="screenshot" src="{{docs_base_url}}/assets/img/setup/customize/doctype-list-view.png">
 
 #### Book master
 
 Using the fields entered, following is the master one book.
 
-![Doctype List]({{docs_base_url}}/assets/img/setup/customize/Doctype-book-added.png)
+<img alt="Doctype Form" class="screenshot" src="{{docs_base_url}}/assets/img/setup/customize/Doctype-book-added.png">
+
+{next}
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/custom-field.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-field.md
index 8aefa80..6410c77 100644
--- a/erpnext/docs/user/manual/en/customize-erpnext/custom-field.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/custom-field.md
@@ -1,77 +1,70 @@
-Custom Field feature allows you to insert fields in the existing masters and transactions as per your requirement. While inseting custom field, you can define its properties like.
-
-* Field Name/Label
-* Field Type
-* Mandatory/Non-Mandatory
-* Insert After Field
-
-To add a Custom Field, go to:
-
-> Setup > Customize > Custom Field > New Custom Field
-
-You can also insert new Custom Field from [Customize Form](https://erpnext.com/customize-erpnext/customize-form) tool.
-
-In Customize Form, for each field, you will find plus (+) option. When click on it, new row will be inserted above that field. You can enter properties for your Custom Field in the newly added blank row.
-
-![Customize Form Custom Field]({{docs_base_url}}/assets/old_images/erpnext/customize-form-custom-field.png)
+Every form in the ERPNext has standard set of fields. If you need to capture some information, but there is no standard field available for it, you can insert Custom Field in a form as per your requirement.
 
 Following are the steps to insert Custom Field in the existing form.
 
-####New Custom Field form / Row in Customize Form
+####Customize Form
 
-As mentioned above, you can insert Custom Field from Custom Field form, and also from Customize Form.
+To add a Custom Field, go to:
 
-####Select Document/Form
+`Setup > Customize > Customize Form`
 
-You should select transaction or master in which you want to insert custom field. Let's assume you need to insert a custom link field in the Quotation form. In this case, Document will be "Quotation".
+####Select Document Type
 
-![Custom Field Document]({{docs_base_url}}/assets/old_images/erpnext/custom-field-document.png)
+In the Customize Form, select Document Type in which you want to insert Custom Field. Let's assume we are inserting Custom Field in the Employee master.
+
+<img alt="Select Document Type" class="screenshot" src="{{docs_base_url}}/assets/img/customize/custom-field-1.gif">
+
+#### Insert Row for the Custom Field
+
+In Customize Form, open the field above which you want to insert a Custom Field. Click on Insert Above.
+
+<img alt="Select Document Type" class="screenshot" src="{{docs_base_url}}/assets/img/customize/custom-field-2.gif">
 
 ####Set Field Label
 
 Custom Field's name will be set based on its Label. If you want to create Custom Field with specific name, but with different label, then you should first set Label as you want Field Name to be set. After Custom Field is saved, you can edit the Field Label again.
 
-![Custom Field Label]({{docs_base_url}}/assets/old_images/erpnext/custom-field-label.png)
-
-####Select Insert After
-
-This field will have all the existing field of the form/doctype selected. Your Custom Field will be placed after field you select in the Insert After field.
-
-![Custom Field Insert]({{docs_base_url}}/assets/old_images/erpnext/custom-field-insert.png)
+<img alt="Select Document Type" class="screenshot" src="{{docs_base_url}}/assets/img/customize/custom-field-3.png">
 
 ####Select Field Type
 
-Click [here](https://erpnext.com/kb/customize/field-types) to learn more about types of field you can set for your Custom Field.
+There are various types of Field like Data, Date, Link, Select, Text and so on. Select Field Type for the Custom Field.
 
-![Custom Field Type]({{docs_base_url}}/assets/old_images/erpnext/custom-field-type.png)
+<img alt="Select Document Type" class="screenshot" src="{{docs_base_url}}/assets/img/customize/custom-field-4.png">
+
+Click [here]({{docs_base_url}}/user/manual/en/customize-erpnext/articles/field-types.html) to learn more about types of field you can set for your Custom Field.
 
 ####Set Option
 
-If you are creating a Link field, then Doctype name with which this field will be linked to will be entered in the Option field. Click [here](https://erpnext.com/kb/customize/creating-custom-link-field) to learn more about creating custom link field.
+Based on the Field Type, value will be entered in the Options field.
 
-![Custom Field Link]({{docs_base_url}}/assets/old_images/erpnext/custom-field-link.png)
+If you are creating a Link field, then in the Options, enter Doctype name with which this field will be linked. Click [here]({{docs_base_url}}/user/manual/en/customize-erpnext/articles/creating-custom-link-field.html) to learn more about creating custom link field.
 
 If field type is set as Select (drop down field), then all he possible result for this field should be listed in the Options field. Each possible result should be separate by row.
 
-![Custom Field Option]({{docs_base_url}}/assets/old_images/erpnext/custom-field-option.png)
+<img alt="Select Document Type" class="screenshot" src="{{docs_base_url}}/assets/img/customize/custom-field-5.png">
 
-For other field types, like Data, Date, Currency etc., Opton field will be left blank.
+For other field types like Data, Date, Currency, Option field will be left blank.
 
 ####Set More Properties
 
 You can set properties as:
 
-1. Mandatory: Should this field be mandatory or non-mandatory.
-1. Print Hide: Should this field be visible in the print format or no.
+1. Mandatory: If checked, entering data in the custom field will be mandatory.
+1. Print Hide: If checked, this field will be hidden from the Standard Print Format. To make field visible in the Standard Print Format, uncheck this field.
 1. Field Description: It will be short field description which will appear just below that field.
-1. Default Value: Value entered in this field will be auto-updated in this field.
+1. Default Value: Value entered in this field will be auto-set in the Custom Field.
 1. Read Only: Checking this option will make custom field non-editable.
 1. Allow on Submit: Checking this option will allow editing value in the field when in submitted transaction.
 
-![Custom Field Properties]({{docs_base_url}}/assets/old_images/erpnext/custom-field-properties.png)
+####Update Customize Form
+
+After inserting required details for the Custom Field, Update Customize Form. On update, Custom Field will be inserting in the form, Employee master in this case. Before checking Employee form, reload your ERPNext account. After reload, check Employee form to see Custom Field in a form.
+
+<img alt="Select Document Type" class="screenshot" src="{{docs_base_url}}/assets/img/customize/custom-field-6.png">
 
 ####Deleting Custom Field
 
-Given a permission, user will be able to delete Custom Fields. Incase, it was deleted by default, if you add another Custom Field with same name. Then you shall see new field auto-mapped with old-deleted Custom Field.
+Given a permission, user will be able to delete Custom Fields. Incase Custom Field is deleted by mistake, if you add another Custom Field with same name. Then you shall see new field auto-mapped with old-deleted Custom Field.
 
 {next}
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/custom-script-fetch-values-from-master.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/custom-script-fetch-values-from-master.md
index b77c9b8..bbfbe45 100644
--- a/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/custom-script-fetch-values-from-master.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/custom-script-fetch-values-from-master.md
@@ -18,8 +18,5 @@
     cur_frm.add_fetch('customer','vat_id','vat_id')
     
 
-* * *
-
-See: [How to create a custom script]({{docs_base_url}}/user/manual/en/customize-erpnext/custom-scripts.html)
 
 {next}
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/index.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/index.md
index e5e9d74..1a54e8c 100644
--- a/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/index.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/index.md
@@ -2,9 +2,9 @@
 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
+`Setup > Customization > Custom Script`
 
-![Custom Script]({{docs_base_url}}/assets/old_images/erpnext/custom-script.png)
+<img alt="Custom Script" class="screenshot" src="{{docs_base_url}}/assets/img/customize/custom-script-1.png">
 
 ### Topics
 
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/customize-form.md b/erpnext/docs/user/manual/en/customize-erpnext/customize-form.md
index 232f34b..b93d76e 100644
--- a/erpnext/docs/user/manual/en/customize-erpnext/customize-form.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/customize-form.md
@@ -1,52 +1,61 @@
 <!--markdown-->
-Before we venture to learn form customization tool, click [here](https://kb.frappe.io/kb/customization/form-architecture) to understand the architecture of forms in ERPNext. It shall help you in using Customize Form tool more efficiently.
+Before we venture to learn form customization tool, click [here](https://frappe.github.io/frappe/user/tutorial/doctypes.html) to understand the architecture of forms in ERPNext. It shall help you in using Customize Form tool more efficiently.
 
-Customize Form is the tool which allows user to customize the property of standard fields as per the requirement. Let's assume we need to set Project Name field as mandatory in the Sales Order form. Following are the steps which shall be followed to achieve this.
+Customize Form is the tool which allows user to customize property of the standard fields, and insert [custom fields]({{docs_base_url}}/user/manual/en/customize-erpnext/custom-field.html) as per the requirement. Let's assume we need to set Project Name field as a mandatory field in the Sales Order form. Following are the steps which shall be followed to achieve this.
 
 ####Step 1: Go to Customize Form
 
-You can go to Customize Form from:
+Go to Customize Form from:
 
-> Setup >> Customize >> Customize Form
+`Setup >> Customize >> Customize Form`
 
-System Manager will find Customize Form option in the Sales Order list (or any other form for that matter) view as well.
+You can also reach the Customize Form tool from the List Views.
 
-![Customize Form List View]({{docs_base_url}}/assets/old_images/erpnext/customize-form-list-view.png)
+<img alt="Customize Form List" class="screenshot" src="{{docs_base_url}}/assets/img/customize/customize-form-from-list-view.gif">
 
-####Step 2: Select Docytpe/Document
+####Step 2: Select Document Type
 
-You should select Docytpe/Document which has field-to-be-customized located in it.
+If navigate from the list view, Document Type will be automatically set in the Customize Form.
 
-![Customize Form Document]({{docs_base_url}}/assets/old_images/erpnext/customize-form-document.png)
+If you reach customize form from the Setup module, or from awesome bar, then you will have to manually select Document Type in which customization needs to be made.
 
-####Step 3:Edit Property
+<img alt="Customize Form select doctype" class="screenshot" src="{{docs_base_url}}/assets/img/customize/customize-form-select-doctype.png">
 
-On selecting Doctype/table, you will have all the fields of the table updated as rows in the Customize Form table. You should drill down to field you need to work on, Project Name in this case.
+####Step 3: Edit Property
 
-On clicking Project Name row, fields to set various property for this field will be shown. To Customize the mandatory property for a field, there is a field called "Mandatory". Checking this field will set Project Name field as mandatory in the Quotation form.
+On selecting Document Type, all the fields of the Document Type will updated as rows in the Customize Form.
 
-![Customize Form Mandatory]({{docs_base_url}}/assets/old_images/erpnext/customize-form-mandatory.png)
+To customized Project field, click on the respective row, and check "Mandatory". With this, Project field will become mandatory in the Sales Order.
 
-Like this, you can customize following properties of the field.
+<img alt="Customize Form select doctype" class="screenshot" src="{{docs_base_url}}/assets/img/customize/customize-form-edit-property.gif">
 
-* 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 labels to suit your industry / language.
-* Make certain fields mandatory.
-* Hide certain fields.
-* Change layout (sequence of fields). To do this, select a field in the grid and click on“Up” or “Down” in the grid toolbar.
-* Add / edit “Select” Options. (for example, you can add more sources in Leads etc).
+Like setting setting field Mandatory, following are the other customization options in the Customize Form tool.
+
+* Change [Field Type]({{docs_base_url}}/user/manual/en/customize-erpnext/articles/field-types.html).
+* Edit Field Labels to suit your industry/language.
+* Set field precision for the Currency field.
+* To hide field, check Hidden.
+* Customize Options for the Select field.
 
 ####Step 4: Update
 
-![Customize Form Update]({{docs_base_url}}/assets/old_images/erpnext/customize-form-update.png)
+To save your customizations, Update Customize Form.
 
-Before checking Sales Order form, you should clear cache and refresh browser tab for customization to take effect.
+To have customizations take effect, reload your ERPNext account once.
 
-For Customize Form, you can also allow attachments, set max number of attachments and set the default Print Format.
+####Other Customizations
+
+From Customize Form, you can also do following customizations:
+
+* Max Attachment Limit: Define [maximum no. of files]({{docs_base_url}}/user/manual/en/customize-erpnext/articles/increase-max-attachments.html) which can attached on a document.
+* Default Print Format: For one document type, you can have multiple print formats. In the Customize Form, you can also set default Print Format for a document.
+* Set [Title Field]({{docs_base_url}}/user/manual/en/customize-erpnext/document-title.html)
+* Sort Field and Sort Order: Define field based on which documents in the list view will be sorted.
 
 >Note: 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.
 
 Following are the properties which you can customize for a specific field from Customize Form.
+
 <style>
     td {
     padding:5px 10px 5px 5px;
@@ -67,7 +76,11 @@
     </tr>
     <tr>
       <td>Print hide</td>
-      <td>Checking it will hide field from Standard print format.</td>
+      <td>Checking it will hide field from the Standard print format.</td>
+    </tr>
+    <tr>
+      <td>Unique</td>
+      <td>For a unique field, same value cannot repeat in another document.</td>
     </tr>
     <tr>
       <td>Hidden</td>
@@ -79,7 +92,7 @@
     </tr>
     <tr>
       <td>Field Type</td>
-      <td>Click <a href="https://erpnext.com/kb/customize/field-types">here</a> to learn about of fields types.</td>
+      <td>Click <a href="{{docs_base_url}}/user/manual/en/customize-erpnext/articles/field-types.html">here</a> to learn about of fields types.</td>
     </tr>
     <tr>
       <td>Options</td>
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/document-title.md b/erpnext/docs/user/manual/en/customize-erpnext/document-title.md
index 639e358..ab83cf2 100644
--- a/erpnext/docs/user/manual/en/customize-erpnext/document-title.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/document-title.md
@@ -12,7 +12,7 @@
 
 1. Setup > Customize > Customize Form
 2. Select your transaction
-3. Edit the **Default** field in your form
+3. Edit the **Default** field in your forms
 
 #### Defining Titles
 
@@ -31,3 +31,5 @@
     src="{{docs_base_url}}/assets/img/customize/editable-title.gif">
 
 If you want a fixed title, you can set the rule in the **Options** property. In this way, the title will be automatically updated everytime the document is updated.
+
+{next}
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/hiding-modules-and-features.md b/erpnext/docs/user/manual/en/customize-erpnext/hiding-modules-and-features.md
index 60addc1..85123f9 100644
--- a/erpnext/docs/user/manual/en/customize-erpnext/hiding-modules-and-features.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/hiding-modules-and-features.md
@@ -1,16 +1,11 @@
-### Hiding Unused Features
-
-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
+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 > Tools > Hide/Unhide Features
+`Setup > Customize > Features Setup`
 
-![Hide Features]({{docs_base_url}}/assets/old_images/erpnext/hide-features.png)
+<img alt="Hide Features" class="screenshot" src="{{docs_base_url}}/assets/img/customize/feature-setup.png">
 
-Check / uncheck the features you want to use and refresh your page for the
-changes to take effect.
+Check the features you want to use. The features which are not checked, relevant fields will get hidden from the forms.
 
 * * *
 
@@ -18,13 +13,12 @@
 
 To hide modules (icons) from the home page, go to:
 
-Setup > Tools> Modules Setup
+`Setup > Permissions > Show / Hide Modules`
 
-![Hide/Unhide Modules]({{docs_base_url}}/assets/old_images/erpnext/hide-module.png)
+<img alt="Hide Features" class="screenshot" src="{{docs_base_url}}/assets/img/customize/show-hide-modules.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.
+Click [here]({{docs_base_url}}/user/manual/en/customize-erpnext/articles/module-visibility.html) to learn about other features from where icons from the desktop can be hidden.
+
+> 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 hidden for that User.
 
 {next}
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/index.txt b/erpnext/docs/user/manual/en/customize-erpnext/index.txt
index 1113395..36e2bf5 100644
--- a/erpnext/docs/user/manual/en/customize-erpnext/index.txt
+++ b/erpnext/docs/user/manual/en/customize-erpnext/index.txt
@@ -1,8 +1,8 @@
 custom-field
-custom-doctype
-custom-scripts
 customize-form
+custom-doctype
 document-title
 hiding-modules-and-features
 print-format
+custom-scripts
 articles
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/print-format.md b/erpnext/docs/user/manual/en/customize-erpnext/print-format.md
index e3c9450..34ef16d 100644
--- a/erpnext/docs/user/manual/en/customize-erpnext/print-format.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/print-format.md
@@ -16,9 +16,9 @@
 
 To create your own versions, open an existing template from:
 
-> Setup > Printing > Print Formats
+`Setup > Printing > Print Formats`
 
-![Print Format]({{docs_base_url}}/assets/old_images/erpnext/customize/print-format.png)
+<img alt="Print Format" class="screenshot" src="{{docs_base_url}}/assets/img/customize/print-format.png">
 
 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”
@@ -43,9 +43,9 @@
 
 To edit / update your print and PDF settings, go to:
 
-> Setup > Printing and Branding > Print Settings
+`Setup > Printing and Branding > Print Settings`
 
-![Print Format]({{docs_base_url}}/assets/old_images/erpnext/customize/print-settings.png)
+<img alt="Print Format" class="screenshot" src="{{docs_base_url}}/assets/img/customize/print-settings.png">
 
 #### Example
 
