diff --git a/erpnext/docs/assets/img/articles/$SGrab_383.png b/erpnext/docs/assets/img/articles/$SGrab_383.png
deleted file mode 100644
index 720ecdf..0000000
--- a/erpnext/docs/assets/img/articles/$SGrab_383.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/$SGrab_389.png b/erpnext/docs/assets/img/articles/$SGrab_389.png
deleted file mode 100644
index ee1b8cb..0000000
--- a/erpnext/docs/assets/img/articles/$SGrab_389.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/$SGrab_390.png b/erpnext/docs/assets/img/articles/$SGrab_390.png
deleted file mode 100644
index b936c07..0000000
--- a/erpnext/docs/assets/img/articles/$SGrab_390.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/$SGrab_391.png b/erpnext/docs/assets/img/articles/$SGrab_391.png
deleted file mode 100644
index 79595ae..0000000
--- a/erpnext/docs/assets/img/articles/$SGrab_391.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/$SGrab_392.png b/erpnext/docs/assets/img/articles/$SGrab_392.png
deleted file mode 100644
index 677e7c9..0000000
--- a/erpnext/docs/assets/img/articles/$SGrab_392.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Screen Shot 2015-02-16 at 2.52.56 pm.png b/erpnext/docs/assets/img/articles/Screen Shot 2015-02-16 at 2.52.56 pm.png
deleted file mode 100644
index e20b65f..0000000
--- a/erpnext/docs/assets/img/articles/Screen Shot 2015-02-16 at 2.52.56 pm.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Screen Shot 2015-02-19 at 5.13.50 pm.png b/erpnext/docs/assets/img/articles/Screen Shot 2015-02-19 at 5.13.50 pm.png
deleted file mode 100644
index f446efc..0000000
--- a/erpnext/docs/assets/img/articles/Screen Shot 2015-02-19 at 5.13.50 pm.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Screen Shot 2015-02-19 at 5.20.52 pm.png b/erpnext/docs/assets/img/articles/Screen Shot 2015-02-19 at 5.20.52 pm.png
deleted file mode 100644
index 404a1cd..0000000
--- a/erpnext/docs/assets/img/articles/Screen Shot 2015-02-19 at 5.20.52 pm.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Selection_049.png b/erpnext/docs/assets/img/articles/Selection_049.png
deleted file mode 100644
index 2cf490e..0000000
--- a/erpnext/docs/assets/img/articles/Selection_049.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Selection_054.png b/erpnext/docs/assets/img/articles/Selection_054.png
deleted file mode 100644
index a17b1ea..0000000
--- a/erpnext/docs/assets/img/articles/Selection_054.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Selection_061.png b/erpnext/docs/assets/img/articles/Selection_061.png
deleted file mode 100644
index 176d8c5..0000000
--- a/erpnext/docs/assets/img/articles/Selection_061.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Selection_062.png b/erpnext/docs/assets/img/articles/Selection_062.png
deleted file mode 100644
index a230c93..0000000
--- a/erpnext/docs/assets/img/articles/Selection_062.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Selection_071.png b/erpnext/docs/assets/img/articles/Selection_071.png
deleted file mode 100644
index 86b7cff..0000000
--- a/erpnext/docs/assets/img/articles/Selection_071.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Selection_072.png b/erpnext/docs/assets/img/articles/Selection_072.png
deleted file mode 100644
index e8dd519..0000000
--- a/erpnext/docs/assets/img/articles/Selection_072.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Selection_440.png b/erpnext/docs/assets/img/articles/Selection_440.png
deleted file mode 100644
index 63fb04c..0000000
--- a/erpnext/docs/assets/img/articles/Selection_440.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Selection_442.png b/erpnext/docs/assets/img/articles/Selection_442.png
deleted file mode 100644
index 55d0735..0000000
--- a/erpnext/docs/assets/img/articles/Selection_442.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Selection_443.png b/erpnext/docs/assets/img/articles/Selection_443.png
deleted file mode 100644
index 6d045f2..0000000
--- a/erpnext/docs/assets/img/articles/Selection_443.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Selection_445.png b/erpnext/docs/assets/img/articles/Selection_445.png
deleted file mode 100644
index bab8185..0000000
--- a/erpnext/docs/assets/img/articles/Selection_445.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Selection_446.png b/erpnext/docs/assets/img/articles/Selection_446.png
deleted file mode 100644
index ecd0edd..0000000
--- a/erpnext/docs/assets/img/articles/Selection_446.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/Selection_447.png b/erpnext/docs/assets/img/articles/Selection_447.png
deleted file mode 100644
index 683c289..0000000
--- a/erpnext/docs/assets/img/articles/Selection_447.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/allowance-percentage-1.png b/erpnext/docs/assets/img/articles/allowance-percentage-1.png
new file mode 100644
index 0000000..4fbed90
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/allowance-percentage-1.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/allowance-percentage-2.png b/erpnext/docs/assets/img/articles/allowance-percentage-2.png
new file mode 100644
index 0000000..a7b9688
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/allowance-percentage-2.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/allowance_percentage.png b/erpnext/docs/assets/img/articles/allowance_percentage.png
deleted file mode 100644
index 519a837..0000000
--- a/erpnext/docs/assets/img/articles/allowance_percentage.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/allowance_percentage_item.png b/erpnext/docs/assets/img/articles/allowance_percentage_item.png
deleted file mode 100644
index 3d30fdc..0000000
--- a/erpnext/docs/assets/img/articles/allowance_percentage_item.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/barcode-feature-setup.png b/erpnext/docs/assets/img/articles/barcode-feature-setup.png
new file mode 100644
index 0000000..0a097ef
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/barcode-feature-setup.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/barcode-item-master.png b/erpnext/docs/assets/img/articles/barcode-item-master.png
new file mode 100644
index 0000000..57b5fcc
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/barcode-item-master.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/barcode-item-selection.gif b/erpnext/docs/assets/img/articles/barcode-item-selection.gif
new file mode 100644
index 0000000..55f3465
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/barcode-item-selection.gif
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/batchwise-stock-1.png b/erpnext/docs/assets/img/articles/batchwise-stock-1.png
new file mode 100644
index 0000000..4477425
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/batchwise-stock-1.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/batchwise-stock-2.png b/erpnext/docs/assets/img/articles/batchwise-stock-2.png
new file mode 100644
index 0000000..5d9b9b4
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/batchwise-stock-2.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/batchwise-stock-3.png b/erpnext/docs/assets/img/articles/batchwise-stock-3.png
new file mode 100644
index 0000000..2fa7712
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/batchwise-stock-3.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/batchwise-stock-4.png b/erpnext/docs/assets/img/articles/batchwise-stock-4.png
new file mode 100644
index 0000000..e6a22f3
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/batchwise-stock-4.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/delivery-note-barcode.png b/erpnext/docs/assets/img/articles/delivery-note-barcode.png
deleted file mode 100644
index 25814c6..0000000
--- a/erpnext/docs/assets/img/articles/delivery-note-barcode.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/difference-account-1.png b/erpnext/docs/assets/img/articles/difference-account-1.png
new file mode 100644
index 0000000..d812b70
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/difference-account-1.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/feature-setup-barcode.png b/erpnext/docs/assets/img/articles/feature-setup-barcode.png
deleted file mode 100644
index 667e3a1..0000000
--- a/erpnext/docs/assets/img/articles/feature-setup-barcode.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/fixed-asset-dep-1.gif b/erpnext/docs/assets/img/articles/fixed-asset-dep-1.gif
new file mode 100644
index 0000000..e6330ad
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/fixed-asset-dep-1.gif
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/fixed-asset-dep-2.png b/erpnext/docs/assets/img/articles/fixed-asset-dep-2.png
new file mode 100644
index 0000000..0679403
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/fixed-asset-dep-2.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/fixed-asset-dep-2.textClipping b/erpnext/docs/assets/img/articles/fixed-asset-dep-2.textClipping
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/fixed-asset-dep-2.textClipping
diff --git a/erpnext/docs/assets/img/articles/item-barcode.png b/erpnext/docs/assets/img/articles/item-barcode.png
deleted file mode 100644
index 6fd0f72..0000000
--- a/erpnext/docs/assets/img/articles/item-barcode.png
+++ /dev/null
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/maintain-stock-1.png b/erpnext/docs/assets/img/articles/maintain-stock-1.png
new file mode 100644
index 0000000..c38b88f
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/maintain-stock-1.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/managing-assets-1.png b/erpnext/docs/assets/img/articles/managing-assets-1.png
new file mode 100644
index 0000000..772037e
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/managing-assets-1.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/reorder-request-1.png b/erpnext/docs/assets/img/articles/reorder-request-1.png
new file mode 100644
index 0000000..ca9b2b0
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/reorder-request-1.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/reorder-request-2.png b/erpnext/docs/assets/img/articles/reorder-request-2.png
new file mode 100644
index 0000000..7ed3b03
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/reorder-request-2.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/reorder-request-3.png b/erpnext/docs/assets/img/articles/reorder-request-3.png
new file mode 100644
index 0000000..a4e4f07
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/reorder-request-3.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/repack-1.png b/erpnext/docs/assets/img/articles/repack-1.png
new file mode 100644
index 0000000..d084299
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/repack-1.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/repack-2.png b/erpnext/docs/assets/img/articles/repack-2.png
new file mode 100644
index 0000000..5b0f4df
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/repack-2.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/serial-naming-1.png b/erpnext/docs/assets/img/articles/serial-naming-1.png
new file mode 100644
index 0000000..964363a
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/serial-naming-1.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/serial-naming-2.png b/erpnext/docs/assets/img/articles/serial-naming-2.png
new file mode 100644
index 0000000..12336df
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/serial-naming-2.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/serial-naming-3.png b/erpnext/docs/assets/img/articles/serial-naming-3.png
new file mode 100644
index 0000000..17ecdcf
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/serial-naming-3.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/serial-naming-4.png b/erpnext/docs/assets/img/articles/serial-naming-4.png
new file mode 100644
index 0000000..6b3d52c
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/serial-naming-4.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/stock-entry-issue.png b/erpnext/docs/assets/img/articles/stock-entry-issue.png
new file mode 100644
index 0000000..eb47037
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/stock-entry-issue.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/stock-entry-manufacture-transfer.gif b/erpnext/docs/assets/img/articles/stock-entry-manufacture-transfer.gif
new file mode 100644
index 0000000..20379ff
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/stock-entry-manufacture-transfer.gif
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/stock-entry-manufacture.gif b/erpnext/docs/assets/img/articles/stock-entry-manufacture.gif
new file mode 100644
index 0000000..a36c18d
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/stock-entry-manufacture.gif
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/stock-entry-receipt.png b/erpnext/docs/assets/img/articles/stock-entry-receipt.png
new file mode 100644
index 0000000..44f62aa
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/stock-entry-receipt.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/stock-entry-subcontract.gif b/erpnext/docs/assets/img/articles/stock-entry-subcontract.gif
new file mode 100644
index 0000000..f952654
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/stock-entry-subcontract.gif
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/stock-entry-transfer.png b/erpnext/docs/assets/img/articles/stock-entry-transfer.png
new file mode 100644
index 0000000..04bd881
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/stock-entry-transfer.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/uom-fraction-1.png b/erpnext/docs/assets/img/articles/uom-fraction-1.png
new file mode 100644
index 0000000..081627b
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/uom-fraction-1.png
Binary files differ
diff --git a/erpnext/docs/assets/img/articles/uom-fraction-2.png b/erpnext/docs/assets/img/articles/uom-fraction-2.png
new file mode 100644
index 0000000..831106b
--- /dev/null
+++ b/erpnext/docs/assets/img/articles/uom-fraction-2.png
Binary files differ
diff --git a/erpnext/docs/assets/img/videos/conf-2015.jpg b/erpnext/docs/assets/img/videos/conf-2015.jpg
new file mode 100644
index 0000000..c8f0591
--- /dev/null
+++ b/erpnext/docs/assets/img/videos/conf-2015.jpg
Binary files differ
diff --git a/erpnext/docs/user/manual/en/manufacturing/subcontracting.md b/erpnext/docs/user/manual/en/manufacturing/subcontracting.md
index 6f2b86b..9252171 100644
--- a/erpnext/docs/user/manual/en/manufacturing/subcontracting.md
+++ b/erpnext/docs/user/manual/en/manufacturing/subcontracting.md
@@ -37,4 +37,8 @@
 > Note 2: ERPNext will automatically add the raw material rate for your
 valuation purpose when you receive the finished Item in your stock.
 
