diff --git a/docs/user/docs.user.md b/docs/user/docs.user.md
index c45ca30..098fd89 100644
--- a/docs/user/docs.user.md
+++ b/docs/user/docs.user.md
@@ -3,6 +3,7 @@
 	"_label": "User Guide",
 	"_toc": [
 		"docs.user.intro",
+		"docs.user.five",
 		"docs.user.implement",
 		"docs.user.setup",
 		"docs.user.selling",
@@ -17,7 +18,7 @@
 		"docs.user.tools",
 		"docs.user.customize",
 		"docs.user.knowledge"
-	],
+			],
 	"_no_toc": 1
 }
 ---
@@ -29,6 +30,10 @@
 	1. [Open Source](docs.user.intro.open_source.html)
 	1. [Ways to get started](docs.user.intro.try.html)
 	1. [Getting Help](docs.user.help.html)
+1. [Five-Day-Setup](docs.user.five.html)
+	1. [Day-1](docs.user.five.day_1.html)
+	1. [Day-2](docs.user.five.day_2.html)
+	1. [Day-3](docs.user.five.day_3.html)
 1. [Implementation](docs.user.implement.html)
 	1. [Implementation Strategy](docs.user.implement.strategy.html)
 	1. [Concepts](docs.user.implement.concepts.html)
@@ -154,4 +159,3 @@
 	1. [DocType Definitions](docs.user.knowledge.doctype.html)
 	1. [Attachment and CSV Files](docs.user.knowledge.attachment_csv.html)
 	1. [Format using Markdown](docs.user.knowledge.markdown.html)
