diff --git a/erpnext/docs/assets/img/articles/barcode-feature-setup.png b/erpnext/docs/assets/img/articles/barcode-feature-setup.png
deleted file mode 100644
index 0a097ef..0000000
--- a/erpnext/docs/assets/img/articles/barcode-feature-setup.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/sales-person-transaction-4.png b/erpnext/docs/assets/img/articles/sales-person-transaction-4.png
deleted file mode 100644
index 5883c76..0000000
--- a/erpnext/docs/assets/img/articles/sales-person-transaction-4.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/customize/feature-setup.png b/erpnext/docs/assets/img/customize/feature-setup.png
deleted file mode 100644
index 200d138..0000000
--- a/erpnext/docs/assets/img/customize/feature-setup.png
+++ /dev/null
Binary files differ
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 85123f9..ce8a1c3 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,15 +1,4 @@
-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 > Features Setup`
-
-<img alt="Hide Features" class="screenshot" src="{{docs_base_url}}/assets/img/customize/feature-setup.png">
-
-Check the features you want to use. The features which are not checked, relevant fields will get hidden from the forms.
-
-* * *
-
-### Hiding Module Icons
+# Hiding Module Icons
 
 To hide modules (icons) from the home page, go to:
 
diff --git a/erpnext/docs/user/manual/en/selling/articles/sales-persons-in-the-sales-transactions.md b/erpnext/docs/user/manual/en/selling/articles/sales-persons-in-the-sales-transactions.md
index c270e13..781d2ce 100644
--- a/erpnext/docs/user/manual/en/selling/articles/sales-persons-in-the-sales-transactions.md
+++ b/erpnext/docs/user/manual/en/selling/articles/sales-persons-in-the-sales-transactions.md
@@ -32,14 +32,4 @@
 
 `Accounts > Standard Reports > Sales Partners Commission`
 
-####Disable Sales Person Feature
-
-If you don't track Sales Person wise performance, and doesn't wish to use this feature, you can disable it from:
-
-`Setup > Customize > Features Setup`
-
-<img class="screenshot" alt="Disable Sales Person" src="{{docs_base_url}}/assets/img/articles/sales-person-transaction-4.png">
-
-On disabling this feature, fields and tables related to Sales Person will become hidden from masters and transcations.
-
 <!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/track-items-using-barcode.md b/erpnext/docs/user/manual/en/stock/articles/track-items-using-barcode.md
index c880dfb..6d8fcb6 100644
--- a/erpnext/docs/user/manual/en/stock/articles/track-items-using-barcode.md
+++ b/erpnext/docs/user/manual/en/stock/articles/track-items-using-barcode.md
@@ -2,15 +2,9 @@
 
 A barcode is a value decoded into vertical spaced lines. Barcode scanners are the input medium, like Keyboard. When it scans a barcode, the data appears in the computer screens at the point of a cursor.
 
-To enable barcode feature in ERPNext go to:
+### Item Master
 
-`Setup > Customize > Features Setup`
-
-Check "Item Barcode".
-
-<img alt="Material Transfer" class="screenshot" src="{{docs_base_url}}/assets/img/articles/barcode-feature-setup.png">
-
-Now a new field "Barcode" will be appear in Item master. Enter barcode while creating a new item.
+To set the barcode of a particular item, you will have to open the Item record. You can also enter barcode while creating a new item.
 
 <img alt="Material Transfer" class="screenshot" src="{{docs_base_url}}/assets/img/articles/barcode-item-master.png">
 