+### Video Help
+
+<iframe width="660" height="371" src="https://www.youtube.com/embed/ThiMCC2DtKo" frameborder="0" allowfullscreen></iframe>
+
 {next}
diff --git a/erpnext/docs/user/manual/en/stock/articles/allow-over-delivery-billing-against-sales-order-upto-certain-limit.md b/erpnext/docs/user/manual/en/stock/articles/allow-over-delivery-billing-against-sales-order-upto-certain-limit.md
index bfee143..f0963d1 100644
--- a/erpnext/docs/user/manual/en/stock/articles/allow-over-delivery-billing-against-sales-order-upto-certain-limit.md
+++ b/erpnext/docs/user/manual/en/stock/articles/allow-over-delivery-billing-against-sales-order-upto-certain-limit.md
@@ -1,15 +1,22 @@
-<h1>Allow over delivery / billing against Sales Order upto certain limit</h1>
+#Allow Over Delivery/Billing
 
-<h1>Allow over delivery / billing against Sales Order upto certain limit</h1>
+While creating Delivery Note, system validates if item's Qty mentined is same as in the Sales Order. It Item Qty has been increased, you will get over-delivery validation. If you want to be able to deliver more items than mentioned in the Sales Order, you should update "Allow over delivery or receipt upto this percent" in the Item master.
 
-To setup over delivery / receipt / billing against a Sales / Purchase Order upto certain limit:
+<img alt="Item wise Allowance percentage" class="screenshot" src="{{docs_base_url}}/assets/img/articles/allowance-percentage-1.png">
 
-1. Go to `Stock > Setup > Stock Settings`.
-2. Set `Allowance Percentage` and save the Stock Settings.
-![Allowance Percentage]({{docs_base_url}}/assets/img/articles/allowance_percentage.png)
-For example: If you have ordered 100 units. and your Allowance is 50% then you are allowed to receive 150 units.
-3. To set item-specific limit, set `Allowance Percentage` in `Item` master.
-![Allowance Percentage in Item]({{docs_base_url}}/assets/img/articles/allowance_percentage_item.png)
+Item's and Rate is also validated when creating Sales Invoice from Sales Order. Also when creating Purchase Receipt and Purchaes Invoice from Purchase Order. Updating "Allow over delivery or receipt upto this percent" will be affective in all sales and purchase transactions.
+
+For example, if you have ordered 100 units of an item, and if item's over receipt percent is 50%, then you are allowed to make Purchase Receipt for upto 150 units.
+
+Update global value for "Allow over delivery or receipt upto this percent" from Stock Settings. Value updated here will be applicable for all the items.
+
+1. Go to `Stock > Setup > Stock Settings`
+
+2. Set `Allowance Percentage`.
+
+3. Save Stock Settings.
+
+<img alt="Item wise Allowance percentage" class="screenshot" src="{{docs_base_url}}/assets/img/articles/allowance-percentage-2.png">
 
 
 <!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/auto-creation-of-material-request.md b/erpnext/docs/user/manual/en/stock/articles/auto-creation-of-material-request.md