-	
diff --git a/docs/user/five_step_setup/docs.user.five.day_1.md b/docs/user/five_step_setup/docs.user.five.day_1.md
new file mode 100644
index 0000000..d6786b4
--- /dev/null
+++ b/docs/user/five_step_setup/docs.user.five.day_1.md
@@ -0,0 +1,85 @@
+---
+{
+	"_label": "Day-1"
+}
+---
+Login to your ERPNext account with the User ID and Password sent through the mail.
+
+After logging into your account you will receive a pop-up form to fill. Please fill this form. Select the abbreviation you would wish to have for your company. The abbreviation selected here will be used in naming most of the business documents.
+
+#### Form Part I
+
+![1st Form](img/firstdaysetup_1.png)
+<br>
+#### Form Part II
+<br>
+
+To understand about Company Financial Year or Fiscal Year visit [Fiscal Year](docs.user.knowledge.fiscal_year.html)
+
+
+![1st Form](img/firstdaysetup_2.png)
+
+After filling this form, you will get a pop-up message for completing the  set-up process. Click on the Setup button. The Setup page will appear.
+
+<br>
+#### Setup Page - Customer
+
+The Organisation details are updated in ERPNext, after filling the first form. Go directly to the Customer Icon.
+
+![Customer](img/firstdaysetup_customer.png)
+<br>
+
+
+After clicking on Customer, a new form will appear. 
+<br>
+
+![Customer](img/firstdaysetup_customer_1.png)
+
+To see how customer details are added, visit [Customer](docs.user.selling.customer.html). Create 5 new customer records in the system. 
+
+Now proceed to make an Item. To go to the main menu, click on erpnext icon which is on the left hand corner of the page. On the main menu page, click on Setup
+
+![Main Menu](img/firstdaysetup_main_menu.png)
+
+<br>
+
+#### Setup Page - Item
+
+On the setup page go to Item.
+
+
+![Item](img/firstdaysetup_item.png)
+
+
+Create a new Item. An Item is your company's product or a service.The term Item is applicable to your core products as well as your raw materials. It can be a product or service that you buy/sell from your customers/ suppliers.
+
+Filling Item details is an important step in ERPNext. Do not postpone this step. After clicking on Item, make a new Item.
+
+![Item](img/firstdaysetup_item_1.png)
+
+To understand how to fill an Item in detail, visit [Item](docs.user.stock.item.html). Add 5 item records to ERPnext. After adding these records, go back to the Setup Page and add Suppliers.
+
+<br>
+#### Setup Page - Suppliers
+<br>
+
+On the Setup page go to Supplier.
+
+![Supplier](img/firstdaysetup_supplier.png)
+<br>
+
+Suppliers are companies or individuals who provide you with products or services. They are treated in exactly the same manner as Customers in ERPNext. Create a new Supplier record.
+
+![Supplier](img/firstdaysetup_supplier_1.png)
+
+
+To understand how to fill Supplier details, visit [Supplier](docs.user.buying.supplier.html). 
+
+If you wish to import your list of customers and suppliers directly to ERPNext, you can do that via the Data Import Tool.
+
+To upload Customers or suppliers in bulk, go to the Data Import Tool.
+
+> Note: The data import format is case-sensitive. The file will not be processed if there are any spelling mistakes or deviations from the default values.
+
+To understand how to import data, visit [Importing Data](docs.user.setup.data_import.html).
+
diff --git a/docs/user/five_step_setup/docs.user.five.day_2.md b/docs/user/five_step_setup/docs.user.five.day_2.md
new file mode 100644
index 0000000..c1a5d28
--- /dev/null
+++ b/docs/user/five_step_setup/docs.user.five.day_2.md
@@ -0,0 +1,53 @@
+---
+{
+	"_label": "Day-2"
+}
+---
+
+#### Setup Page- Accounts 
+
+Go to the Accounts icon and make ledgers under Chart of Accounts.
+
+![Accounts](img/seconddaysetup_accounts.png)
+
+<br>
+
+
+Create acccounting ledgers.
+
+![Tree](img/seconddaysetup_tree.png)
+
+<br>
+
+To begin Opening Entries, go to 'Opening Accounts and Stock' on the Setup Page. 
+
+<br>
+
+![Ledger](img/seconddaysetup_accounts_jv.png)
+
+<br>
+
+
+To understand how to create opening entries in detail visit [Opening Entry](docs.user.setup.opening.html).
+
+#### Opening Stock
+
+You can upload your opening stock in the system using Stock Reconciliation. Stock Reconciliation will update your stock for any given Item. 
+
+![Stock Opening](img/seconddaysetup_stock_opening.png)
+<br>
+
+
+To understand Stock Opening in detail visit [Opening Stock](docs.user.accounts.opening_stock.html).
+
+
+#### Setup Page - HR Setup
+
+To setup HR, begin by creating individual employee records.
+
+
+![Employee](img/seconddaysetup_hr.png)
+
+To fill the Employee Form, refer to [Employee](docs.user.hr.employee.html)
+
+To complete the remaining HR-Setup, see [Human Resources](docs.user.hr.html)
\ No newline at end of file
diff --git a/docs/user/five_step_setup/docs.user.five.day_3.md b/docs/user/five_step_setup/docs.user.five.day_3.md
new file mode 100644
index 0000000..09a5d3f
--- /dev/null
+++ b/docs/user/five_step_setup/docs.user.five.day_3.md
@@ -0,0 +1,135 @@
+---
+{
+	"_label": "Day-3"
+}
+---
+After completing the set-up and account opening process, it is advisable  to complete a few cycles of sales, purchase, and manufacturing process.
+
+
+### Sales Cycle
+
+Complete a standard sales cycle - Lead > Opportunity > Quotation > Sales Order > Delivery Note > Sales Invoice > Payment (Journal Voucher)
+
+#### Lead
+
+To begin the sales cycle, go to the Selling Icon. On the selling page, click on Lead. 
+
+![Lead](img/thirddaysetup_lead.png)
+
+Fill the Lead form.
+
+> To understand Lead in detail, visit [Lead](docs.user.selling.lead.html)
+
+#### Opportunity
+
+After completing the Lead form, assume that, this same lead is getting converted into an Opportunity. Thus, to create an Opportunity from the existing lead, click on Create Opportunity, on the Lead page.
+
+##### Step 1: Go to 'Lead List' Page and open the Lead that shows interested status.
+
+![Opportunity](img/thirddaysetup_opportunity_1.png)
+
+<br>
+
+##### Step 2: Generate Opportunity from the selected Lead
+
+![Opportunity](img/thirddaysetup_opportunity.png)
+
+You can also generate an Opportunity directly from the Selling Page.
+
+> To understand Opportunity in detail visit [Opportunity](docs.user.selling.opportunity.html).
+
+
+#### Quotation
+
+Imagine that your Opportunity has shown interest and asked for a Quotation. To generate a Quotation from the same Opportunity, open the submitted Opportunity and click on Create Quotation.
+
+![Quotation](img/thirddaysetup_quotation.png)
+
+You can also generate a Quotation directly from the Selling Page.
+
+> To understand Quotation in detail visit [Quotation](docs.user.selling.quotation.html)
+
+
+#### Sales Order
+
+Imagine that the Quotation which you sent was accepted by the prospect. You are now  reequired to send him a Sales Order. To make a sales order from this same Quotation, go to that Quotation page and click on Make Sales Order.
+
+![Sales Order](img/thirddaysetup_sales_order.png)
+
+You can also generate a Sales Order directly from the Selling Page.
+
+> To understand Sales Order in detail visit [Sales Order](docs.user.selling.sales_order.html).
+
+#### Delivery Note
+
+If your organisation has the practice of sending Delivery Note, this section will be helpful. To create a Delivery Note from the a Sales Order, go to that Sales Order and click on Make Delivery.
+
+
+![Delivery Note](img/thirddaysetup_delivery_note.png)
+
+> To understand Delivery Note in detail, visit [Delivery Note](docs.user.stock.delivery_note.html)
+
+
+#### Sales Invoice
+
+Save and Submit your Delivery Note to generate a Sales Invoice. You can also generate an Invoice from Sales Order.
+
+![Sales Invoice](img/thirddaysetup_sales_invoice.png)
+
+<br>
+
+#### Payment (Journal Voucher)
+
+
+A Journal Voucher or a payment entry can be generated directly from the Sales Invoice.
+
+![Payment Entry](img/thirddaysetup_payment_entry.png)
+
+> To understand a Journal Voucher in detail, visit [Journal Voucher](docs.user.accounts.journal_voucher.html)
+
+<br>
+
+### Purchase Cycle
+
+Complete a standard purchase cycle - Material Request > Purchase Order > Purchase Receipt > Payment (Journal Voucher).
+
+
+#### Material Request
+
+To create a Material Request, go to Stock/Buying and Click on Material Request.
+
+![Material Request](img/thirddaysetup-material-request.png)
+
+> To understand Material Request in detail, visit [Material Request](docs.user.buying.material_request.html)
+
+#### Purchase Order
+
+To create a Purchase Order go to Buying and click on Purchase Order
+
+![Purchase Order](img/thirddaysetup-purchase-order.png)
+
+> To understand Purchase Order in detail, visit [Purchase Order](docs.user.buying.purchase_order.html)
+
+#### Purchase Receipt
+
+To create a Purchase Receipt from an existing Purchase Order, open that purchase order and click on Make Purchase Receipt.
+
+![Purchase Receipt](img/thirddaysetup-purchase-receipt.png)
+
+<br>
+
+>To understand Purchase Receipt in detail, visit [Purchase Receipt](docs.user.stock.purchase_receipt.html)
+
+<br>
+
+#### Payment( Journal Voucher)
+
+Payments made against Sales Invoices or Purchase Invoices can be made by clicking on “Make Payment Entry” button on “Submitted” invoices.
+
+
+![Payment Entry](img/thirddaysetup-payment-entry.png)
+
+<br>
+
+> To understand Payment Entry in detail, visit [Payment Entry](docs.user.accounts.payments.html).
+
diff --git a/docs/user/five_step_setup/docs.user.five.md b/docs/user/five_step_setup/docs.user.five.md
new file mode 100644
index 0000000..14b761b
--- /dev/null
+++ b/docs/user/five_step_setup/docs.user.five.md
@@ -0,0 +1,48 @@
+---
+{
+	"_label": "Five-Day Setup",
+	"_toc": [
+		"docs.user.five.day_1",
+		"docs.user.five.day_2",
+		"docs.user.five.day_3"
+			
+	]
+}
+---
+Welcome to ERPNext. To be able to setup ERPNext account successfully, a five-day-setup process is recommended. Perform the 5-days-setup instructions and sail through the ERPNext implementation.
+
+The setup help is divided into day-wise instructions for 5 consecutive days. Day 1 will  cover the following topics:
+
+#### Day 1
+
+- Company Setup
+- Customer Setup
+- Item Setup
+- Supplier Setup
+- Data Import Tool
+
+#### Day 2
+
+- Opening Accounts 
+- Opening Stock
+- HR Setup
+
+#### Day 3
+
+- Sales Cycle
+- Purchase Cycle
+
+	
+
+#### Day 4
+
+- Manufacturing Cycle
+- Fulfillment Cycle- Inventory, Delivery Note, Warehouse etc
+- Accounts
+
+#### Day 5
+
+- Billing
+- Payments
+- HR Reports
+
diff --git a/docs/user/intro/docs.user.implement.strategy.md b/docs/user/intro/docs.user.implement.strategy.md
index 9ec58e8..8f05af7 100644
--- a/docs/user/intro/docs.user.implement.strategy.md
+++ b/docs/user/intro/docs.user.implement.strategy.md
@@ -13,7 +13,7 @@
 - Create your first Customer, Supplier and Item. Add a few more so you get familiar with them.
 - Create Customer Groups, Item Groups, Warehouses, Supplier Groups, so that you can classify your Items.
 - Complete a standard sales cycle - Lead > Opportunity > Quotation > Sales Order > Delivery Note > Sales Invoice > Payment (Journal Voucher)