index e95b113..02d88d8 100644
--- a/erpnext/docs/user/manual/en/stock/articles/auto-creation-of-material-request.md
+++ b/erpnext/docs/user/manual/en/stock/articles/auto-creation-of-material-request.md
@@ -1,25 +1,27 @@
-<h1>Auto Creation of Material Request</h1>
+#Auto Creation of Material Request
 
-<h1>Auto Creation of Material Request</h1>
+To prevent stockouts, you can track item's reorder level. When stock level goes below reorder level, purchase manager is notified and instructed to initiate purchase process for the item.
 
-ERPNext allows you to define item-wise and warehouse-wise reorder level in the item master. Reorder level is the item's stock level at which item should be re-ordered.
+In ERPNext, you can update item's Reorder Level and Reorder Qty in the Item master. If same item has different reorder level, you can also update warehouse-wise reorder level and reorder qty.
+
+<img alt="reorder level" class="screenshot" src="{{docs_base_url}}/assets/img/articles/reorder-request-1.png">
 
 With reorder level, you can also define what should be the next action. Either new purchase or transfer from another warehouse. Based on setting in Item master, purpose will be updated in the Material Request as well.
 
-![Item Reorder Level]({{docs_base_url}}/assets/img/articles/$SGrab_391.png)
+<img alt="reorder level next action" class="screenshot" src="{{docs_base_url}}/assets/img/articles/reorder-request-2.png">
 
-You can have Material Request automatically created for items whose stock level reaches re-order level. You can enable this feature from:
+When item's stock reaches reorder level, Material Request is auto-created automatically. You can enable this feature from:
 
 `Stock > Setup > Stock Settings`
 
-![Item Reorder Stock Setting]({{docs_base_url}}/assets/img/articles/$SGrab_392.png)
+<img alt="active auto-material request" class="screenshot" src="{{docs_base_url}}/assets/img/articles/reorder-request-3.png">
 
-A separate Material Request will be created for each item. User with Purchase Manager's role will be informed about these Material Request. He can further process this Material Request, and create Supplier Quotation and Purchase Order against it.
+A separate Material Request will be created for each item. User with Purchase Manager's role will receive email alert about these Material Requests.
 
-If auto creation of Material Request is failed, Purchase Manager will be informed about error message via email. One of the most encountered error message is:
+If auto creation of Material Request is failed, User with Purchase Manager role will be informed about error message. One of the most encountered error message is:
 
-**An error occurred for certain Items while creating Material Requests based on Re-order level.
-Date 01-04-2015 not in any Fiscal Year.**
+**An error occurred for certain Items while creating Material Requests based on Re-order level.**
+**Date 01-04-2016 not in any Fiscal Year.**
 
-One of the reason of error could be Fiscal Year as well. Click [here](https://erpnext.com/kb/accounts/fiscal-year-error) to learn more about it.
+One of the reason of error could be Fiscal Year as well. Click [here]({{docs_base_url}}/user/manual/en/accounts/articles/fiscal-year-error.html) to learn more about it.
 <!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/creating-depreciation-for-item.html b/erpnext/docs/user/manual/en/stock/articles/creating-depreciation-for-item.html
deleted file mode 100644
index 6115ed5..0000000
--- a/erpnext/docs/user/manual/en/stock/articles/creating-depreciation-for-item.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<h1>Creating Depreciation For Item</h1>
-
-<h1>Creating Depreciation For Item</h1>
-
-<b>Question:</b> A Fixed Asset Item has been purchased and stored in a warehouse. How can the user create a depreciation for a Fixed Asset Item?<u><b><br><br></b></u><b>Answer:</b><u><b><br><br></b></u>Though there is no direct, automated method to book
-Asset Depreciation. A suitable work around to achieve this is by creating a Stock Reconciliation Entry.
-<br><u><b><br>Step 1:</b></u> In the Attachment file, fill in the appropriate columns;
-<br>
-<ul>
-    <li><i>Item Code</i> whose value is to be depreciated</li>
-    <li><i>Warehouse </i>in which it is stored</li>
-    <li><i>Qty (Quantity) </i>Leave this column blank</li>
-    <li>&nbsp;<i>Valuation Rate </i>Enter the Value after Depreciation</li>
-</ul>
-<p>
-    <br>
-</p>
-<img src="{{docs_base_path}}/assets/img/articles/kb_deprec_csv.png"><br>
-<p><u><b><br></b></u>
-</p>
-<p><u><b>Step 2:</b></u> In the Stock Reconciliation Form, enter the Expense account for depreciation in <i>Difference Account</i>.</p>
-<br><img src="{{docs_base_path}}/assets/img/articles/kb_deprec_form.png" height="302" width="652"><br>
-<p>
-    <br>
-</p>
-<div class="well">Note: For more information on Stock Reconciliation, see the <a href="https://erpnext.com/user-guide/setting-up/stock-reconciliation-for-non-serialized-item" target="_blank">User Guide</a>.</div>
-<div class="well"> Note: An Automated Asset Depreciation feature in on our To-Do List. See this <a href="https://github.com/frappe/erpnext/issues/191" target="_blank">Github Issue</a>.</div>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/creating-depreciation-for-item.md b/erpnext/docs/user/manual/en/stock/articles/creating-depreciation-for-item.md
index af9223f..491427c 100644
--- a/erpnext/docs/user/manual/en/stock/articles/creating-depreciation-for-item.md
+++ b/erpnext/docs/user/manual/en/stock/articles/creating-depreciation-for-item.md
@@ -1,24 +1,28 @@
-#Creating Depreciation For Item
+#Depreciation Entry
 
-**Question:** A Fixed Asset Item has been purchased and stored in a warehouse. How can the user create a depreciation for a Fixed Asset Item?<
+**Question:** A Fixed Asset Item has been purchased and stored in a warehouse. How to create a depreciation for a Fixed Asset Item?
 
-**Answer:**Though there is no direct, automated method to book Asset Depreciation. A suitable work around to achieve this is by creating a Stock Reconciliation Entry.
+**Answer:**You can post asset depreciation entry for the fixed asset item via [Stock Reconciliation]({{docs_base_url}}/user/manual/en/stock/opening-stock.html) Entry.
 
-####Step 1: In the Attachment file, fill in the appropriate columns;
+####Step 1:
 
-- _Item Code_ whose value is to be depreciated.
-- _Warehouse_ in which it is stored
-- _Qty_ Leave this column blank
-- _Valuation rate_ Enter the Value after Depreciation
+In the Attachment file, fill in the appropriate columns;
 
-<img src="{{docs_base_path}}/assets/img/articles/kb_deprec_csv.png"><br>
+- **Item Code** whose value is to be depreciated.
+- **Warehouse** in which item is stored.
+- **Qty (Quantity)** Leave this column blank.
+- **Valuation Rate** will be item's value after depreciation.
 
+<img alt="reorder level" class="screenshot" src="{{docs_base_url}}/assets/img/articles/fixed-asset-dep-1.gif">
 
-####Step 2: 
+After updating Valuation Rate for an item, come back to Stock Reconciliation and upload save .csv file.
 
-In the Stock Reconciliation Form, enter the Expense account for depreciation in <i>Difference Account</i>.</p>
-<img src="{{docs_base_path}}/assets/img/articles/kb_deprec_form.png" height="302" width="652">
+####Step 2:
 
-<div class="well">Note: For more information on Stock Reconciliation, see the <a href="https://erpnext.com/user-guide/setting-up/stock-reconciliation-for-non-serialized-item" target="_blank">User Guide</a>.</div>
+Select Expense account for depreciation in **Difference Account**. Value booked in the depreciation account will be the difference of old and next valuation rate of the fixed asset item, which will be actually the depreciation amount.
 
-<div class="well"> Note: An Automated Asset Depreciation feature in on our To-Do List. See this <a href="https://github.com/frappe/erpnext/issues/191" target="_blank">Github Issue</a>.</div>
\ No newline at end of file
+<img alt="reorder level" class="screenshot" src="{{docs_base_url}}/assets/img/articles/fixed-asset-dep-2.png">
+
+####Stock Reconciliation Help Video
+
+<iframe width="660" height="371" src="https://www.youtube.com/embed/0yPgrtfeCTs" frameborder="0" allowfullscreen></iframe>
diff --git a/erpnext/docs/user/manual/en/stock/articles/index.txt b/erpnext/docs/user/manual/en/stock/articles/index.txt
index fc039b1..6d20384 100644
--- a/erpnext/docs/user/manual/en/stock/articles/index.txt
+++ b/erpnext/docs/user/manual/en/stock/articles/index.txt
@@ -1,7 +1,7 @@
 allow-over-delivery-billing-against-sales-order-upto-certain-limit
 auto-creation-of-material-request
-creating-depreciation-for-item
-is-stock-item-field-frozen-in-item-master
+depreciation-entry
+maintain-stock-field-frozen-in-item-master
 manage-rejected-finished-goods-items
 managing-assets
 managing-batch-wise-inventory
@@ -11,5 +11,4 @@
 serial-no-naming
 stock-entry-purpose
 stock-level-report
-track-items-using-barcode
-using-batch-feature-in-stock-entry
\ No newline at end of file
+track-items-using-barcode
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/is-stock-item-field-frozen-in-item-master.md b/erpnext/docs/user/manual/en/stock/articles/maintain-stock-field-frozen-in-item-master.md
similarity index 77%
rename from erpnext/docs/user/manual/en/stock/articles/is-stock-item-field-frozen-in-item-master.md
rename to erpnext/docs/user/manual/en/stock/articles/maintain-stock-field-frozen-in-item-master.md
index a012827..f93e668 100644
--- a/erpnext/docs/user/manual/en/stock/articles/is-stock-item-field-frozen-in-item-master.md
+++ b/erpnext/docs/user/manual/en/stock/articles/maintain-stock-field-frozen-in-item-master.md
@@ -1,14 +1,12 @@
-<h1>Is Stock Item field Frozen in the Item master</h1>
+#Maintain Stock field Frozen in the Item master
 
-<h1>Is Stock Item field Frozen in the Item master</h1>
+In the item master, you might witness values in the following fields to be frozen.
 
-In the item master, you might witness values in the following fields be frozen.
-
-1. Is Stock Item
+1. Maintain Stock
 1. Has Batch No.
 1. Has Serial No.
 
-![Item Field Frozen]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-16 at 2.52.56 pm.png)
+<img alt="Item Field Frozen" class="screenshot" src="{{docs_base_url}}/assets/img/articles/maintain-stock-1.png">
 
 For an item, once stock ledger entry is created, values in these fields will be froze. This is to prevent user from changing value which can lead to mis-match of actual stock, and stock level in the system of an item.
 
diff --git a/erpnext/docs/user/manual/en/stock/articles/manage-rejected-finished-goods-items.md b/erpnext/docs/user/manual/en/stock/articles/manage-rejected-finished-goods-items.md
index 9bb0103..2d57d64 100644
--- a/erpnext/docs/user/manual/en/stock/articles/manage-rejected-finished-goods-items.md
+++ b/erpnext/docs/user/manual/en/stock/articles/manage-rejected-finished-goods-items.md
@@ -1,32 +1,31 @@
-<h1>Manage Rejected Finished Goods Items</h1>
+#Manage Rejected Finished Goods Items
 
-<h1>Manage Rejected Finished Goods Items</h1>
+There could be manufactured Items which would not pass quality test, hence rejected.
 
-There could be manufactured Items which would not pass quality test, and would be rejected.
-
-Standard manufacturing process in ERPNext doesn't cover managing rejected items separately. Hence you should create finished goods entry for both accepted as well as rejected items. With this, you will have rejected items also received in the finished goods warehouse.
+Standard manufacturing process in ERPNext doesn't cover managing rejected items. Hence you should create finished goods entry for both accepted as well as rejected items. With this, you will have rejected items also received in the finished goods warehouse.
 
 To move rejected items from the finished goods warehouse, you should create Material Transfer entry. Steps below to create Material Transfer entry.
 
-####New Stock Entry
+####Step 1: New Stock Entry
 
-`Stock > Stock Entry > New`
+`Stock > Documents > Stock Entry > New`
 
-####Entry Purpose
+####Step 2: Purpose
 
 Purpose = Material Transfer
 
-####Warehouse
+####Step 3: Warehouse
 
 Source Warehouse = Finished Goods warehouse
 Target Warehouse = Rejected items warehouse
 
-####Items
+####Step 4: Items
 
 Select item which failed quality test, and enter total rejected items as Qty.
 
-####Submit Stock Entry
+####Step 5: Submit Stock Entry
 
 On Saving and Submitting Stock Entry, stock of rejected items will be moved from Finished Goods Warehouse to Rejected Warehouse.
 
+
 <!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/managing-assets.md b/erpnext/docs/user/manual/en/stock/articles/managing-assets.md
index 5032dcd..0be7860 100644
--- a/erpnext/docs/user/manual/en/stock/articles/managing-assets.md
+++ b/erpnext/docs/user/manual/en/stock/articles/managing-assets.md
@@ -1,24 +1,23 @@
-<h1>Managing Assets</h1>
+#Managing Assets
 
-<h1>Managing Assets</h1>
+Items like machinery, furniture, land and property, patents etc. can be categorized as fixed asset of a company. In ERPNext, you can maintain fixed asset items, mainly stock items in a separate Warehouse.
 
-Items like machinery, furniture, land and property, patents etc. can be categorized as fixed asset of a company. In ERPNext, you can maintain fixed asset items in a separate Warehouse.
-
-Item can be created for each type of an asset. Whereas unique Serial No. will be created for each unit of that asset item. Maintaining serialized inventory of asset item will have in tracking item's warranty and expiry details.
+For the high value asset items, serialized inventory can be maintained. It will allow assigning unique Serial No. to each unit of an asset item.
 
 ####Fixed Asset Master
 
-While creating Item Code for the fixed asset item, you should updated field "Is Fixed Asset" as "Yes".
+While creating Item Code for the fixed asset item, you should check "Is Fixed Asset" field.
 
-![Fixed Asset Item]({{docs_base_url}}/assets/img/articles/$SGrab_383.png)
+<img alt ="Fixed Asset Item" class="screenshot" src="{{docs_base_url}}/assets/img/articles/managing-assets-1.png">
 
 Other item properties like Stock/Non-stock item can be updated on the nature of asset. Like patent and trademarks will be non-stock assets.
 