-- Complete a standard purchase cycle - Purchase Request > Purchase Order > Purchase Receipt > Payment (Journal Voucher).
+- Complete a standard purchase cycle - Material Request > Purchase Order > Purchase Receipt > Payment (Journal Voucher).
 - Complete a manufacturing cycle (if applicable) - BOM > Production Planning Tool > Production Order > Stock Entry (issue) > Stock Entry (back-flush)
 
 > Tip: Use the 30-day free trial at [erpnext.com](https://erpnext.com) to take your test drive.
diff --git a/docs/user/setup/docs.user.setup.cost_centers.md b/docs/user/setup/docs.user.setup.cost_centers.md
index 3df26e1..d666e41 100644
--- a/docs/user/setup/docs.user.setup.cost_centers.md
+++ b/docs/user/setup/docs.user.setup.cost_centers.md
@@ -45,6 +45,14 @@
 Budgets are also great for planning purposes. When you are making plans for the next financial year, you would typically target a revenue based on which you would set your expenses. Setting a budget will ensure that your expenses do not get out of hand, at any point, as per your plans.
 
 You can define it in the Cost Center. If you have seasonal sales you can also define a budget distribution that the budget will follow.
+
+> Accounts > Budget Distribution > New Budget Distribution
+
+
+![Budget Distribution](img/budgeting.png)
+
+
+
 ￼
 #### Budget Actions
 
diff --git a/docs/user/setup/docs.user.setup.users.md b/docs/user/setup/docs.user.setup.users.md
index 82d79d3..06ac910 100644
--- a/docs/user/setup/docs.user.setup.users.md
+++ b/docs/user/setup/docs.user.setup.users.md
@@ -6,7 +6,7 @@
 
 ERPNext has a role-based permission system, which means that you can assign Roles to Users, and permissions on Roles.Each ERPNext user has a Profile. The Profile contains the user’s email and authentication and can be set from:
 
-> Setup > Users and Permissions > Users
+> Setup > Profile
 
 #### Step 1: Adding a new User
 
diff --git a/docs/user/stock/docs.user.stock.item.md b/docs/user/stock/docs.user.stock.item.md
index 5ac78d7..76a83a2 100644
--- a/docs/user/stock/docs.user.stock.item.md
+++ b/docs/user/stock/docs.user.stock.item.md
@@ -15,7 +15,7 @@
 
 - **Item Name:** Item name is the actual name of your product or service.
 - **Item Code:** Item Code is a short-form to denote your Item. If you have very few Items, it is advisable to keep the Item Name and the Item Code same. This helps new users to recognise and update Item details in all transactions. In case you have lot of Items with long names and the list runs in hundreds, it is advisable to code. To understand naming Item codes see [Item Codification](docs.user.setup.codification.html)
-- **Item Group:** Item Group is used to categorize an Item under various criterias like products, raw materials, services, sub-assemblies, consumables or all Item groups. Create your default Item Group list under Setup> Item Group and pre-select the option while filling your New Item details under Item Group.
+- **Item Group:** Item Group is used to categorize an Item under various criterias like products, raw materials, services, sub-assemblies, consumables or all Item groups. Create your default Item Group list under Setup> Item Group and pre-select the option while filling your New Item details under [Item Group](docs.user.stock.item_group.html)
 - **Default Unit of Measure:** This is the default measuring unit that you will use for your product. It could be in nos, kgs, meters, etc. You can store all the UOM’s that your product will require under Set Up> Master Data > UOM. These can be preselected while filling New Item by using % sign to get a pop up of the UOM list. 
 - **Brand:** If you have more than one brand save them under Set Up> Master Data> Brand and pre-select them while filling a New Item.
 