-If your asset item is serialized, click [here](https://erpnext.com/user-guide/stock/serialized-inventory) to learn how serialized inventory is managed in ERPNext.
+If your asset item is serialized, click [here]({{docs_base_url}}/user/videos/learn/serialized-inventory.html) to learn how serialized inventory is managed in ERPNext.
 
 ####Warehouse for Fixed Asset
 
-Separate Warehouse should be created for the fixed asset items. All the sales, purchase and stock transactions for asset items will be done in that fixed asset warehouse only.
+Separate Warehouse should be created for the fixed asset items. All the sales, purchase and stock transactions for asset items should be done for fixed asset warehouse only.
 
-Also, as per the perpetual inventory valuation system, you will have accounting ledger auto-created for the warehouse. You can move the accounting ledger of warehouse created for fixed asset from Stock Asset group to fixed asset group. This will be helpful while preparing financial statement for a company.
+As per the perpetual inventory valuation system, accounting ledger is auto-created for a warehouse. You can move the accounting ledger of fixed asset asset from Stock Asset (default group) to Fixed Asset's group account.
+
 <!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/managing-batch-wise-inventory.html b/erpnext/docs/user/manual/en/stock/articles/managing-batch-wise-inventory.html
deleted file mode 100644
index 23cd46d..0000000
--- a/erpnext/docs/user/manual/en/stock/articles/managing-batch-wise-inventory.html
+++ /dev/null
@@ -1,5 +0,0 @@
-<h1>Managing Batch wise Inventory</h1>
-
-<h1>Managing Batch wise Inventory</h1>
-
-To maintain batches against an Item you need to mention 'has batch no' as yes in the Item Master. You can create a new Batch from&nbsp;<div><br></div><div><p >Stock &gt; Documents &gt; Batch &gt; New</p></div><div><br></div><div>To learn more about batch check out the manual page at&nbsp;https://manual.erpnext.com/contents/stock/batch</div><div><br></div><div>While making a purchase receipt or delivery note, mention the batch number against the item.</div><div><br></div><div><p ><strong>Batch No. in Purchase Receipt</strong></p><p ><img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2015-06-23 at 5.33.37 pm.png"><br></p><p ><strong>Batch No. in Delivery Note</strong></p><p ><img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2015-06-23 at 5.35.28 pm.png"><br></p><p ><b>Batch-wise Stock Balance Report</b></p><p >To check batch-wise stock balance report, go to:</p><p >Stock &gt; Standard Reports &gt; Batch-wise Balance History</p><p ><br></p></div>
diff --git a/erpnext/docs/user/manual/en/stock/articles/managing-batch-wise-inventory.md b/erpnext/docs/user/manual/en/stock/articles/managing-batch-wise-inventory.md
index 5b16954..7ae102b 100644
--- a/erpnext/docs/user/manual/en/stock/articles/managing-batch-wise-inventory.md
+++ b/erpnext/docs/user/manual/en/stock/articles/managing-batch-wise-inventory.md
@@ -1,23 +1,35 @@
 #Managing Batch wise Inventory
 
-To maintain batches against an Item you need to mention 'has batch no' as yes in the Item Master. You can create a new Batch from:
+Set of items which has same properties and attributes can be group in a single Batch. For example, pharceuticals items are batch, so that it's manufacturing and expiry date can be tracked together. 
+
+To maintain batches against an Item you need to mention 'Has Batch No' as yes in the Item Master. 
+
+<img alt="Batch Item" class="screenshot" src="{{docs_base_url}}/assets/img/articles/batchwise-stock-1.png">
+
+You can create a new Batch from:
 
 `Stock > Documents > Batch > New`
 
-To learn more about batch check out the manual page at: https://manual.erpnext.com/contents/stock/batch
+To learn more about batch, click [here.]({{docs_base_url}}/user/manual/en/stock/batch.html)
 
-While making a purchase receipt or delivery note, mention the batch number against the item. 
+For the Batch item, updating Batch No. in the stock transactions (Purchase Receipt & Delivery Note) is mandatory.
 
-**Batch No. in Purchase Receipt**
+#### Purchase Receipt
 
-<img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2015-06-23 at 5.33.37 pm.png">
+When creating Purchase Receipt, you should create new Batch, or select one of the existing Batch master. One Batch can be associated with one Batch Item.
 
-**Batch No. in Delivery Note**
+<img alt="Batch in Purchase Receipt" class="screenshot" src="{{docs_base_url}}/assets/img/articles/batchwise-stock-2.png">
 
-<img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2015-06-23 at 5.35.28 pm.png"><br>
+#### Delivery Note
 
-Batch-wise Stock Balance Report 
+Define Batch in Delivery Note Item table. If Batch item is added under Product Bundle, you can update it's Batch No. in the Packing List table sa well.
+
+<img alt="Batch in Delivery Note" class="screenshot" src="{{docs_base_url}}/assets/img/articles/batchwise-stock-3.png">
+
+#### Batch-wise Stock Balance Report
 
 To check batch-wise stock balance report, go to:
 
-`Stock > Standard Reports > Batch-wise Balance History`
+Stock > Standard Reports > Batch-wise Balance History
+
+<img alt="Batchwise Stock Balance" class="screenshot" src="{{docs_base_url}}/assets/img/articles/batchwise-stock-4.png">
diff --git a/erpnext/docs/user/manual/en/stock/articles/managing-fractions-in-uom.md b/erpnext/docs/user/manual/en/stock/articles/managing-fractions-in-uom.md
index 75acd38..12447e0 100644
--- a/erpnext/docs/user/manual/en/stock/articles/managing-fractions-in-uom.md
+++ b/erpnext/docs/user/manual/en/stock/articles/managing-fractions-in-uom.md
@@ -1,12 +1,10 @@
-<h1>Managing Fractions in UoM</h1>
-
-<h1>Managing Fractions in UoM</h1>
+#Managing Fractions in UoM
 
 UoM stands for Unit of Measurement. Few examples of UoM are Numbers (Nos), Kgs, Litre, Meter, Box, Carton etc.
 
-There are few UoMs which cannot have value decimal places. For example, if we have television for an item, with Nos as its UoM, we cannot have 1.5 Nos. of television, or 3.7 Nos. of computer sets. The value of quantity for these items must be whole number.
+There are few UoMs which cannot have value in decimal places. For example, if we have television for an item, with Nos as its UoM, we cannot have 1.5 Nos. of television, or 3.7 Nos. of computer sets. The value of quantity for these items must be whole number.
 
-You can configure if particular UoM can have value in decimal place or no. Bydefault, decimal places will be allowed in all the UoMs. To restrict decimal places or value in fraction for any UoM, you should follow these steps.
+You can configure if particular UoM can have value in decimal place or no. By default, value in decimal places will be allowed for all the UoMs. To restrict decimal places or value in fraction for any UoM, you should follow these steps.
 
 ####UoM List
 
@@ -14,21 +12,21 @@
 
 `Stock > Setup > UoM`
 
-For the list of UoM, select one which you want to restrict value in fraction. Let's assume that UoM is Nos.
+From the list of UoM, select UoM for which value in decimal place is to be restricted. Let's assume that UoM is Nos.
 
 ####Configure
 
-In the UoM form, you will find a field called "Must be whole number". Check this field to restrict user from enter decimal places in quantity field for item with this UoM.
+In the UoM master, you will find a field called "Must be whole number". Check this field to restrict user from enter value in decimal places in quantity field, for item having this UoM.
 
-![UoM Whole No]({{docs_base_url}}/assets/img/articles/$SGrab_390.png)
+<img alt="UoM Must be Whole No" class="screenshot" src="{{docs_base_url}}/assets/img/articles/uom-fraction-1.png">
 
-####While Creating Entry
+####Validation
 
-While creating transaction, if you enter value in fraction for item who's UoM has "Must be whole number" checked, you will get error message stating:
+While creating transaction, if you enter value in fraction for item whos UoM has "Must be whole number" checked, you will get error message stating:
 
 `Quantity cannot be a fraction at row #`
 
-![UoM Fraction Error]({{docs_base_url}}/assets/img/articles/$SGrab_389.png)
+<img alt="UoM Validation Message" class="screenshot" src="{{docs_base_url}}/assets/img/articles/uom-fraction-2.png">
 
 
 <!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/opening-stock-balance-entry-for-the-serialized-and-batch-item.md b/erpnext/docs/user/manual/en/stock/articles/opening-stock-balance-entry-for-the-serialized-and-batch-item.md
index 5251a8e..9b8684a 100644
--- a/erpnext/docs/user/manual/en/stock/articles/opening-stock-balance-entry-for-the-serialized-and-batch-item.md
+++ b/erpnext/docs/user/manual/en/stock/articles/opening-stock-balance-entry-for-the-serialized-and-batch-item.md
@@ -1,14 +1,14 @@
-<h1>Opening Stock Balance Entry for the Serialized and Batch Item</h1>
+#Opening Stock Balance Entry for the Serialized and Batch Item
 
-<h1>Opening Stock Balance Entry for the Serialized and Batch Item</h1>
+Items for which Serial No. and Batch No. is maintained, opening stock balance entry for them is update via Stock Entry. [Click here to learn how serialized inventory is managed in ERPNext]({{docs_base_url}}/user/manual/en/stock/serial-no.html).
 
-Items for which Serial No. and Batch No. is maintained, opening stock balance entry for them will be update via Stock Entry. [Click here to learn how serialized inventory is managed in ERPNext](https://erpnext.com/user-guide/stock/serialized-inventory).
+**Question:** Why Opening Balance entry for the Serialized and Batch Item cannot be updated via Stock Reconciliation?
 
-Why Opening Balance entry for the Serialized and Batch Item cannot be updated via Stock Reconciliation?
+In the ERPNext, stock level of a serialized items is derived based on the count of Serial Nos for that item. Hence, unless Serial Nos. are created for the serialized item, its stock level is not be updated. In the Stock Reconciliation Tool, you can only update opening quantity of an item, but not their Serial No. and Batch No.
 
-In the ERPNext, stock level of a serialized items is derived based on the count of Serial Nos for that item. Hence, unless Serial Nos. are created for the serialized item, its stock level will not be updated. In the Stock Reconciliation Tool, you can only update opening quantity of an item, and not their Serial No. and Batch No.
+### Opening Balance for the Serialized Item
 
-Let's check steps for create opening stock balance entry for the Serialized and Batch item.
+Following are the steps to create opening stock balance entry for the Serialized and Batch item.
 
 #### Step 1: New Stock Entry
 
@@ -28,36 +28,33 @@
 
 #### Step 5: Select Items
 
-Select Items in the Stock Entry table.
+Select Items for which opening balance is to be updated.
 
 #### Step 6: Update Opening Qty
 
-For the serialized item, you should update as many Serial Nos as their Qty. If you have updated Prefix in the Item master, on the submission of Stock Entry Serial Nos. will be auto-created following that prefix.
+For the serialized item, update quantity as many Serial Nos are their.
 
-![Item Serial No. Prefix]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-19 at 5.13.50 pm.png)
+For the serialized item, mention Serial Nos. equivalent to it's Qty. Or if Serial Nos. are configured to be created based on Prefix, then no need to mention Serial Nos. manually. Click [here]({{docs_base_url}}/user/manual/en/stock/articles/serial-no-naming.html) to learn more about Serial No. naming.
 
-For a batch item, you should provide Batch ID in which opening balance will be updated. You should keep batch master ready, and updated it for the Batch Item. To create new Batch, go to:
+For a batch item, provide Batch ID in which opening balance will be updated. Keep batch master ready, and updated it for the Batch Item. To create new Batch, go to:
 
 `Stock > Setup > Batch > New`
 
-[Click here to learn how Batchwise inventory is managed in ERPNext](https://erpnext.com/user-guide/stock/batchwise-inventory).
+[Click here to learn how Batchwise inventory is managed in ERPNext.]({{docs_base_url}}/user/manual/en/stock/articles/managing-batch-wise-inventory.html)
 
 #### Step 7: Update Valuation Rate an Item
 
-Valuation Rate is the mandatory field, where you should update `per unit value of item`. If you have unit of items having different valuation rates, they should be updated in a separate row, with different Valuation Rate.
+Update valuation rate, which will be per unit value of item. If different units of the same items having different valuation rate, they should be updated in a separate row, with different Valuation Rates.
 
 #### Step 8: Difference Account
 
-As per perpetual inventory valuation system, accounting entry is created for every stock entry. Accounting system followed in the ERPNext requires Total Debit in an entry matching with Total Credit. On the submission of Stock Entry, system Debits accounting ledger of a Warehouse by total value of items. To balance the same, we use Temporary Liability account in the Difference Account field. [Click here to learn more about use of Temporary Accounts in updating opening balance](https://erpnext.com/kb/accounts/updating-opening-balance-in-accounts-using-temporary-account).
+As per perpetual inventory valuation system, accounting entry is created for every stock transaction. Double entry accounting system requires Total Debit matching with Total Credit in an entry. On the submission of Stock Entry, system debits Warehouse account by total value of items. To balance the same, we use Temporary Opening account as a Difference Account.
 
-![Difference Account]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-19 at 5.20.52 pm.png)
+<img alt="Difference Account" class="screenshot" src="{{docs_base_url}}/assets/img/articles/difference-account-1.png">
 
 #### Step 9: Save and Submit Stock Entry
 
-On submission of Stock Entry, stock ledger entry will be posted, and opening balance will be updated for the items on a given posting date.
+On submission of Stock Entry, stock ledger posting will be posted, and opening balance will be updated for the items on a given Posting Date.
 
-If Serial Nos. for your items are set to be created based on prefix, then on submission of Stock Entry, Serial Nos. will be created as well.
-
-![Serial No Creation]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-19 at 5.28.57 pm.png)
 
 <!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/repack-entry.md b/erpnext/docs/user/manual/en/stock/articles/repack-entry.md
index 59bf983..1d758c8 100644
--- a/erpnext/docs/user/manual/en/stock/articles/repack-entry.md
+++ b/erpnext/docs/user/manual/en/stock/articles/repack-entry.md
@@ -1,16 +1,14 @@
-<h1>Repack Entry</h1>
+#Repack Entry
 
-<h1>Repack Entry</h1>
-
-If you buy items in bulk to be repacked into smaller packs, you can create a **Stock Entry** of type "Repack". For example, item bought in tons can be repacked into Kgs. 
+Repack Entry is created for item bought in bulk, which is being packed into smaller packages. For example, item bought in tons can be repacked into Kgs. 
 
 Notes:
-1. Separate purchase and repacked Items must be made.
+1. Purchase Item and repack will be have different Item Codes.
 2. Repack entry can be made with or without BOM (Bill of Material).
 
-Let's check below scenario to understand this better.
+In a Repack Entry, there can be one or more than one repack items. Let's check below scenario to understand this better.
 
-Assume you buy crude oil in barrel, and get diesel and gasoline as its output. To create production entry, go to:
+Assume we are buying boxes of spray paint of specific colour (Green, Blue etc). And later re-bundling to create packs having multiple colours of spray paint (Blue-Green, Green-Yellow etc.) in them.
 
 #### 1. New Stock Entry
 
@@ -22,14 +20,16 @@
 
 For raw-material/input item, only Source Warehouse will be provided.
 
-For repacked/production item, only Target Warehouse will be entered. You will have to provide valuation for the repacked/production item.
+For repacked/output items, only Target Warehouse will be provided. You will have to provide valuation for the repack items.
 
-![New STE]({{docs_base_url}}/assets/img/articles/Selection_071.png)
+<img alt="Repack Entry" class="screenshot" src="{{docs_base_url}}/assets/img/articles/repack-1.png">
+
+Update Qty for all the items selected.
 
 #### 3. Submit Stock Entry
 
-On submitting Stock Entry, stock of input item will be reduced from Source Warehouse, and stock of repacked/production item will be added in the Target Warehouse.
+On submitting Stock Entry, stock of input item will be reduced from Source Warehouse, and stock of repack/output item will be added in the Target Warehouse.
 
-![New STE]({{docs_base_url}}/assets/img/articles/Selection_072.png)
+<img alt="Repack Stock Entry" class="screenshot" src="{{docs_base_url}}/assets/img/articles/repack-2.png">
 
 <!-- markdown --> 
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/serial-no-naming.md b/erpnext/docs/user/manual/en/stock/articles/serial-no-naming.md
index c4e8774..4f2425f 100644
--- a/erpnext/docs/user/manual/en/stock/articles/serial-no-naming.md
+++ b/erpnext/docs/user/manual/en/stock/articles/serial-no-naming.md
@@ -1,26 +1,24 @@
-<h1>Serial No. Naming</h1>
+#Serial No. Naming
 
-<h1>Serial No. Naming</h1>
+Serial Nos. is unique value assigned on each unit of an item. Serial no. helps in tracking item's warranty and expiry details. Generally high value items like machines, computers, costly equipments are serialized.
 
-Serial Nos. are unique value assigned on each unit of an item. Serial no. helps in locating and tracking item's warranty and expiry details.
-
-To make item Serialized, in the Item master, on selecting **Has Serial No** field should be updated as "Yes".
+To make item Serialized, in the Item master, check **Has Serial No**.
 
 There are two ways Serial no. can be generated in ERPNext.
 
 ###1. Serializing Purchase Items
 
-If purchased items are received with Serial Nos. applied by OEM (original equipment manufacturer), you should follow this approach. While creating Purchase Receipt, you shall scan or manually enter Serial nos. for an item. On submitting Purchase Receipt, Serial Nos. will be created in the backend as per Serial No. entered for an item.
+If purchased items are received with Serial Nos. applied by OEM (original equipment manufacturer), you can follow same Serial No in ERPNext as well. While creating Purchase Receipt, you shall scan or manually enter Serial nos. for an item. On submitting Purchase Receipt, Serial Nos. will be created in the backend as per Serial Nos. provided for an item. If using OEM' Serial No., then in the Item master, Prefix should not be mentioned for serializalization. As per this scenaio, Prefix field should be left blank.
 
 If received items already has its Serial No. barcoded, you can simply scan that barcode for entering Serial No. in the Purchase Receipt. Click [here](https://frappe.io/blog/management/using-barcodes-to-ease-data-entry) to learn more about it.
 
 On submission of Purchase Receipt or Stock entry for the serialized item, Serial Nos. will be auto-generated.
 
-![Serial Nos]({{docs_base_url}}/assets/img/articles/Selection_061.png)
+<img alt="Serial Nos Entry" class="screenshot" src="{{docs_base_url}}/assets/img/articles/serial-naming-1.png">
 
 Generated Serial numbers will be updated for each item.
 
-![Serial Nos]({{docs_base_url}}/assets/img/articles/Selection_062.png)
+<img alt="Serial Nos Created" class="screenshot" src="{{docs_base_url}}/assets/img/articles/serial-naming-2.png">
 
 ###2. Serializing Manufacturing Item
 
@@ -30,12 +28,12 @@
 
 When Item is set as serialized, it will allow you to mentioned Series for it.
 
-![Item Serial No. Series]({{docs_base_url}}/assets/img/articles/Selection_049.png)
+<img alt="Serial Nos Created" class="screenshot" src="{{docs_base_url}}/assets/img/articles/serial-naming-3.png">
 
 ####2.2 Production Entry for Serialized Item
 
 On submission of production entry for manufacturing item, system will automatically generate Serial Nos. following Series as specified in the Item master.
 
-![Serial No]({{docs_base_url}}/assets/img/articles/Selection_054.png)
+<img alt="Serial Nos Created" class="screenshot" src="{{docs_base_url}}/assets/img/articles/serial-naming-4.png">
 
 <!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/stock-entry-purpose.md b/erpnext/docs/user/manual/en/stock/articles/stock-entry-purpose.md
index 26b6346..426328e 100644
--- a/erpnext/docs/user/manual/en/stock/articles/stock-entry-purpose.md
+++ b/erpnext/docs/user/manual/en/stock/articles/stock-entry-purpose.md
@@ -1,53 +1,49 @@
-<h1>Stock Entry Purpose</h1>
+#Stock Entry Purpose
 
-<h1>Stock Entry Purpose</h1>
+Stock Entry is a stock transaction, which can be used for multiple purposes. Let's learn about each Stock Entry Purpose below.
 
-Stock Entry document records Item movement from a Warehouse, to a Warehouse and between Warehouses. And in stock entry form selection of 'Purpose' belongs to type of item movement. Following are the uses of Stock Entry Purposes in stock entry form.
+#### 1.Purpose: Material Issue
 
-#### 1.Purpose = Material Issue
+Material Issue entry create to issue item(s) from a warehouse. On submission of Material Issue, stock of item is deducated from the Source Warehouse. 
 
-This purpose is selected to issue item from a warehouse. In this stock entry, you should define Source Warehouse only. This type of stock entry can be perform for adjustment of serialized inventory.
+Material Issue is generally made for the low value consumable items like office stationary, product consumables etc. Also you can create Material Issue to reconcile serialized and batched item's stock.
 
-![Material Issue]({{docs_base_url}}/assets/img/articles/Selection_440.png)
+<img alt="Material Issue" class="screenshot" src="{{docs_base_url}}/assets/img/articles/stock-entry-issue.png">
 
-#### 2.Purpose = Material Receipt
+#### 2.Purpose: Material Receipt
 
-This purpose is selected to receive item in a warehouse. In this stock entry, you should define Target Warehouse only. This type of stock entry can be perform for adjustment of serialized inventory.
+Material Receipt entry is created to inward stock of item(s) in a warehouse. This type of stock entry can be created for updating opening balance of serialized and batched item. Also items purchased without Purchase Order can be inwarded from Material Receipt entry.
 
-![Material Receipt]({{docs_base_url}}/assets/img/articles/Selection_442.png)
+For the stock valuation purpose, provided Item Valuation becomes a mandatory field in the Material Receipt entry.
 
-#### 3.Purpose = Material Transfer
+<img alt="Material Receipt" class="screenshot" src="{{docs_base_url}}/assets/img/articles/stock-entry-receipt.png">
 
-This purpose is selected to transfer item from warehouse to warehouse or to transfer raw material for production. In this stock entry, you should define Source Warehouse and Target Warehouse also.
+#### 3.Purpose: Material Transfer
 
-![Material Transfer]({{docs_base_url}}/assets/img/articles/Selection_443.png)
+Material Transfer entry is created for the inter-warehouse Material Transfer.
+
+<img alt="Material Transfer" class="screenshot" src="{{docs_base_url}}/assets/img/articles/stock-entry-transfer.png">
  
-#### 4.Purpose = Manufacture
+#### 4.Purpose: Material Transfer for Manufacture 
 
-This purpose is selected to perform finished goods entry. This purpose is auto selected in stock entry form, when you Update Finished Goods entry from Submitted Production Order. ![Check this page to know more about Manufacturing](https://erpnext.com/user-guide/guide-books/engineer-to-order/stock-entry)
+In the manufacturing process, raw-materials are issued from the stores to the production department (generally WIP warehouse). This Material Transfer entry is created from Production Order. Items in this entry are fetched from the BOM of production Item, as selected in Production Order.
 
-![Manufacture]({{docs_base_url}}/assets/img/articles/Selection_444.png) 
+<img alt="Transfer for Manufacture" class="screenshot" src="{{docs_base_url}}/assets/img/articles/stock-entry-manufacture-transfer.gif">
 
-#### 5.Purpose = Repack
+#### 4.Purpose: Manufacture
 
-This purpose is selected to perform repack of item. ![Check this page to know more about Repack entry](https://erpnext.com/kb/stock/repack-entry)
+Manufacture is created from Production Order. In this entry, both raw-material item as well as production item are fetched from the BOM, selected in the Production Order. For the raw-material items, only Source Warehouse (generally WIP warehouse) is mentioned. For the production item, only target warehouse as mentioned in the Production Order is updated. On submission, stock of raw-material items are deducted from Source Warehouse, which indicates that raw-material items were consumed in the manufacturing process. Production Item is added to the Target Warehouse marking the completion of production cycle.
 
-#### 6.Purpose = Subcontract
+<img alt="Manufacture" class="screenshot" src="{{docs_base_url}}/assets/img/articles/stock-entry-manufacture.gif">
 
-This purpose is selected to transfer row material to supplier for manufacturing subcontracting item.![Check this page to know more about Subcontracting](https://erpnext.com/user-guide/manufacturing/subcontracting)
+#### 5.Purpose: Repack
 
-![Subcontract]({{docs_base_url}}/assets/img/articles/Selection_445.png)
+Repack Entry is created when items purchases in bulk is repacked under smaller packs. ![Check this page to know more about Repack entry.]({{docs_base_url}}/user/manual/en/stock/articles/repack-entry.html)
 
-#### 6.Purpose = Sales Return
+#### 6.Purpose: Subcontract
 
-This purpose is selected to receive returned item by customer. ![Check this page to know more about Sales Return](https://erpnext.com/user-guide/stock/sales-return)
+Subcontracting transaction involves company transfer raw-material items to the sub-contractors warehouse. This requires adding a warehouse for the sub-contractor as well. Sub-contract entry transfers stock from the companies warehouse to the sub-contractors warehouse.![Check this page to know more about Subcontracting]({{docs_base_url}}/user/manual/en/manufacturing/subcontracting.html).
 
-![Sales Return]({{docs_base_url}}/assets/img/articles/Selection_446.png)
+<img alt="Subcontract" class="screenshot" src="{{docs_base_url}}/assets/img/articles/stock-entry-subcontract.gif">
 
-#### 6.Purpose = Purchase Return
-
-This purpose is selected to issue purchased item to supplier. ![Check this page to know more about Purchase Return](https://erpnext.com/user-guide/stock/purchase-return)
-
-![Purchase Return]({{docs_base_url}}/assets/img/articles/Selection_447.png)
-        
 <!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/stock-level-report.md b/erpnext/docs/user/manual/en/stock/articles/stock-level-report.md
index fa92612..b674470 100644
--- a/erpnext/docs/user/manual/en/stock/articles/stock-level-report.md
+++ b/erpnext/docs/user/manual/en/stock/articles/stock-level-report.md
@@ -1,6 +1,4 @@
-<h1>Stock Level Report</h1>
-
-<h1>Stock Level Report</h1>
+#Stock Level Report
 
 Stock Level report list stock item's quantity available in a particular warehouse.
 
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 5b0d99a..c880dfb 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
@@ -1,20 +1,21 @@
-<h1>Track items using Barcode</h1>
+#Track Items Using Barcode
 
-A barcode, is a code using multiple lines and spaces of varying widths, designed to represent some alpha-numeric characters. For example, in retail, it generally represents item code / serial number. Most barcode scanners behave like an external keyboard. When it scans a barcode, the data appears in the computer screens at the point of cursor.
+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 `Setup –> Customize –> Features Setup` and check "Item Barcode" option.
-![Features Setup]({{docs_base_url}}/assets/img/articles/feature-setup-barcode.png)
+To enable barcode feature in ERPNext go to:
 
-Now, a new field "Barcode" will be appear in Item master, enter barcode while creating a new item. You can update barcode field for existing items using "Data Import Tool".
+`Setup > Customize > Features Setup`
 
-If you are creating your own barcode, then you should print those same barcodes and attach to your products.
-![Item Barcode]({{docs_base_url}}/assets/img/articles/item-barcode.png)
+Check "Item Barcode".
 
+<img alt="Material Transfer" class="screenshot" src="{{docs_base_url}}/assets/img/articles/barcode-feature-setup.png">
 
-Once you have updated barcode field in item master, you can fetch items using barcode in Delivery Note, Sales Invoice and Purchase Receipt document.
+Now a new field "Barcode" will be appear in Item master. Enter barcode while creating a new item.
 
-For example, in Delivery Note Item table, a new field "Barcode" will be appear and if you point your mouse cursor to that field and scan the barcode using Barcode Scanner, the code will appear in that field. At the same time, system will pull item details, based on the barcode.
-![Delivery Note Barcode]({{docs_base_url}}/assets/img/articles/delivery-note-barcode.png)
+<img alt="Material Transfer" class="screenshot" src="{{docs_base_url}}/assets/img/articles/barcode-item-master.png">
 
+Once barcode field is updated in item master, items can be fetched using barcode. This feature will be availble in Delivery Note, Sales Invoice and Purchase Receipt transactions only.
+
+<img alt="Material Transfer" class="screenshot" src="{{docs_base_url}}/assets/img/articles/barcode-item-selection.gif">
 
 <!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/using-batch-feature-in-stock-entry.md b/erpnext/docs/user/manual/en/stock/articles/using-batch-feature-in-stock-entry.md
deleted file mode 100644
index eeb5cdf..0000000
--- a/erpnext/docs/user/manual/en/stock/articles/using-batch-feature-in-stock-entry.md
+++ /dev/null
@@ -1,13 +0,0 @@
-<h1>Using Batch feature in Stock Entry.</h1>
-
-1. You need to first create an Item Master Record. You can do so by typing 'new Item' in the Awesome bar.
-    <img class="screenshot" src="{{docs_base_url}}/assets/img/articles/Screenshot from 2014-11-18 17:56:19.png">
-2. In the Item Master fill in all item related details. In the 'Inventory' section select 'Has Batch No.' as 'YES'
-    <img  class="screenshot" src="{{docs_base_url}}/assets/img/articles/Screenshot from 2014-11-18 18:00:57.png">
-    NOTE: This option can be changed after submit but only as long as there are no Stock Entries created against that Item. Once an Stock Entry is created against that item this field freezes. To modify it again you need to cancel all outstanding 'Stock Entries'
-3. You can then create a batch. To do so you can type 'new Batch' in the Awesome bar.
-4. Fill in the batch related details and save the Doc.
-    <img  class="screenshot"
-     src="{{docs_base_url}}/assets/img/articles/Screenshot from 2014-11-18 18:09:42.png">
-5. Now in Stock Transaction You can associate a batch against that item under the 'Serial No / Batch' Section.<br>
-    <img  class="screenshot" src="{{docs_base_url}}/assets/img/articles/Screenshot from 2014-11-18 18:13:22.png"><br></div>
diff --git a/erpnext/docs/user/videos/index.md b/erpnext/docs/user/videos/index.md
index dcefe84..1399258 100644
--- a/erpnext/docs/user/videos/index.md
+++ b/erpnext/docs/user/videos/index.md
@@ -32,4 +32,4 @@
         <br><br>
 		<a href="https://conf.erpnext.com">Join us at the ERPNext Conference on October 9th 2015 in Mumbai</a>
     </div>
-</div>
+</div>
\ No newline at end of file
