diff --git a/erpnext/docs/user/guides/CRM/.txt b/erpnext/docs/user/guides/CRM/.txt
deleted file mode 100644
index e69de29..0000000
--- a/erpnext/docs/user/guides/CRM/.txt
+++ /dev/null
diff --git a/erpnext/docs/user/guides/CRM/setup/campaign.md b/erpnext/docs/user/guides/CRM/setup/campaign.md
deleted file mode 100644
index 36b55c3..0000000
--- a/erpnext/docs/user/guides/CRM/setup/campaign.md
+++ /dev/null
@@ -1,20 +0,0 @@
-A Campaign is a full-scale implementation of a sales strategy to promote a
-product or a service. This is done in a market segment of a particular
-geographical area, to achieve specified objectives.
-
-<img class="screenshot" alt="Campaign" src="{{url_prefix}}/assets/img/crm/campaign.png">
-
-You can track [Lead]({{url_prefix}}/user/guides/crm/lead.html), [Opportunity]({{url_prefix}}/user/guides/crm/opportunity.html), [Quotation]({{url_prefix}}/user/guides/selling/quotation.html) against a campaign.
-
-###Track Leads against Campaign
-
-* To track a 'Lead' against a campaign select 'View Leads'.
-
-<img class="screenshot" alt="Campaign - View Leads" src="{{url_prefix}}/assets/img/crm/campaign-view-leads.png">
-
-* You shall get a filtered list of all leads made against that campaign.
-* You can also create new leads by clicking 'New'
-
-<img class="screenshot" alt="Campaign - New Lead" src="{{url_prefix}}/assets/img/crm/campaign-new-lead.png">
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/accounts/setup/tax-rule.md b/erpnext/docs/user/guides/accounts/setup/tax-rule.md
deleted file mode 100644
index fdbc704..0000000
--- a/erpnext/docs/user/guides/accounts/setup/tax-rule.md
+++ /dev/null
@@ -1,21 +0,0 @@
-You can define which [Tax Template]({{url_prefix}}/user/guides/setting-up/setting-up-taxes.html) must be applied on a Sales / Purchase transaction using Tax Rule.
-
-<img class="screenshot" alt="Tax Rule" src="{{url_prefix}}/assets/img/accounts/tax-rule.png">
-
-You can define Tax Rules for Sales or Purchase Taxes. 
-While making a Transaction the system will select and apply tax template based on the tax rule defined.
-The system selects Tax Rule with maximum matching Filters.
-
-Let us consider a senario to understand Tax Rule Better.
-
-Suppose we define 2 Tax Rules as below.
-
-<img class="screenshot" alt="Tax Rule" src="{{url_prefix}}/assets/img/accounts/tax-rule-1.png">
-
-<img class="screenshot" alt="Tax Rule" src="{{url_prefix}}/assets/img/accounts/tax-rule-2.png">
-
-Here Tax Rule 1 has Billing Country as India and Tax Rule 2 has Billing Country as United Kingdom
-
-Now supposed we try to create a Sales Order for a customer whose default Billing Country is India, system shall select Tax Rule 1.
-In case the customers Billing Country was United Kingdom, the system would have selected Tax Rule 2.
-
diff --git a/erpnext/docs/user/guides/customer-portal/issues.md b/erpnext/docs/user/guides/customer-portal/issues.md
deleted file mode 100644
index 478e1b9..0000000
--- a/erpnext/docs/user/guides/customer-portal/issues.md
+++ /dev/null
@@ -1,22 +0,0 @@
-The customer portal makes it very easy for a customer to raise concerns. A
-simple and intuitive interface facilitates your customer to report their
-concerns as Issues. They can view the complete thread of their
-conversation.
-
-#### Empty Ticket List
-
-![Ticket List]({{url_prefix}}/assets/old_images/erpnext/portal-ticket-list-empty.png)
-
-#### New Issue
-
-![New Ticket]({{url_prefix}}/assets/old_images/erpnext/portal-new-ticket.png)
-
-#### Open Issue
-
-![Open Issue]({{url_prefix}}/assets/old_images/erpnext/portal-ticket-1.png)
-
-#### Reply on Issue
-
-![Reply Issue]({{url_prefix}}/assets/old_images/erpnext/portal-ticket-reply.png)
-
-{next}
diff --git a/erpnext/docs/user/guides/customer-portal/sign-up.md b/erpnext/docs/user/guides/customer-portal/sign-up.md
deleted file mode 100644
index 2e95d49..0000000
--- a/erpnext/docs/user/guides/customer-portal/sign-up.md
+++ /dev/null
@@ -1,22 +0,0 @@
-Customers have to log-in to the Company Website, and sign-up as a customer.
-
-#### Step 1: Click on Login Icon
-
-![Sign Up]({{url_prefix}}/assets/old_images/erpnext/customer-portal-sign-up-1.png)
-
-  
-
-#### Step 2: Click on Sign Up Icon
-
-![Sign Up]({{url_prefix}}/assets/old_images/erpnext/customer-portal-sign-up-2.png)
-
-  
-
-#### Step 3: Enter Customer Name and ID
-
-![Sign Up]({{url_prefix}}/assets/old_images/erpnext/customer-portal-sign-up-3.png)
-
-After the sign up process, a mail will be sent to the customers email id with
-the password details.
-
-{next}
diff --git a/erpnext/docs/user/guides/human-resources/employee.md b/erpnext/docs/user/guides/human-resources/employee.md
deleted file mode 100644
index 331fe47..0000000
--- a/erpnext/docs/user/guides/human-resources/employee.md
+++ /dev/null
@@ -1,9 +0,0 @@
-There are many fields you can add in your Employee records.
-
-To create new Employee go to:
-
-> Human Resources > Employee > New
-
-<img class="screenshot" alt="Employee" src="{{url_prefix}}/assets/img/human-resources/employee.png">
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/human-resources-reports.md b/erpnext/docs/user/guides/human-resources/human-resources-reports.md
deleted file mode 100644
index 20d792b..0000000
--- a/erpnext/docs/user/guides/human-resources/human-resources-reports.md
+++ /dev/null
@@ -1,34 +0,0 @@
-Human Resources Reports
-
-### Employee Leave Balance
-
-Employee Leave Balance Report shows employees and their respective balance leaves under various leave types. Report is generated as per the number of allowed leaves.
-
-<img alt="Employee Leave Balance" class="screenshot" src="{{url_prefix}}/assets/img/human-resources/employee-leave-balance-report.png">
-
-### Employee Birthday
-
-Employee Birthday Report shows Birthdays of your employees.
-
-<img alt="Employee Birthday" class="screenshot" src="{{url_prefix}}/assets/img/human-resources/employee-birthday-report.png">
-
-### Employee Information
-
-Employee Information Report shows Report View of important information recorded in Employee master.
-
-<img alt="Employee Information" class="screenshot" src="{{url_prefix}}/assets/img/human-resources/employee-information-report.png">
-
-### Monthly Salary Register
-
-Monthly Salary Register shows net pay and its components of employee(s) at a glance.
-
-<img alt="Monthly Salary Register" class="screenshot" src="{{url_prefix}}/assets/img/human-resources/monthly-salary-register-report.png">
-
-
-### Monthly Attendance Sheet
-
-Monthly Attendance Sheet shows monthly attendance of selected employee at a glance.
-
-<img alt="Monthly Attendance Sheet" class="screenshot" src="{{url_prefix}}/assets/img/human-resources/monthly-attendance-sheet-report.png">
-
-{next}
diff --git a/erpnext/docs/user/guides/human-resources/introduction-to-human-resources.md b/erpnext/docs/user/guides/human-resources/introduction-to-human-resources.md
deleted file mode 100644
index 8d4da2f..0000000
--- a/erpnext/docs/user/guides/human-resources/introduction-to-human-resources.md
+++ /dev/null
@@ -1,11 +0,0 @@
-The Human Resources (HR) Module covers the processes linked to managing a team
-of co-workers. Most important feature here is processing the payroll by using
-Process Payroll to generate Salary Slips. Most countries have complex tax
-rules stating which expenses the company can make on behalf of the Employees.
-There are a set of rules for the company to deduct taxes and social security
-from employee payroll. ERPNext allows to accomodate all types of taxes and
-their calculation.
-
-It also maintains a complete employee database including contact information,
-salary details, attendance, performance evaluation, and appraisal records.
-
diff --git a/erpnext/docs/user/guides/human-resources/job-opening.md b/erpnext/docs/user/guides/human-resources/job-opening.md
deleted file mode 100644
index bfe914c..0000000
--- a/erpnext/docs/user/guides/human-resources/job-opening.md
+++ /dev/null
@@ -1,10 +0,0 @@
-You can make a record of the open vacancies in your company using Job Opening.
-
-To create a new Job Opening go to 
-
-> Human Resource > Job Opening > New
-
-<img class="screenshot" alt="Job Opening" src="{{url_prefix}}/assets/img/human-resources/job-opening.png">
-
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/setup/branch.md b/erpnext/docs/user/guides/human-resources/setup/branch.md
deleted file mode 100644
index 9fc71d5..0000000
--- a/erpnext/docs/user/guides/human-resources/setup/branch.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Branches of your organization
-
-<img class="screenshot" alt="Branch" src="{{url_prefix}}/assets/img/human-resources/branch.png">
-
-{next}
diff --git a/erpnext/docs/user/guides/human-resources/setup/department.md b/erpnext/docs/user/guides/human-resources/setup/department.md
deleted file mode 100644
index 8376626..0000000
--- a/erpnext/docs/user/guides/human-resources/setup/department.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Departments in your organization
-
-<img class="screenshot" alt="Department" src="{{url_prefix}}/assets/img/human-resources/department.png">
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/setup/designation.md b/erpnext/docs/user/guides/human-resources/setup/designation.md
deleted file mode 100644
index c8af106..0000000
--- a/erpnext/docs/user/guides/human-resources/setup/designation.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Designations in your organization
-
-<img class="screenshot" alt="Designation" src="{{url_prefix}}/assets/img/human-resources/designation.png">
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/setup/earning-type.md b/erpnext/docs/user/guides/human-resources/setup/earning-type.md
deleted file mode 100644
index ab97634..0000000
--- a/erpnext/docs/user/guides/human-resources/setup/earning-type.md
+++ /dev/null
@@ -1,10 +0,0 @@
-You can make a record of the Salary Components and describe it as Earning Type
-
-To create a new Earning Type
-
-> Human Resource > Setup > Earning Type > New
-
-<img class="screenshot" alt="Earning Type" src="{{url_prefix}}/assets/img/human-resources/earning-type.png">
-
-
-{next}
diff --git a/erpnext/docs/user/guides/human-resources/setup/employment-type.md b/erpnext/docs/user/guides/human-resources/setup/employment-type.md
deleted file mode 100644
index 84b6aad..0000000
--- a/erpnext/docs/user/guides/human-resources/setup/employment-type.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Various employment contracts you have with your employees.
-
-<img class="screenshot" alt="Employment Type" src="{{url_prefix}}/assets/img/human-resources/employment-type.png">
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/setup/holiday-list.md b/erpnext/docs/user/guides/human-resources/setup/holiday-list.md
deleted file mode 100644
index ea64cdf..0000000
--- a/erpnext/docs/user/guides/human-resources/setup/holiday-list.md
+++ /dev/null
@@ -1,5 +0,0 @@
-You can specify the Holidays for a particular year using Holiday List.
-
-<img class="screenshot" alt="Holiday List" src="{{url_prefix}}/assets/img/human-resources/holiday-list.png">
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/setup/hr-settings.md b/erpnext/docs/user/guides/human-resources/setup/hr-settings.md
deleted file mode 100644
index f349fc7..0000000
--- a/erpnext/docs/user/guides/human-resources/setup/hr-settings.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# HR Settings
-
-GLobal settings for HR related documents
-
-<img class="screenshot" alt="HR Settings" src="{{url_prefix}}/assets/img/human-resources/hr-settings.png">
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/setup/leave-allocation.md b/erpnext/docs/user/guides/human-resources/setup/leave-allocation.md
deleted file mode 100644
index 985b0c0..0000000
--- a/erpnext/docs/user/guides/human-resources/setup/leave-allocation.md
+++ /dev/null
@@ -1,7 +0,0 @@
-Helps you allocate Leaves to a particular Employee
-
-<img class="screenshot" alt="Leave Allocation" src="{{url_prefix}}/assets/img/human-resources/leave-allocation.png">
-
-To assign leaves to multiple employees use the [Leave Allocation Tool]({{url_prefix}}/user/guides/human-resources/tools/leave-allocation-tool.html)
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/tools/leave-allocation-tool.md b/erpnext/docs/user/guides/human-resources/tools/leave-allocation-tool.md
deleted file mode 100644
index a1fa801..0000000
--- a/erpnext/docs/user/guides/human-resources/tools/leave-allocation-tool.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Leave Allocation tool helps you allocated a specific number of leaves for your employees.
-
-<img class="screenshot" alt="Leave Application" src="{{url_prefix}}/assets/img/human-resources/leave-application.png">
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/tools/upload-attendance.md b/erpnext/docs/user/guides/human-resources/tools/upload-attendance.md
deleted file mode 100644
index 5f70933..0000000
--- a/erpnext/docs/user/guides/human-resources/tools/upload-attendance.md
+++ /dev/null
@@ -1,9 +0,0 @@
-This tool helps you to upload bulk attendence from a csv file.
-
-To upload the attendance go to:
-
-> Human Resources > Upload Attendance
-
-<img class="screenshot" alt="Attendence upload" src="{{url_prefix}}/assets/img/human-resources/attendence-upload.png">
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/index.md b/erpnext/docs/user/guides/index.md
deleted file mode 100644
index 454b4a8..0000000
--- a/erpnext/docs/user/guides/index.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# User Manual
-
-{index}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/projects/introduction-to-projects.md b/erpnext/docs/user/guides/projects/introduction-to-projects.md
deleted file mode 100644
index 85a67b9..0000000
--- a/erpnext/docs/user/guides/projects/introduction-to-projects.md
+++ /dev/null
@@ -1,10 +0,0 @@
-ERPNext helps you manage your Projects by breaking them into Tasks and
-allocating them to different people.  
-
-Purchasing and selling can also be tracked against Projects and this can help
-the company keep tabs on its budget, delivery and profitability for a Project.
-
-Projects can be used to manage internal projects, manufacturing jobs or
-service jobs. For service jobs, Time Sheets can also be created that can be
-used to bill Customers if billing is done on a Time & Money basis.
-
diff --git a/erpnext/docs/user/guides/projects/project.md b/erpnext/docs/user/guides/projects/project.md
deleted file mode 100644
index 9b265c0..0000000
--- a/erpnext/docs/user/guides/projects/project.md
+++ /dev/null
@@ -1,87 +0,0 @@
-Project management in ERPNext is Task driven. You can create Project and assign multiple Tasks against it.
-
-<img class="screenshot" alt="Project" src="{{url_prefix}}/assets/img/project/project.png">
-
-### Managing tasks
-Project can be divided into multiple Tasks.
-Task can be created via Project document itself or can be created via  [Task]({{url_prefix}}/user/guides/projects/tasks.html)
-
-<img class="screenshot" alt="Project" src="{{url_prefix}}/assets/img/project/project_task.png">
-
-* To view Task made against a Project click on 'Tasks'
-
-<img class="screenshot" alt="Project - View Task" src="{{url_prefix}}/assets/img/project/project_view_task.png">
-
-<img class="screenshot" alt="Project - Task List" src="{{url_prefix}}/assets/img/project/project_task_list.png">
-
-* You can also view the Tasks from the Project document itself
-
-<img class="screenshot" alt="Project - Task Grid" src="{{url_prefix}}/assets/img/project/project_task_grid.png">
-
-### Managing time
-
-ERPNext uses [Time Log]({{url_prefix}}/user/guides/projects/time-log.html) to track the progress of a Project.
-You can create Time Logs against each task.
-The Actual Start and End Time along with the costing shall then be updated based on the Time Log.
-
-* To view Time Log made against a Project click on 'Time Logs'
-
-<img class="screenshot" alt="Project - View Time Log" src="{{url_prefix}}/assets/img/project/project_view_time_log.png">
-
-<img class="screenshot" alt="Project - Time Log List" src="{{url_prefix}}/assets/img/project/project_time_log_list.png">
-
-* You can also create a Time Log directlly and link it to the Project.
-
-<img class="screenshot" alt="Project - Link Time Log" src="{{url_prefix}}/assets/img/project/project_time_log_link.png">
-
-### Managing expenses
-
-You can book [Expense Claim]({{url_prefix}}/user/guides/human-resources/expense-claim.html) against a project task.
-The system shall update the total amount from expense claims in the project costing section.
-
-* To view Expense Claims made against a Project click on 'Expense Claims'
-
-<img class="screenshot" alt="Project - View Expense Claim" src="{{url_prefix}}/assets/img/project/project_view_expense_claim.png">
-
-* You can also create a Expense Claims directlly and link it to the Project.
-
-<img class="screenshot" alt="Project - Link Expense Claim" src="{{url_prefix}}/assets/img/project/project_expense_claim_link.png">
-
-* Total amount of Expense Claims booked against a project is shown under 'Total Expense Claim' in the Project Costing Section
-
-<img class="screenshot" alt="Project - Total Expense Claim" src="{{url_prefix}}/assets/img/project/project_total_expense_claim.png">
-
-### Cost Center
-
-You can make a [Cost Center]({{url_prefix}}/user/guides/accounts/setup/cost-center.html) against a Project or use an existing cost center to track all expenses made against that project.
-
-<img class="screenshot" alt="Project - Cost Center" src="{{url_prefix}}/assets/img/project/project_cost_center.png">
-
-###Project Costing
-
-The Project Costing section helps you track the time and expenses incurred against the project.
-
-<img class="screenshot" alt="Project - Costing" src="{{url_prefix}}/assets/img/project/project_costing.png">
-
-* The Costing Section is updated based on Time Logs made.
-
-* Gross Margin is the difference between Total Costing Amount and Total Billing Amount
-
-###Billing
-
-You can make/link a [Sales Order]({{url_prefix}}/user/guides/selling/sales-order.html) against a project. Once linked you can use the standard sales module to bill your customer against the Project.
-
-<img class="screenshot" alt="Project - Sales Order" src="{{url_prefix}}/assets/img/project/project_sales_order.png">
-
-###Gantt Chart
-
-A Gantt Chart illustrates a project schedule.
-ERPNext gives you a illustrated view of tasks scheduled against that project in Gantt Chart View.
-
-* To view gantt chart against a project, go to that project and click on 'Gantt Chart'
-
-<img class="screenshot" alt="Project - View Gantt Chart" src="{{url_prefix}}/assets/img/project/project_view_gantt_chart.png">
-
-<img class="screenshot" alt="Project - Gantt Chart" src="{{url_prefix}}/assets/img/project/project_gantt_chart.png">
-
-{next}
diff --git a/erpnext/docs/user/guides/projects/tasks.md b/erpnext/docs/user/guides/projects/tasks.md
deleted file mode 100644
index 6ee97a0..0000000
--- a/erpnext/docs/user/guides/projects/tasks.md
+++ /dev/null
@@ -1,59 +0,0 @@
-Project is divided into Tasks. 
-In ERPNext, you can also create a Task independently.
-
-<img class="screenshot" alt="Task" src="{{url_prefix}}/assets/img/project/task.png">
-
-### Status of the Task
-
-A Task can have either of the following status - Open, Working, Pending Review, Closed, Cancelled.
-
-<img class="screenshot" alt="Task - Status" src="{{url_prefix}}/assets/img/project/task_status.png">
-
-* By default each new Task created shall have the status set to 'Open'.
-
-* If a Time Log is made against a task, its status shall be set to 'Working'.
-
-### Dependent Task
-
-You can specify a list of dependent task under the 'Depends On' section.
-
-<img class="screenshot" alt="Depends On" src="{{url_prefix}}/assets/img/project/task_depends_on.png">
-
-* You cannot close the parent Task until all 'Dependant Task' are closed.
-
-* If the Dependent Task are delayed and overlap with the expected Start Date of the Parent task, the system will reschedule the parent task.
-
-### Managing Time
-
-ERPNext uses [Time Log]({{url_prefix}}/user/guides/projects/time-log.html) to track the progress of a Task.
-You can create multiple Time Logs against each task.
-The Actual Start and End Time along with the costing shall then be updated based on the Time Log.
-
-* To view Time Log made against a Task click on 'Time Logs'
-
-<img class="screenshot" alt="Task - View Time Log" src="{{url_prefix}}/assets/img/project/task_view_time_log.png">
-
-<img class="screenshot" alt="Task - Time Log List" src="{{url_prefix}}/assets/img/project/task_time_log_list.png">
-
-* You can also create a Time Log directlly and link it to the Task.
-
-<img class="screenshot" alt="Task - Link Time Log" src="{{url_prefix}}/assets/img/project/task_time_log_link.png">
-
-### Managing Expenses
-
-You can book [Expense Claim]({{url_prefix}}/user/guides/human-resource-management/expense-claim.html) against a task.
-The system shall update the total amount from expense claims in the costing section.
-
-* To view Expense Claims made against a Task click on 'Expense Claims'
-
-<img class="screenshot" alt="Task - View Expense Claim" src="{{url_prefix}}/assets/img/project/task_view_expense_claim.png">
-
-* You can also create a Expense Claims directlly and link it to the Task.
-
-<img class="screenshot" alt="Task - Link Expense Claim" src="{{url_prefix}}/assets/img/project/task_expense_claim_link.png">
-
-* Total amount of Expense Claims booked against a task is shown under 'Total Expense Claim' in the Task Costing Section
-
-<img class="screenshot" alt="Task - Total Expense Claim" src="{{url_prefix}}/assets/img/project/task_total_expense_claim.png">
-
-{next}
diff --git a/erpnext/docs/user/guides/selling/setup/index.txt b/erpnext/docs/user/guides/selling/setup/index.txt
deleted file mode 100644
index 245c1a9..0000000
--- a/erpnext/docs/user/guides/selling/setup/index.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-selling-settings
-sales-partner
-shipping-rule
-product-bundle
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/setting-up/email/index.txt b/erpnext/docs/user/guides/setting-up/email/index.txt
deleted file mode 100644
index 01061d0..0000000
--- a/erpnext/docs/user/guides/setting-up/email/index.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-email-account
-email-alerts
-email-digest
-sending-email
diff --git a/erpnext/docs/user/guides/setting-up/email/sending-email.md b/erpnext/docs/user/guides/setting-up/email/sending-email.md
deleted file mode 100644
index 61a76c5..0000000
--- a/erpnext/docs/user/guides/setting-up/email/sending-email.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# Sending Email from any Document
-
-In ERPNext you can send any document as email (with a PDF attachment) by clicking on `Menu > Email` from any open document.
-
-<img class="screenshot" alt="Send Email" src="{{url_prefix}}/assets/img/setup/email/send-email.gif">
-
-**Note:** You must have outgoing [email accounts]({{url_prefix}}/user/guides/setting-up/email/email-account.html) setup for this.
-
-{next}
diff --git a/erpnext/docs/user/guides/setting-up/setup-wizard/step-9-suppliers.md b/erpnext/docs/user/guides/setting-up/setup-wizard/step-9-suppliers.md
deleted file mode 100644
index 48bca94..0000000
--- a/erpnext/docs/user/guides/setting-up/setup-wizard/step-9-suppliers.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# Step 8: Suppliers
-
-Enter a few of your Suppliers' names.
-
-<img alt="Suppliers" class="screenshot"
-src="{{url_prefix}}/assets/img/setup-wizard/step-9.png">
-
----
-
-To understand Suppliers in detail visit [Supplier Master]({{url_prefix}}/user/guides/buying/supplier-master.html)
-
-{next}
diff --git a/erpnext/docs/user/guides/stock/installation-note.md b/erpnext/docs/user/guides/stock/installation-note.md
deleted file mode 100644
index c4e3bc0..0000000
--- a/erpnext/docs/user/guides/stock/installation-note.md
+++ /dev/null
@@ -1,5 +0,0 @@
-You can use installation note to record the instalation of a product having a serial number.
-
-<img class="screenshot" alt="Installation Note" src="{{url_prefix}}/assets/img/stock/installation-note.png">
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/stock/item-price.md b/erpnext/docs/user/guides/stock/item-price.md
deleted file mode 100644
index a235341..0000000
--- a/erpnext/docs/user/guides/stock/item-price.md
+++ /dev/null
@@ -1,43 +0,0 @@
-Item Price is the record in which you can log sellig and buying rate of an item.
-
-There are two ways to reach to new Item Price form.
-
-> Selling/Buying/Stock >> Setup >> Item Price >> New Item Price
-
-Or
-
-> Item >> Add/Edit Prices >> Click on "+"  >> New Item Price
-
-Following are the steps to create new Item Price.
-
-Step 1: Select Price List
-
-You can create multiple Price List in ERPNext to track Selling and Buying Price List of an item separtely. Also if item's selling prices id changing based on territory, or due to other criteria, you can create multiple selling Price List for it.
-
-![Item Price list]({{url_prefix}}/assets/old_images/erpnext/item-price-list.png)
-
-On selection of Price List, its currency and for selling or buying property will be fetched as well.
-
-To have Item Price fetching in the sales or purchase transaction, you should have Price List id selected in the transaction, just above Item table.
-
-Step 2: Select Item
-
-Select item for which Item Price record is to be created. On selection of Item Code, Item Name and Description will be fetched as well.
-
-![Item Price Item]({{url_prefix}}/assets/old_images/erpnext/item-price-item.png)
-
-Step 3: Enter Rate
-
-Enter selling/buying rate of an item in Price List currency.
-
-![Item Price Rate]({{url_prefix}}/assets/old_images/erpnext/item-price-rate.png)
-
-Step 4: Save Item Price
-
-To check all Item Price together, go to:
-
-Stock >> Main Report >> Itemwise Price List Rate
-
-You will find option to create new Item Price record (+) in this report as well.
-
-{next}
diff --git a/erpnext/docs/user/guides/stock/item/index.txt b/erpnext/docs/user/guides/stock/item/index.txt
deleted file mode 100644
index deaa805..0000000
--- a/erpnext/docs/user/guides/stock/item/index.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-item-codification
-item-variants
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/stock/setup/item-attribute.md b/erpnext/docs/user/guides/stock/setup/item-attribute.md
deleted file mode 100644
index a39c9ee..0000000
--- a/erpnext/docs/user/guides/stock/setup/item-attribute.md
+++ /dev/null
@@ -1,16 +0,0 @@
-You can define Attributes and attribute values for your Item Variants here.
-
-<img class="screenshot" alt="Attribute Master" src="{{url_prefix}}/assets/img/stock/item-attribute.png">
-
-#### Non Numeric Attributes
-
-* For Non Numeric Attributes, specify attributes values along with its abbreviation in the Attribute Value Table.
-
-<img class="screenshot" alt="Attribute Master" src="{{url_prefix}}/assets/img/stock/item-attribute-non-numeric.png">
-
-#### Numeric Attributes
-
-* If your attribute is Numeric, select Numeric Values
-* Specify the Range and the Increment Value
-
-<img class="screenshot" alt="Attribute Master" src="{{url_prefix}}/assets/img/stock/item-attribute-numeric.png">
diff --git a/erpnext/docs/user/guides/stock/setup/stock-settings.md b/erpnext/docs/user/guides/stock/setup/stock-settings.md
deleted file mode 100644
index 409037a..0000000
--- a/erpnext/docs/user/guides/stock/setup/stock-settings.md
+++ /dev/null
@@ -1,5 +0,0 @@
-You can set default settings for your stock related transactions here.
-
-<img class="screenshot" alt="Stock Settings" src="{{url_prefix}}/assets/img/stock/stock-settings.png">
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/website/blogger.md b/erpnext/docs/user/guides/website/blogger.md
deleted file mode 100644
index c548817..0000000
--- a/erpnext/docs/user/guides/website/blogger.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Blogger is a user who can post blogs. 
-You can mention a shori bio about the blogger and also set a avatar here.
-
-<img class="screenshot" alt="Blogger" src="{{url_prefix}}/assets/img/website/blogger.png">
-
-{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/website/index.txt b/erpnext/docs/user/guides/website/index.txt
deleted file mode 100644
index cf794db..0000000
--- a/erpnext/docs/user/guides/website/index.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-web-page
-blog-post
-web-form
-blogger
-setup
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/website/introduction-to-website.md b/erpnext/docs/user/guides/website/introduction-to-website.md
deleted file mode 100644
index 82f95cb..0000000
--- a/erpnext/docs/user/guides/website/introduction-to-website.md
+++ /dev/null
@@ -1,27 +0,0 @@
-Websites are a core component of any business and having a good website
-usually means:
-
-  * Invest lot of money.
-  * Difficult to update.
-  * Not interactive.
-
-Unless you are a web designer yourself.
-
-Wouldn't it be nice if there was a way to update your product catalog on your
-site automatically from your ERP?
-
-We thought exactly the same and hence built a small Website Development app
-right inside ERPNext! Using ERPNext’s Website module, you can
-
-  1. Create Web Pages
-  2. Write a Blog
-  3. Publish your Product Catalog using the Item master
-
-We will soon be adding a shopping cart facility so that your customers can
-place orders and pay you online!
-
-Though not necessary, to make a good website, you might have to know a bit of
-HTML / CSS or hire the services of a professional. The good part is that once
-this is setup, you can add and edit content, blogs and products directly from
-your ERP.
-
diff --git a/erpnext/docs/user/guides/website/product-listing-on-website.md b/erpnext/docs/user/guides/website/product-listing-on-website.md
deleted file mode 100644
index 0acc8fa..0000000
--- a/erpnext/docs/user/guides/website/product-listing-on-website.md
+++ /dev/null
@@ -1,68 +0,0 @@
-### Listing Item on Website
-
-To list your Item on the Website, fill the Item details and save the file.
-Once the file is saved, a plus (+) button will appear next to the Image icon.
-Click on the plus button and add your Item image. The html code will be
-generated automatically.
-
-##### Step 1: Save Image
-
-![Webimage]({{url_prefix}}/assets/old_images/erpnext/item-webimage.png)
-
-  
-
-##### Step 2: Check the 'Show in Website' box.
-
-Under the Website section, please check the box that says 'show in Website'.
-Once the box is checked, the page will display other fields for entering
-information.
-
-![Webimage]({{url_prefix}}/assets/old_images/erpnext/item-webimage-1.png)
-
-  
-
-##### Step 3: Enter Website Details
-
-![Webimage]({{url_prefix}}/assets/old_images/erpnext/item-webimage-2.png)
-
-The page name will be generated automatically. Mention the Item-Group under
-which the Item will be displayed.
-
-#### Item Groups
-
-Mention the Item Group under this column. If you wish to list your Item under
-the broad category products, name your Item Group as Products. In case you
-have various varieties of Item and want to classify them under different
-names, make Item Groups with those names and check the box that says 'show in
-Website'. For Example, if you wish to create a category called 'Bags', create
-a Item Group named Bags.
-
-![Item Group]({{url_prefix}}/assets/old_images/erpnext/itemgroup-webimage-bags.png)
-
-Once the Item Group is created go to the Website Settings page under Website.
-Enter the Label, Url, and Parent Label.
-
-![Item Group]({{url_prefix}}/assets/old_images/erpnext/itemgroup-website-settings.png)
-
-  
-
-#### Webpage labels
-
-![Webpage]({{url_prefix}}/assets/old_images/erpnext/webpage-labels.png)
-
-Add more Items under a particular Item Group.
-
-To add more Items under a certain Label, mention the Item Group on the Item
-Page. The Items will be added automatically on the Webpage, under the Item
-Group Label. For Example, To add Item-Kiddies Bag and Butterfly Print Bag,
-check the 'Show in Website'box. The Items will be placed under the Label Bags
-on the Webpage.
-
-![Item Group]({{url_prefix}}/assets/old_images/erpnext/itemgroup-websettings.png)
-
-  
-
-Item Group Display
-
-![Item Group Display]({{url_prefix}}/assets/old_images/erpnext/webpage-itemgroup-display.png)
-
diff --git a/erpnext/docs/user/guides/website/styling-the-website.md b/erpnext/docs/user/guides/website/styling-the-website.md
deleted file mode 100644
index 60af9bc..0000000
--- a/erpnext/docs/user/guides/website/styling-the-website.md
+++ /dev/null
@@ -1,23 +0,0 @@
-You can set some basic styles to your page using the styles feature.
-
-#### Background
-
-You can either set a solid background by selecting a color. You can attach a
-file and select it in the “Background Image” box.
-
-#### Fonts
-
-Fonts: Font family of your body text (includes some Open Source fonts). Font-
-size: Font-size of your website body text (large is good). Heading Font: Font
-family of your headings.
-
-Apart from this you can also add custom style rules using CSS
-
-#### Custom CSS
-
-There are tons of CSS rules and tricks that fall out of scope of this manual.
-But you could add your own style to certain elements like h1, h2 etc and also
-create your own style classes that you can use in elements in your body
-content.
-
-{next}
diff --git a/erpnext/docs/user/guides/CRM/contact.md b/erpnext/docs/user/manual/en/CRM/contact.md
similarity index 90%
rename from erpnext/docs/user/guides/CRM/contact.md
rename to erpnext/docs/user/manual/en/CRM/contact.md
index 51a6e50..83757e0 100644
--- a/erpnext/docs/user/guides/CRM/contact.md
+++ b/erpnext/docs/user/manual/en/CRM/contact.md
@@ -19,12 +19,12 @@
 
 > CRM > Contact > New
 
-<img class="screenshot" alt="Contact" src="{{url_prefix}}/assets/img/crm/contact.png">
+<img class="screenshot" alt="Contact" src="{{docs_base_url}}/assets/img/crm/contact.png">
 
 Or you can add a Contact or Address directly from the Customer record, click on “New
 Contact” or “New Address”.
 
-<img class="screenshot" alt="Contact" src="{{url_prefix}}/assets/img/crm/contact-from-cust.png">
+<img class="screenshot" alt="Contact" src="{{docs_base_url}}/assets/img/crm/contact-from-cust.png">
 
 > Tip: When you select a Customer in any transaction, one Contact and Address
 gets pre-selected. This is the “Default Contact or Address”.
diff --git a/erpnext/docs/user/guides/CRM/customer.md b/erpnext/docs/user/manual/en/CRM/customer.md
similarity index 84%
rename from erpnext/docs/user/guides/CRM/customer.md
rename to erpnext/docs/user/manual/en/CRM/customer.md
index 9f33f77..b317336 100644
--- a/erpnext/docs/user/guides/CRM/customer.md
+++ b/erpnext/docs/user/manual/en/CRM/customer.md
@@ -11,7 +11,7 @@
 
 or upload it via the Data Import Tool.
 
-<img class="screenshot" alt="Customer" src="{{url_prefix}}/assets/img/crm/customer.png">
+<img class="screenshot" alt="Customer" src="{{docs_base_url}}/assets/img/crm/customer.png">
 
 > Note: Customers are separate from Contacts and Addresses. A Customer can
 have multiple Contacts and Addresses.
@@ -21,9 +21,9 @@
 Contacts and Addresses in ERPNext are stored separately so that you can
 attach multiple Contacts or Addresses to Customers and Suppliers.
 
-Read [Contact]({{url_prefix}}/user/guides/crm/contact.html) to know more.
+Read [Contact]({{docs_base_url}}/user/guides/crm/contact.html) to know more.
 
-Thus we may have identical Customer Names that are uniquely identified by the ID. Since the email address is not part of the customer information the linking of customer and User is through [Contacts]({{url_prefix}}/user/guides/crm/contact.html)
+Thus we may have identical Customer Names that are uniquely identified by the ID. Since the email address is not part of the customer information the linking of customer and User is through [Contacts]({{docs_base_url}}/user/guides/crm/contact.html)
 
 ### Integration with Accounts
 
@@ -52,12 +52,12 @@
 “Credit Limit”. You can also set a global “Credit Limit” in the Company
 master. Classifying Customers
 
-ERPNext allows you to group your Customers using [Customer Group]({{url_prefix}}/user/guides/crm/setup/customer-group.html) 
-and also divide them into [Territories]({{url_prefix}}/user/guides/crm/setup/territory.html)
+ERPNext allows you to group your Customers using [Customer Group]({{docs_base_url}}/user/guides/crm/setup/customer-group.html) 
+and also divide them into [Territories]({{docs_base_url}}/user/guides/crm/setup/territory.html)
 Grouping will help you get better analysis of your data and
 identify which Customers are profitable and which are not. Territories will
 help you set sales targets for the respective territories.
-You can also mention [Sales Person]({{url_prefix}}/user/guides/crm/setup/sales-person.html) against a customer.
+You can also mention [Sales Person]({{docs_base_url}}/user/guides/crm/setup/sales-person.html) against a customer.
 
 ### Sales Partner
 
diff --git a/erpnext/docs/user/guides/CRM/index.md b/erpnext/docs/user/manual/en/CRM/index.md
similarity index 100%
rename from erpnext/docs/user/guides/CRM/index.md
rename to erpnext/docs/user/manual/en/CRM/index.md
diff --git a/erpnext/docs/user/guides/CRM/index.txt b/erpnext/docs/user/manual/en/CRM/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/CRM/index.txt
rename to erpnext/docs/user/manual/en/CRM/index.txt
diff --git a/erpnext/docs/user/guides/CRM/lead.md b/erpnext/docs/user/manual/en/CRM/lead.md
similarity index 96%
rename from erpnext/docs/user/guides/CRM/lead.md
rename to erpnext/docs/user/manual/en/CRM/lead.md
index 5dbb36d..8bcbc05 100644
--- a/erpnext/docs/user/guides/CRM/lead.md
+++ b/erpnext/docs/user/manual/en/CRM/lead.md
@@ -24,7 +24,7 @@
 
 > Selling > Lead > New Lead
 
-<img class="screenshot" alt="Lead" src="{{url_prefix}}/assets/img/crm/lead.png">
+<img class="screenshot" alt="Lead" src="{{docs_base_url}}/assets/img/crm/lead.png">
 
 ERPNext gives you a lot of options you may want to store about your Leads. For
 example what is the source, how likely are they to give you business etc. If
diff --git a/erpnext/docs/user/guides/CRM/newsletter.md b/erpnext/docs/user/manual/en/CRM/newsletter.md
similarity index 78%
rename from erpnext/docs/user/guides/CRM/newsletter.md
rename to erpnext/docs/user/manual/en/CRM/newsletter.md
index 25cd2b0..c4d9c9d 100644
--- a/erpnext/docs/user/guides/CRM/newsletter.md
+++ b/erpnext/docs/user/manual/en/CRM/newsletter.md
@@ -12,8 +12,8 @@
 document before testing. A test email will be sent to your email id. You can
 send the email to all the intended receipients by clicking on the send button.
 
-<img class="screenshot" alt="Newsletter - New" src="{{url_prefix}}/assets/img/crm/newsletter-new.png">
+<img class="screenshot" alt="Newsletter - New" src="{{docs_base_url}}/assets/img/crm/newsletter-new.png">
 
-<img class="screenshot" alt="Newsletter - Test" src="{{url_prefix}}/assets/img/crm/newsletter-test.png">
+<img class="screenshot" alt="Newsletter - Test" src="{{docs_base_url}}/assets/img/crm/newsletter-test.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/CRM/opportunity.md b/erpnext/docs/user/manual/en/CRM/opportunity.md
similarity index 82%
rename from erpnext/docs/user/guides/CRM/opportunity.md
rename to erpnext/docs/user/manual/en/CRM/opportunity.md
index d6850c8..9f44fdf 100644
--- a/erpnext/docs/user/guides/CRM/opportunity.md
+++ b/erpnext/docs/user/manual/en/CRM/opportunity.md
@@ -9,13 +9,13 @@
 
 #### Figure 1: Create Opportunity 
 
-<img class="screenshot" alt="Opportunity" src="{{url_prefix}}/assets/img/crm/opportunity.png">
+<img class="screenshot" alt="Opportunity" src="{{docs_base_url}}/assets/img/crm/opportunity.png">
 
 You can also open a “Open” Lead and click on “Create Opportunity” button.
 
 #### Figure 2: Create Opportunity from an open Lead
 
-<img class="screenshot" alt="Opportunity" src="{{url_prefix}}/assets/img/crm/lead-to-opportunity.png">
+<img class="screenshot" alt="Opportunity" src="{{docs_base_url}}/assets/img/crm/lead-to-opportunity.png">
 
 An Opportunity can also come from an existing Customer. You can create
 multiple Opportunities against the same Lead. In Opportunity, apart from the
diff --git a/erpnext/docs/user/manual/en/CRM/setup/campaign.md b/erpnext/docs/user/manual/en/CRM/setup/campaign.md
new file mode 100644
index 0000000..9f2f070
--- /dev/null
+++ b/erpnext/docs/user/manual/en/CRM/setup/campaign.md
@@ -0,0 +1,20 @@
+A Campaign is a full-scale implementation of a sales strategy to promote a
+product or a service. This is done in a market segment of a particular
+geographical area, to achieve specified objectives.
+
+<img class="screenshot" alt="Campaign" src="{{docs_base_url}}/assets/img/crm/campaign.png">
+
+You can track [Lead]({{docs_base_url}}/user/guides/crm/lead.html), [Opportunity]({{docs_base_url}}/user/guides/crm/opportunity.html), [Quotation]({{docs_base_url}}/user/guides/selling/quotation.html) against a campaign.
+
+###Track Leads against Campaign
+
+* To track a 'Lead' against a campaign select 'View Leads'.
+
+<img class="screenshot" alt="Campaign - View Leads" src="{{docs_base_url}}/assets/img/crm/campaign-view-leads.png">
+
+* You shall get a filtered list of all leads made against that campaign.
+* You can also create new leads by clicking 'New'
+
+<img class="screenshot" alt="Campaign - New Lead" src="{{docs_base_url}}/assets/img/crm/campaign-new-lead.png">
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/CRM/setup/customer-group.md b/erpnext/docs/user/manual/en/CRM/setup/customer-group.md
similarity index 69%
rename from erpnext/docs/user/guides/CRM/setup/customer-group.md
rename to erpnext/docs/user/manual/en/CRM/setup/customer-group.md
index 6e6e1b9..007f445 100644
--- a/erpnext/docs/user/guides/CRM/setup/customer-group.md
+++ b/erpnext/docs/user/manual/en/CRM/setup/customer-group.md
@@ -3,12 +3,12 @@
 group. Typically Customers are grouped by market segment (that is usually
 based on your domain).
 
-<img class="screenshot" alt="Customer Group Tree" src="{{url_prefix}}/assets/img/crm/customer-group-tree.png">
+<img class="screenshot" alt="Customer Group Tree" src="{{docs_base_url}}/assets/img/crm/customer-group-tree.png">
 
 > Tip: If you think all this is too much effort, you can leave it at “Default
 Customer Group”. But all this effort, will pay off when you start getting
 reports. An example of a sample report is given below:
 
-![Sales Analytics]({{url_prefix}}/assets/old_images/erpnext/sales-analytics-customer.png)
+![Sales Analytics]({{docs_base_url}}/assets/old_images/erpnext/sales-analytics-customer.png)
 
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/CRM/setup/index.md b/erpnext/docs/user/manual/en/CRM/setup/index.md
similarity index 100%
rename from erpnext/docs/user/guides/CRM/setup/index.md
rename to erpnext/docs/user/manual/en/CRM/setup/index.md
diff --git a/erpnext/docs/user/guides/CRM/setup/index.txt b/erpnext/docs/user/manual/en/CRM/setup/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/CRM/setup/index.txt
rename to erpnext/docs/user/manual/en/CRM/setup/index.txt
diff --git a/erpnext/docs/user/guides/CRM/setup/sales-person.md b/erpnext/docs/user/manual/en/CRM/setup/sales-person.md
similarity index 83%
rename from erpnext/docs/user/guides/CRM/setup/sales-person.md
rename to erpnext/docs/user/manual/en/CRM/setup/sales-person.md
index 4c6c0b6..114003b 100644
--- a/erpnext/docs/user/guides/CRM/setup/sales-person.md
+++ b/erpnext/docs/user/manual/en/CRM/setup/sales-person.md
@@ -3,7 +3,7 @@
 individually. Again as in Territory, the target has to be set against Item
 Group.
 
-<img class="screenshot" alt="Sales Person Tree" src="{{url_prefix}}/assets/img/crm/sales-person-tree.png">
+<img class="screenshot" alt="Sales Person Tree" src="{{docs_base_url}}/assets/img/crm/sales-person-tree.png">
 
 ####Sales Person in Transactions
 
diff --git a/erpnext/docs/user/guides/accounts/accounting-entries.md b/erpnext/docs/user/manual/en/accounts/accounting-entries.md
similarity index 89%
rename from erpnext/docs/user/guides/accounts/accounting-entries.md
rename to erpnext/docs/user/manual/en/accounts/accounting-entries.md
index e67d999..7aeff24 100644
--- a/erpnext/docs/user/guides/accounts/accounting-entries.md
+++ b/erpnext/docs/user/manual/en/accounts/accounting-entries.md
@@ -4,7 +4,7 @@
 
   * Mama (The Tea-stall owner) invests Rs 25000 to start the business.
 
-![A&L]({{url_prefix}}/assets/old_images/erpnext/assets-1.png)
+![A&L]({{docs_base_url}}/assets/old_images/erpnext/assets-1.png)
 
 __Analysis:__ Mama invested 25000 in company, hoping to get some profit. In other
 words, company is liable to pay 25000 to Mama in the future. So, account
@@ -14,7 +14,7 @@
 
   * The company needs equipments (Stove, teapot, cups etc) and raw materials (tea, sugar, milk etc) immediately. He decides to buy from the nearest general store "Super Bazaar" who is a friend so that he gets some credit. Equipments cost him 2800 and raw materials worth of 2200. He pays 2000 out of total cost 5000.
 
-![A&L]({{url_prefix}}/assets/old_images/erpnext/assets-2.png)
+![A&L]({{docs_base_url}}/assets/old_images/erpnext/assets-2.png)
 
 __Analysis:__ Equipments are "Fixed Assets" (because they have a long life) of the
 company and raw materials "Current Assets" (since they are used for day-to-day
@@ -25,7 +25,7 @@
 
   * Mama (who takes care of all entries) decides to book sales at the end of the every day, so that he can analyze daily sales. At the end of the very first day, the tea stall sells 325 cups of tea, which gives net sales of Rs. 1575. The owner happily books his first day sales.
 
-![A&L]({{url_prefix}}/assets/old_images/erpnext/assets-3.png)
+![A&L]({{docs_base_url}}/assets/old_images/erpnext/assets-3.png)
 
 __Analysis:__ Income has been booked in "Sales of Tea" account which has been
 credited to increase the value and the same amount will be debited to "Cash"
@@ -36,7 +36,7 @@
 At the end of the month, the company paid the rent amount of stall (5000) and
 salary of one employee (8000), who joined from the very first day.
 
-![A&L]({{url_prefix}}/assets/old_images/erpnext/assets-4.png)
+![A&L]({{docs_base_url}}/assets/old_images/erpnext/assets-4.png)
 
 ### Booking Profit
 
@@ -47,7 +47,7 @@
 Sheet is not balanced i.e. Debit is not equal to Credit, the profit has not
 yet been booked. To book profit, the following entry has to be made:
 
-![A&L]({{url_prefix}}/assets/old_images/erpnext/assets-5.png)
+![A&L]({{docs_base_url}}/assets/old_images/erpnext/assets-5.png)
 
 Explanation: Company's net sales and expenses are 40000 and 20000
 respectively. So, company made a profit of 20000. To make the profit booking
diff --git a/erpnext/docs/user/guides/accounts/accounting-reports.md b/erpnext/docs/user/manual/en/accounts/accounting-reports.md
similarity index 73%
rename from erpnext/docs/user/guides/accounts/accounting-reports.md
rename to erpnext/docs/user/manual/en/accounts/accounting-reports.md
index 5026151..61470b1 100644
--- a/erpnext/docs/user/guides/accounts/accounting-reports.md
+++ b/erpnext/docs/user/manual/en/accounts/accounting-reports.md
@@ -7,7 +7,7 @@
 done in that period for that Account.
 
 <img alt="General Ledger" class="screenshot"
-    src="{{url_prefix}}/assets/img/accounts/general-ledger.png">
+    src="{{docs_base_url}}/assets/img/accounts/general-ledger.png">
 
 ### Trial Balance
 
@@ -20,7 +20,7 @@
   * Credits
   * Closing
 
-<img alt="Trial Balance" class="screenshot" src="{{url_prefix}}/assets/img/accounts/trial-balance.png">
+<img alt="Trial Balance" class="screenshot" src="{{docs_base_url}}/assets/img/accounts/trial-balance.png">
 
 The sum of all closing balances in a Trial Balance must be zero.
 
@@ -30,7 +30,7 @@
 Suppliers. In this report, you will get your outstanding amounts period wise.
 i.e. between 0-30 days, 30-60 days and so on.
 
-<img alt="Accounts Receivable" class="screenshot" src="{{url_prefix}}/assets/img/accounts/accounts-receivable.png">
+<img alt="Accounts Receivable" class="screenshot" src="{{docs_base_url}}/assets/img/accounts/accounts-receivable.png">
 
 ### Sales and Purchase Register
 
@@ -38,6 +38,6 @@
 invoice Item, you will get the amount of individual tax that has been paid,
 based on the Taxes and Charges table.
 
-<img alt="Sales Register" class="screenshot" src="{{url_prefix}}/assets/img/accounts/sales-register.png">
+<img alt="Sales Register" class="screenshot" src="{{docs_base_url}}/assets/img/accounts/sales-register.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/accounts/advance-payment-entry.md b/erpnext/docs/user/manual/en/accounts/advance-payment-entry.md
similarity index 86%
rename from erpnext/docs/user/guides/accounts/advance-payment-entry.md
rename to erpnext/docs/user/manual/en/accounts/advance-payment-entry.md
index fa818fb..042e800 100644
--- a/erpnext/docs/user/guides/accounts/advance-payment-entry.md
+++ b/erpnext/docs/user/manual/en/accounts/advance-payment-entry.md
@@ -24,7 +24,7 @@
 
 #### Figure 1 : Journal Entry -Advance Entry  
 
-<img class="screenshot" alt="Advace Payment" src="{{url_prefix}}/assets/img/accounts/advance-payment-1.png">
+<img class="screenshot" alt="Advace Payment" src="{{docs_base_url}}/assets/img/accounts/advance-payment-1.png">
 
 ### Double Entry Accounting  
 
@@ -41,7 +41,7 @@
   
 #### Figure 2: Transaction and Difference Entry
 
-<img class="screenshot" alt="Advace Payment" src="{{url_prefix}}/assets/img/accounts/advance-payment-2.png">
+<img class="screenshot" alt="Advace Payment" src="{{docs_base_url}}/assets/img/accounts/advance-payment-2.png">
 
 Save and submit the JV. If this document is not saved it will not be pulled in
 other accounting documents.
@@ -55,7 +55,7 @@
 
 #### Figure 3: Receive Advance 
 
-<img class="screenshot" alt="Advace Payment" src="{{url_prefix}}/assets/img/accounts/advance-payment-3.png">
+<img class="screenshot" alt="Advace Payment" src="{{docs_base_url}}/assets/img/accounts/advance-payment-3.png">
 
 Save and submit the Sales Invoice.
 
diff --git a/erpnext/docs/user/manual/en/accounts/articles/.md b/erpnext/docs/user/manual/en/accounts/articles/.md
new file mode 100644
index 0000000..39dc1a8
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/.md
@@ -0,0 +1,228 @@
+Write a post about distributing same expense among various cost centers.
+
+<div><span style="color: rgb(0, 100, 0); font-family: Verdana, sans-serif; font-size: 9pt; line-height: 1.42857143;">&nbsp;&nbsp;</span>
+    <br>
+</div>
+<div><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">How do i differentiate salaries of 2 departments in <span class="il">cost</span>  <span class="il">centers</span>?</span>
+    <br>
+</div>
+<div><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif"><br></span>
+</div>9:18:38 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;hi Dhaval..</span>
+<br>
+<br>9:18:42 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;this is Umair..</span>
+<br>
+<br>9:18:44 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;how are you?</span>
+<br>
+<br>9:18:46 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;hey umair</span>
+<br>
+<br>9:18:49 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;m good</span>
+<br>
+<br>9:19:16 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;have you created department wise <span class="il">cost</span>  <span class="il">center</span>?</span>
+<br>
+<br>9:19:27 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;no we have not yet created <span class="il">cost</span>  <span class="il">center</span></span>
+<br>
+<br>9:19:36 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;if so, this is how you should post journal voucher for salary..</span>
+<br>
+<br>9:19:49 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;can you help us in an ideal way to setup up <span class="il">cost</span>  <span class="il">centers</span>?</span>
+<br>
+<br>9:19:50 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;I will just give you an example first..</span>
+<br>
+<br>9:19:53 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;ok</span>
+<br>
+<br>9:20:09 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;if you give 2,00,000 in a monthly salary..</span>
+<br>
+<br>9:20:37 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;and divide salary expense in multiple <span class="il">cost</span>  <span class="il">center</span>:</span>
+<br>
+<br>9:20:52 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;then this how journal voucher will be posted.</span>
+<br>
+<br>9:23:06 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;Dr. Salary (Expense a/c) ........... Sales (<span class="il">cost</span>  <span class="il">center</span>) ........... 80000
+<br>&nbsp;&nbsp;&nbsp;&nbsp;Dr. Salary ..............................
+<wbr>. Manufacturing .................. 70000
+<br>&nbsp;&nbsp;&nbsp;&nbsp;Dr. Salary ..............................
+<wbr>. Admin.........................
+<wbr>..... 30000
+<br>&nbsp;&nbsp;&nbsp;&nbsp;Dr. Salary ..............................
+<wbr>. Seniors ............................ 20000
+<br>&nbsp;&nbsp;&nbsp;&nbsp;Cr. Bank/Cash account.......................
+<wbr>..............................
+<wbr>. 200000</span>
+<br>
+<br>9:23:15 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;Debit = Credit - 2,00,000</span>
+<br>
+<br>9:23:25 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;ok</span>
+<br>
+<br>9:23:32 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;so, expense account selected will be same..</span>
+<br>
+<br>9:23:45 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;but you will divide rows based on <span class="il">cost</span>  <span class="il">center</span>.</span>
+<br>
+<br>9:24:00 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;but we have 3 levels of hierarchy</span>
+<br>
+<br>9:24:30 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;like Production Unit -1 &gt; Departments &gt; sections</span>
+<br>
+<br>9:24:49 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;its like a tree,</span>
+<br>
+<br>9:24:57 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;<span class="il">cost</span>  <span class="il">center</span> within a <span class="il">cost</span>  <span class="il">center</span></span>
+<br>
+<br>9:25:48 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;you can define child - parent relationship in <span class="il">Cost</span>  <span class="il">Center</span> master.</span>
+<br>
+<br>9:26:01 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;because it is a tree structure master..</span>
+<br>
+<br>9:26:20 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;ya, but here is my problem</span>
+<br>
+<br>9:26:20 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;but only child <span class="il">cost</span>  <span class="il">centers</span> will be selectable in the transactions..</span>
+<br>
+<br>9:26:28 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;exactly</span>
+<br>
+<br>9:26:52 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;<a href="https://erpnext.com/user-guide/selling/selling-setup/customer-group" target="_blank">https://erpnext.com/user-<wbr>guide/selling/selling-setup/<wbr>customer-group</a></span>
+<br>
+<br>9:27:08 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;check this for example on how to manage tree masters</span>
+<br>
+<br>9:28:03 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;so how can i have a <span class="il">cost</span>  <span class="il">center</span> of production unit as a ledger as well as parent</span>
+<br>
+<br>9:29:45 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;Production (parent)<br>&nbsp;&nbsp;&nbsp;&nbsp; - Cutting<br>&nbsp;&nbsp;&nbsp;&nbsp; - Stitching<br>&nbsp;&nbsp;&nbsp;&nbsp; - packing</span>
+<br>
+<br>9:30:09 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;so how do i track salaries of each of there depts</span>
+<br>
+<br>9:30:15 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;these*</span>
+<br>
+<br>9:30:25 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;check attached link for example on how to create group and child <span class="il">Cost</span>  <span class="il">Centers</span>.</span>
+<br>
+<br>9:31:00 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;in JV, you will select Cutting, Packing department for <span class="il">Cost</span>  <span class="il">Center</span>.</span>
+<br>
+<br>9:31:06 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;i have to create each individual ledgers &nbsp;- cutting salary, stitching salary, packing salary</span>
+<br>
+<br>9:32:15 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;OH! so in JV, when i select Cutting, Packing department for <span class="il">Cost</span>  <span class="il">Center</span>. will it show salary as a head in
+the <span class="il">cost</span>  <span class="il">center</span>?</span>
+<br>
+<br>9:32:22 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;as it is a salary JV?</span>
+<br>
+<br>9:32:32 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;or will only the value of the amount show?</span>
+<br>
+<br>9:33:50 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;it will show balance for the individual <span class="il">cost</span>  <span class="il">center</span>..</span>
+<br>
+<br>9:34:19 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;and consolidated <span class="il">cost</span>  <span class="il">center</span> for Production <span class="il">Cost</span>  <span class="il">Center</span>, which
+is parent for these <span class="il">cost</span>  <span class="il">centers</span></span>
+<br>
+<br>9:34:38 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;so only amount and not against the type expense</span>
+<br>
+<br>9:38:00 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;yes.. it will show again Salary Account as well..</span>
+<br>
+<br>9:38:17 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;basically, we tag <span class="il">cost</span>  <span class="il">center</span> with Profit and Loss account..</span>
+<br>
+<br>9:38:34 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;ok</span>
+<br>
+<br>9:38:35 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;so actual ledger posting happens in the Account/Ledger..</span>
+<br>
+<br>9:38:54 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;<span class="il">Cost</span>  <span class="il">Center</span> shows balance based on amount mentioned with it..</span>
+<br>
+<br>9:39:17 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;so in <span class="il">cost</span>  <span class="il">centers</span> i should just keep all my depts as ledgers and all <span class="il">costs</span> will be
+tracked for all types of expenses</span>
+<br>
+<br>9:39:23 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;so, we need to identify the correct combination of <span class="il">Cost</span>  <span class="il">Center</span> and Expense account when making entry</span>
+<br>
+<br>9:39:45 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;thats one approach.</span>
+<br>
+<br>9:39:54 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;you can try and check if it works for you.</span>
+<br>
+<br>9:40:12 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;what is the other approach?</span>
+<br>
+<br>9:41:53 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;as per your scenario, this seems to be better.</span>
+<br>
+<br>9:42:08 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;we can comeup with other solution as scenario changes.</span>
+<br>
+<br>9:42:57 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;ok so, just for my knowledge, &nbsp;what was the default according to you?</span>
+<br>
+<br>9:43:11 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;where do i track <span class="il">cost</span>  <span class="il">center</span> transactions?</span>
+<br>
+<br>9:43:43 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;there is no default as such <img class="CToWUd" src="https://mail.google.com/mail/u/0/?ui=2&amp;ik=5ded98c3b2&amp;view=fimg&amp;th=14997f6e6fc0690c&amp;attid=0.2&amp;disp=emb&amp;attbid=ANGjdJ8-s7s_w-HjfYCzquJ_jtWcYmi_jio2e21FfwAQMuN0Ojva3jv5ASXx__dGcNPLBGFnkLIhVx7IEYFiJRpimtb3Baen5vbSkns_O1ZHy63fuzSb1DKi0IilcQE&amp;sz=w1600-h1000&amp;ats=1415597192468&amp;rm=14997f6e6fc0690c&amp;zw&amp;atsh=1" alt="Smiley: Smile" title="Smile" height="24" width="24"></span>
+<br>
+<br>9:43:56 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;you can define masters you per your requirement..</span>
+<br>
+<br>9:44:06 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;we suggest setting up <span class="il">cost</span>  <span class="il">center</span> based on Project..</span>
+<br>
+<br>9:44:19 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;because it will help you track profitability as well.</span>
+<br>
+<br>9:44:29 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;but thats another scenario.</span>
+<br>
+<br>9:44:41 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;ok</span>
+<br>
+<br>9:44:44 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;cool</span>
+<br>
+<br>9:46:36 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;where to tract <span class="il">cost</span>  <span class="il">center</span> reports?</span>
+<br>
+<br>9:47:24 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;track*</span>
+<br>
+<br>9:48:32 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Dhaval Shah:</span>
+<br><span style="color:#006400;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;?</span>
+<br>
+<br>9:48:51 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;Accounts &gt;&gt; Main Reports &gt;&gt; Financial Analytics</span>
+<br>
+<br>9:49:12 AM: <span style="color:#696969;font-size:9.0pt;font-family:Verdana,sans-serif">Web Notes Support:</span>
+<br><span style="color:#b22222;font-size:9.0pt;font-family:Verdana,sans-serif">&nbsp;&nbsp;&nbsp;&nbsp;below P&amp;L and Balance Sheet, you will find <span class="il">cost</span>  <span class="il">centers</span> for selection.</span>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/accounting-for-projects.md b/erpnext/docs/user/manual/en/accounts/articles/accounting-for-projects.md
new file mode 100644
index 0000000..6eba288
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/accounting-for-projects.md
@@ -0,0 +1,72 @@
+<h1>Accounting for Projects</h1>
+
+Accounting for the projects is tracked via Cost Center in ERPNext. This will require you creating separate Cost Center for each Project. Separate Cost Center for each Project all allow:<
+
+- Allocating budget against specific Cost Center.
+- Getting Profitability Report for each Project.
+
+Let's check steps on how Project and Cost Center should be linked, and used in the sales and purchase transactions.
+
+### 1. Linking Project and Cost Center
+
+#### 1.1 Create Project
+
+You should first create new Project from:
+
+`Projects > Project > New`
+
+In the Project, you will find field to set default Cost Center for this Project.
+
+#### 1.2 Create Cost Center
+
+Since budgeting and costing for each Project will be managed separately, you should create separate Cost Center for each Project.
+
+To create new Cost Center, go to:
+
+`Accounts > Setup > Cost Center`
+
+[Click here to learn on how to add new Cost Center](https://erpnext.com/user-guide/accounts/cost-centers-and-budgeting).
+
+#### 1.3 Update Cost Center in the Project
+
+After creating Cost Center, come back to Project master, and select Cost Center creating for this Project under Default Cost Center field.
+
+![Project Default Cost Center]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-26 at 3.52.10 pm.png)
+
+With this, you will have Cost Center being fetched automatically in the Sales and Purchase transactions based on selection of Cost Center.
+
+Let's check how this setting will affect your sales and purchase entries.
+
+### 2. Selecting Project and Cost Center in the Sales and Purchase Transactions
+
+#### 2.1 Selecting Project in the Sales Transactions
+
+In the sales transactions (which are Sales Order, Delivery Note and Sales Invoice), Project will be selected in the More Info section. On selection of a Project, respective Cost Center will be updated for all the items in that transaction.
+
+![Cost Center in Sales]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-26 at 3.58.45 pm.png)
+
+#### 2.2 Selecting Project in the Purchase Cycle Transactions
+
+In the purchase transactions, Project will be define for each item. This is because you can create a consolidated purchase entry of materials for various projects. Just like it works in sales cycle, same way in the purchase transactions, on selection of Project, its default cost center will be fetched automatically.
+
+![Cost Center in Purchase]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-26 at 4.20.30 pm.png)
+
+### 3. Accounting Report for a Project
+
+#### 3.1 Projectwise Profitability
+
+Since Project's Cost Center has been updated in both sales and purchase entries made for a specific transaction, system will provide you a projectwise profitability report. Profitability for a Project will be derived based on total value income booked minus total value of expense booked where common Cost Center (of a Project) is tagged.
+
+![Financial Analytics for a Project]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-26 at 4.10.37 pm.png)
+
+#### 3.2 Projectwise Budgeting
+
+If you have also define budgets in the Cost Center of a Project, you will get Budget Variance Report for a Cost Center of a Project.
+
+To check Budget Variance report, go to:
+
+`Accounts > Standard Reports > Budget Variance Report`
+
+[Click here for detailed help on how to do budgeting from Cost Center](https://erpnext.com/user-guide/accounts/budgeting).
+
+<!-- markdown -->
diff --git a/erpnext/docs/user/manual/en/accounts/articles/c-form.md b/erpnext/docs/user/manual/en/accounts/articles/c-form.md
new file mode 100644
index 0000000..c2f2061
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/c-form.md
@@ -0,0 +1,47 @@
+<h1>C-Form</h1>
+
+C-Form functionality is only applicable for Indian customers.
+
+**What is C-Form?**
+
+C-Form is issued by the Customer. If Customer Issues C-Form, supplier applies discounted CST (central sales tax) in the invoice. C-Form is only applicable on the inter-state transactions.
+
+C-Form functionality in ERPNext allows Supplier to update C-Form No. as received from Customer in the submitted Sales Invoice. Also you can create report on Sales Invoice and track invoices for which C-Form has not yet been received from Customer.
+
+Following are step to manage C-Form related sales in ERPNext.
+
+####Set C-Form Applicability
+
+While creating Sales invoice for the customer, set C-Form applicability in Sales Invoice. In More Info section of Sales Invoice, set field called **Is C-Form Applicable** as **Yes**. Bydefault, this field will have No for a value.
+ 
+![C-form]({{docs_base_url}}/assets/img/articles/Selection_0028c9f9a.png)
+
+Updating this field as Yes will allow you to pull this Sales Invoice in the C-Form Tool, and update C-Form No. as received from the Customer.
+
+####Create C-Form Record
+
+After receiving C-Form from your Customer, you should update that C-Form no. in the Sales Invoice by creating C-Form record.
+
+Go to `Accounts > Setup > C-Form > New`
+
+Enter details like C-Form No, Received Date, State and Amount etc. Select Customer and pull related Sales Invoices under provided table.
+
+![New C-Form]({{docs_base_url}}/assets/img/articles/Selection_020f01c1e.png)
+
+####Save & Submit C-Form
+
+After entering details, save and submit C-Form record. On save system will generate C-Form record and on submission update that C-Form No. in the Sales Invoice.
+
+![C-Form]({{docs_base_url}}/assets/img/articles/Selection_02178f9d6.png)
+
+C-Form serial no will be updated in related invoice under the field 'C-Form No'.
+
+![C-Form No]({{docs_base_url}}/assets/img/articles/Selection_022b7c6d5.png)
+
+####Tracking Pending Invoice for C-Form
+
+To track invoices for which C-Form has not yet been received from Customer, you can create custom report on Sales Invoice. In this report, you can filter invoices which doesn't have C-Form updated in them yet, and followup with the customer accordingly.
+
+![C-Form Report]({{docs_base_url}}/assets/img/articles/Selection_026.png)
+
+<!-- markdown -->
diff --git a/erpnext/docs/user/manual/en/accounts/articles/changing-parent-account.md b/erpnext/docs/user/manual/en/accounts/articles/changing-parent-account.md
new file mode 100644
index 0000000..02cbd66
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/changing-parent-account.md
@@ -0,0 +1,28 @@
+<h1>Changing Parent Account</h1>
+
+Chart of Account has hierarchical structure. This means each account has a parent account defined for it. You will have few ledger preset, and few ledger (like for Customer, Supplier, Warehouse) will be auto-created based on their master record. These ledger will be placed under pre-defined groups in the Chart of Account. If needed you can place specific account under another group by changing its Parent Account.
+
+Following are the steps to edit Parent for specific Account.
+
+####1. Go to Chart of Account
+
+`Accounts > Setup > Chart of Account`
+
+Click on Account for which Parent Account is to be changed.
+
+####2. Edit Account
+
+![Account]({{docs_base_url}}/assets/img/articles/Selection_080.png)  
+
+####3. Change Parent Account
+
+Search and select preferred Parent Account and save.
+
+![Account]({{docs_base_url}}/assets/img/articles/Selection_084.png)
+
+Refresh system from Help menu to experience the change.
+
+![Account]({{docs_base_url}}/assets/img/articles/Selection_085.png)
+
+<div class="well">Note: Change of Parent Account is not applicable for Root Accounts.</div>
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/customer-for-multiple-company.md b/erpnext/docs/user/manual/en/accounts/articles/customer-for-multiple-company.md
new file mode 100644
index 0000000..6770fa3
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/customer-for-multiple-company.md
@@ -0,0 +1,27 @@
+<h1>Customer for Multiple Company</h1>
+
+ERPNext allows you managing multiple companies in one ERPNext account. It is possible that you will have Customer and Supplier which would belong to more than one company of yours. While creating sales and purchase transactions, system shows result of Customer and Suppliers for that Company only.
+
+It means if you have added (say) Wind Mills Limited as a customer for the first company, you will not be able to select it as a customer when creating Sales Order (or any other sales transaction) for another company.
+
+There are two approach to address this scenario.
+
+####Create Another Customer Record
+
+You should create another Customer record for Wind Mills Limited, but for the second company.
+
+If you try adding another customer with exact same name (as Wind Mills Limited), system will throw a validation message that, account already exist for Wind Mills Limited.
+
+![Common Customer]({{docs_base_url}}/assets/img/articles/$SGrab_306.png)
+
+>To be able to track customerwise receivables, ERPNext created accounting ledger for each customer in the Chart of Account, under Accounts Receivable group.
+
+As indicated in the error message, since Account Name already exist for the first customer, you should change customer name for second customer a bit (say Wind Mills Pvt. Limited) to bring uniqueness in it. Then you will be able to save Customer correctly.
+
+####Change Company in Existing Customer
+
+Since creating another Customer record for the same party will be over-load in the system, you can change company in the exist Customer master of Wind Mills Limited, and re-save it. On saving customer again, it will create another accounting ledger for Wind Mills in the Chart of Account of second company.
+
+![Common Customer Account]({{docs_base_url}}/assets/img/articles/$SGrab_307.png)
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/depreciation-for-fixed-asset-items.md b/erpnext/docs/user/manual/en/accounts/articles/depreciation-for-fixed-asset-items.md
new file mode 100644
index 0000000..026657f
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/depreciation-for-fixed-asset-items.md
@@ -0,0 +1,30 @@
+<h1>Depreciation for Fixed Asset Items</h1>
+
+Depereciation of fixed asset items.
+
+####Separate Group of Depreciation Account
+
+![Fixed Asset Account]({{docs_base_url}}/assets/img/articles/$SGrab_384.png)
+
+####Depreciation Entry for Fixed Asset Items
+
+Depreciation is when you write off certain value of your assets as an expense. For example if you have a computer that you will use for say 5 years, you can distribute its expense over the period and pass a
+Journal Voucher at the end of each year reducing its value by a certain percentage.
+
+As per perpetual inventory valuation system (set by default), you should create Stock Reconciliation for depreciating value of fixed asset items. In the Stock Reconciliation template, you should only enter Item's Code, Warehouse and its current value.
+
+Let's assume current value of our computer is $250, and its purchase value was $320.
+
+![Fixed Asset Depreciation]({{docs_base_url}}/assets/img/articles/$SGrab_385.png)
+
+In this case, depreciation amount of Computer will be $70 ($320-$250). Depreciation Amount will be booked under Difference (expense) Account selected in the stock reconciliation.
+
+![Fixed Asset Depreciation]({{docs_base_url}}/assets/img/articles/$SGrab_386.png)
+
+Following is how general ledger will be posted for fixed this Stock Reconciliation.
+
+![Fixed Asset General Ledger]({{docs_base_url}}/assets/img/articles/$SGrab_387.png)
+
+Click [here](https://erpnext.com/user-guide/setting-up/stock-reconciliation-for-non-serialized-item) for steps to be followed when making Stock Reconciliation entry.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/difference-entry-button.html b/erpnext/docs/user/manual/en/accounts/articles/difference-entry-button.html
new file mode 100644
index 0000000..30cae4e
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/difference-entry-button.html
@@ -0,0 +1,16 @@
+<h1>Difference Entry Button </h1>
+
+As per accounting standards Debit amount must be equal to Credit amount. If these amounts are not equal, then entry will not be executed in system. Also system will through validation message. And difference amount will reflect under Difference (Dr-Cr) field.
+<br>
+<img src="{{docs_base_path}}/assets/img/articles/Selection_002.png"><br>
+When you press 'Make Difference Entry' button, one new Row will be added under Journal Entry Accounts table with difference amount. You can edit that row to select appropriate account.
+<br>
+<img src="{{docs_base_path}}/assets/img/articles/Selection_003.png">
+<br>
+<br>On selecting account under new row, you will be able to submit Journal Entry.
+<br>
+<br>
+<div class="well">If debit and credit amount entered for accounts are already tallying, then you need not click on "Make Difference Entry" button.</div>
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/fiscal-year-error.md b/erpnext/docs/user/manual/en/accounts/articles/fiscal-year-error.md
new file mode 100644
index 0000000..e22a3ef
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/fiscal-year-error.md
@@ -0,0 +1,32 @@
+<h1>Fixing Fiscal Year's Error</h1>
+
+While creating entries in ERPNext, system validates if dates (like Posting Date, Transaction Date etc.) matches with Fiscal Year selected in the entry. If not, system through an error message saying:
+
+`Date ##-##-#### not in fiscal year`
+
+You are more likely to receive this error message if your Fiscal Year has changes, but you still have old Fiscal Year updated. To ensure new Fiscal Year is auto updated in the transactions, you should setup your master as instructed below.
+
+####Create New Fiscal Year
+
+Only User with System Manager's Role Assigned has permission to create new Fiscal Year. To create new Fiscal Year, go to:
+
+`Accounts > Setup > Fiscal Year`
+
+Click [here](https://erpnext.com/user-guide/accounts/fiscal-year) to learn more about Fiscal Year master.
+
+####Set Fiscal Year as Default
+
+After Fiscal Year is saved, you will find option to set that Fiscal year as Default.
+
+![Fiscal Year Default]({{docs_base_url}}/assets/img/articles/$SGrab_393.png)
+
+Default Fiscal Year will be updated in the Global Default setting as well. You can manually update Default Fiscal Year from:
+
+`Setup > Settings > Global Default`
+
+![Fiscal Year Global Default]({{docs_base_url}}/assets/img/articles/$SGrab_394.png)
+
+Then Save Global Default, and refresh browser of your ERPNext account. After this, you will have default Fiscal Year auto-updated in your transactions as well.
+
+Note: In transactions, you can manually select required Fiscal Year from More Info section. You might have to click on "View Details" button to access View Details section, and edit Fiscal Year.
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-entries-upto-a-specific-date.html b/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-entries-upto-a-specific-date.html
new file mode 100644
index 0000000..38ecaf5
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-entries-upto-a-specific-date.html
@@ -0,0 +1,3 @@
+<h1>How to freeze accounting entries upto a specific date?</h1>
+
+To freeze accounting entries upto a certain date, follow these steps:<br><br>1. Go to <b>Accounts -&gt; Setup -&gt; Accounts Settings</b>.<br>2. Set the date in <b>Accounts Frozen Upto</b> field.<br><img src="{{docs_base_path}}/assets/img/articles/freeze-accounting-entry.png" height="302" width="488"><br><br>Now, the system will not allow to make accounting entries before that date. <br><br>But you can allow a specific <b>Role,</b> to make/edit accounting entries before that date. To do that set the desired <b>Role</b>, in <b>Role Allowed to Set Frozen Accounts &amp; Edit Frozen Entries</b> field.<br>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-ledger.md b/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-ledger.md
new file mode 100644
index 0000000..d76a331
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/how-to-freeze-accounting-ledger.md
@@ -0,0 +1,28 @@
+<h1>How To Freeze Accounting Ledger?</h1>
+
+You can freeze any accounting ledger in ERPNext. So that frozen accounting ledger became unsearchable in accounting transaction. Follow below step to understand the process.
+
+#### 1. Set Frozen Accounts Modifier
+
+To set frozen accounts modifier go to `Accounts > Setup > Accounts Setting`
+
+Search and select Role under Frozen Accounts Modifier field and save the Account Settings form. 
+   
+![Account Settings]({{docs_base_url}}/assets/img/articles/Selection_001f1e2ff.png)
+
+#### 2. Edit Accounting Ledger.
+
+To edit accounting ledger go to `Accounts > Setup > Chart of Accounts`
+
+![Account Settings]({{docs_base_url}}/assets/img/articles/Selection_0027e4d09.png)
+
+#### 3. Set Frozen Status of Ledger.
+
+![Account Settings]({{docs_base_url}}/assets/img/articles/Selection_003bf981b.png)
+
+Set Frozen field status of ledger as 'Yes' and save the ledger form. On save this ledger will be frozen and you will became unable to search this ledger in accounting transactions. 
+
+<div class ="well"> Note: If you want to make accounting transaction against this ledger in the future, then that time again set frozen field status as 'No'.</div>
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/how-to-nullify-balance-from-temporary-accounts.md b/erpnext/docs/user/manual/en/accounts/articles/how-to-nullify-balance-from-temporary-accounts.md
new file mode 100644
index 0000000..5ba6d17
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/how-to-nullify-balance-from-temporary-accounts.md
@@ -0,0 +1,16 @@
+<h1>How to Nullify Balance From Temporary Accounts? </h1>
+
+There are two separate temporary accounts in Chart of Accounts. One is Temporary Account (Assets) and other one is Temporary Account (Liabilities). These accounts are available under Application of Funds and Source of Funds in Chart of Accounts respectively.
+
+These temporary accounts only used to update opening balances. [Click here to learn about update Opening balances](https://erpnext.com/kb/accounts/updating-opening-balance-in-accounts-using-temporary-account)
+
+After completing all opening entries against these temporary accounts balances for both accounts will updated. And Debit balance of Temporary Account (Assets) will became equal to Credit balance of Temporary Account (Liabilities).
+
+Since temporary account were used only for balancing purpose, it shall not have any balance in it.
+To nullify balance in these accounts, you should create a new Journal Voucher, where will you update  balances against these accounts. To create new Journal Entry go to `Accounts &gt; Documents &gt; Journal Entry
+
+![Journal Entry]({{docs_base_url}}/assets/img/articles/$SGrab_432.png)
+
+On submit of this journal entry, balances of these temporary accounts will be set to Zero.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/index.md b/erpnext/docs/user/manual/en/accounts/articles/index.md
new file mode 100644
index 0000000..4e1be28
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/index.md
@@ -0,0 +1 @@
+{content}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/index.txt b/erpnext/docs/user/manual/en/accounts/articles/index.txt
new file mode 100644
index 0000000..2eb1756
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/index.txt
@@ -0,0 +1,22 @@
+
+accounting-for-projects
+c-form
+changing-parent-account
+customer-for-multiple-company
+depreciation-for-fixed-asset-items
+difference-entry-button
+fiscal-year-error
+how-to-freeze-accounting-entries-upto-a-specific-date
+how-to-freeze-accounting-ledger
+how-to-nullify-balance-from-temporary-accounts
+manage-foreign-exchange-difference
+managing-transactions-in-multiple-currency
+new-fiscal-year-auto-create-feature
+pos-view
+post-dated-cheque-entry
+pricing-rule
+recurring-order-and-invoices
+update-stock-option-in-sales-invoice
+updating-opening-balance-in-accounts-using-temporary-account
+what-is-the-differences-of-total-and-valuation-in-tax-and-charges
+withdrawing-salary-from-owners-equity-account
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/manage-foreign-exchange-difference.md b/erpnext/docs/user/manual/en/accounts/articles/manage-foreign-exchange-difference.md
new file mode 100644
index 0000000..6e24f86
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/manage-foreign-exchange-difference.md
@@ -0,0 +1,25 @@
+<h1>Manage Foreign Exchange Difference</h1>
+
+When you book Sales Invoices and Purchase invoices in multiple currencies, you will have to deal with currency difference while booking payment entry. You can easily manage this in ERPNext in following ways.  
+
+####Add Expense Account
+
+To mange currency difference, create Account **Foreign Exchange Gain/Loss**.
+
+![Account]({{docs_base_url}}/assets/img/articles/Selection_577.png)
+
+####Book Payment Entry
+
+In the payment voucher, update invoice amount against Customer or Supplier account, then update actual payment amount against Bank/ Cash account. Add new row and select Foreign Exchange Gain/Loss to update currency difference amount.
+
+####Scenario
+
+Below is the Sales Invoice for a customer in Europe. The base currency of a Company in USD. Sales Invoice is  made at the exchange rate (USD to Eur) of 1.128.
+
+![Sales Invoice]({{docs_base_url}}/assets/img/articles/Selection_576.png)
+
+When receiving payment from the customer, exchange rate changed to 1.20. As per the update in the exchange rate, payment was for $120. Following is how payment entry will be booked to adjust the difference amount.
+
+![Journal Entry image]({{docs_base_url}}/assets/img/articles/Selection_578.png) 
+
+<!-- markdown -->
diff --git a/erpnext/docs/user/manual/en/accounts/articles/managing-transactions-in-multiple-currency.html b/erpnext/docs/user/manual/en/accounts/articles/managing-transactions-in-multiple-currency.html
new file mode 100644
index 0000000..3757a69
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/managing-transactions-in-multiple-currency.html
@@ -0,0 +1,39 @@
+<h1>Managing Transactions In Multiple Currency</h1>
+
+You can make transaction in your base currency as well as in customer or supplier currencies. When you make transaction in your customer or supplier currency, the same currency reflects only in print format of that transaction. And system pass back end
+entry in your base currency.
+<br>
+<br>To understand this scenario will take example of Sales Invoice, where your base currency is INR and your customer currency is USD.
+<br>
+<br>Following are steps to create Sales Invoice in customer currency.
+<br>&nbsp;
+<br><b>Step 1:</b> Go to Selling &gt;&gt; Documents &gt;&gt; Sales Invoice &gt;&gt; (+) New.
+<br>
+<br><b>Step 2:</b> Select Customer and Enter other details.
+<br>
+<br>
+<img src="{{docs_base_path}}/assets/img/articles/Selection_012.png">
+<br><b>Step 3:</b> Select customer currency and related Price List.
+<br>
+<br>
+<img src="{{docs_base_path}}/assets/img/articles/Selection_016.png">
+<br>
+<br>
+<br>On selecting customer currency 'Exchange Rate' field will open under Currency field, where you will enter exchange rate of customer currency to basic currency. In our case for USD to INR. You can check exchange rate online
+for your customer currency to your currency.
+<br>
+<br>Also you can set default customer currency in customer master. Which will auto fetch in transactions.
+<br>
+<br>
+<img src="{{docs_base_path}}/assets/img/articles/Selection_017.png">&nbsp;
+<br>System has Currency Exchange master, where you can set currency exchange masters for your multiple currencies. To Set this go to Accounts &gt; Setup &gt; Currency Exchange. <br><br><b>Step 4:</b> Select Item details.<br>
+<br>On selecting Item details Sales invoice Total section will look like below image.
+<br>
+<br>
+<img src="{{docs_base_path}}/assets/img/articles/Selection_018.png" width="750">
+<br>
+<br>
+<br>
+<b>Step 5:</b> Save and Submit <br><br>Enter other details like Taxes and charges, Terms and Condition if there and save and submit the invoice form. After submit click on Printer Icon to check print preview. The same document print or email document will you send to your customer or supplier.<br>For our case it will look as below image.<br><br><img src="{{docs_base_path}}/assets/img/articles/Selection_019.png">&nbsp;&nbsp; <br>
+<br>
+<br>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/new-fiscal-year-auto-create-feature.html b/erpnext/docs/user/manual/en/accounts/articles/new-fiscal-year-auto-create-feature.html
new file mode 100644
index 0000000..5b6c10f
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/new-fiscal-year-auto-create-feature.html
@@ -0,0 +1,3 @@
+<h1>New Fiscal Year Auto-Create feature</h1>
+
+New Fiscal Year needs to be created each year at the end of the previous fiscal year. This Process however has been automated in ERPNext.<div><br></div><div>3 days prior to the end of the existing fiscal year; the system shall check if the user has created a new fiscal year for the incoming year. If not the system generates a new fiscal year. All fiscal year Companies are also linked with the new fiscal year as in the previous year.<br><br></div><div><img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2014-12-03 at 5.03.10 pm.png"><br></div>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/pos-view.html b/erpnext/docs/user/manual/en/accounts/articles/pos-view.html
new file mode 100644
index 0000000..fb3c500
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/pos-view.html
@@ -0,0 +1,3 @@
+<h1>POS View</h1>
+
+POS view renders form in a different layout, mainly designed for the quick selection of items. This view has primarily been designed for the retail business, who needs to be quick at invoicing.<div><br></div><div><img src="{{docs_base_path}}/assets/img/articles/$SGrab_219.png"><br></div><div><br></div><div>Using POS View, you can make complete Sales Invoice, without switching to standard form view.<br><div><br></div><div><b>Question: Why do I get error message for missing fields when making Purchase Receipt or other sales/purchase transactions from POS View?</b></div></div><div><br></div><div>Though POS View is mainly designed for Sales Invoice, but it is also made available in all the sales and purchase transactions. In other transactions, POS View is only meant for quick selection of items. This view will not provide all the fields which are available in the standard form view. Hence, you shall use POS View in other transactions just for Item selection, and revert to form view for enter values in other mandatory fields.</div>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/post-dated-cheque-entry.md b/erpnext/docs/user/manual/en/accounts/articles/post-dated-cheque-entry.md
new file mode 100644
index 0000000..12957d9
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/post-dated-cheque-entry.md
@@ -0,0 +1,32 @@
+<h1>Post Dated Cheque Entry</h1>
+
+Post Dated Cheque is a cheque dated on future date given to another party. This actually works as an advance payment which will could be cleared post cheque date only.
+
+In ERPNext, you can manage post dated cheque entries via journal voucher. Following are step to book payment entry for post dated cheque.
+
+####New Journal Voucher
+
+To open new journal voucher go to 
+
+`Accounts > Documents > Journal Voucher > New`
+
+####Set Posting Date and other details
+
+Assuming your Cheque Date is 31st December, 2014 (or any future date) and you need value of this cheque to reflect in the bank balance after cheque date only.
+
+![Journal Voucher]({{docs_base_url}}/assets/img/articles/Selection_005d73bc7.png)
+
+Note: Journal Voucher Reference Date should equal to or less than Posting Date.
+
+####Step 3: Save and Submit Journal Voucher
+
+After entering required details Save and Submit the Journal Voucher.
+
+####Adjusting Post Dated  Cheque Entry
+
+If Post Dated Journal Voucher needs to be adjusted against any invoice, it can be accomplished via [Payment Reconciliation Tool](https://erpnext.com/user-guide/accounts/payment-reconciliation).
+
+When cheque is cleared in the future date, i.e. actual date on the cheque, you can update its Clearance Date via [Bank Reconciliation Tool](https://erpnext.com/user-guide/accounts/bank-reconciliation).
+
+You might find value of this Journal Voucher already reflecting against bank's ledger. You should check **Bank Reconciliation Statement**, a report in the account module to know difference of balance as per system, and balance expected in the bank.
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/pricing-rule.md b/erpnext/docs/user/manual/en/accounts/articles/pricing-rule.md
new file mode 100644
index 0000000..f1caf62
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/pricing-rule.md
@@ -0,0 +1,75 @@
+<h1>Pricing Rule</h1>
+
+Pricing Rule allows you to define rules based on which item's price or discount to be applied is determined.
+
+### Scenario:
+
+Following are the few cases which can be addressed using Pricing Rule.
+
+1. As per the promotional sale policy, if customer purchases more than 10 units of an item, he enjoys 20% discount. 
+
+2. For Customer "XYZ", selling price for the specific or group of "Products" should be updated as ###.
+
+3. Items categorized under specific Item Group has same selling or buying price.
+
+4. Customers catering to specific Customer Group has same selling price.
+
+5. Supplier's categorized under common Supplier Type should have same buying rate applied.
+
+To have %Discount and Price List Rate for an Item auto-applied, you should set Pricing Rules for it.
+
+Pricing Rule master has two sections:
+
+### 1. Applicability Section:
+
+In this section, conditions are set for the Pricing Rule. When transaction meets condition as specified in the Pricing Rule, Price or Discount as specified in the Item master will be applicable. You can set condition on following values.
+
+####1.1 Applicable On:
+
+![Applicable On]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-04-09 at 1.26.23 pm.png)
+
+If you want Pricing Rule to be applied on all the items, you should apply rule based on Item Group, and select most Parent Item Group for a value.
+
+####1.2 Applicable For:
+
+Applicability option will updated based on our selection for Selling or Buying or both. You can set applicability on one of the following master.
+
+![Applicable for]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-04-09 at 1.27.31 pm.png)
+
+####1.3 Quantity:
+
+Specify minimum and maximum qty of an item when this Pricing Rule should be applicable.
+
+![Pricing Rule Qty limit]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-04-09 at 1.28.05 pm.png)
+
+###2. Application:
+
+Using Price List Rule, you can ultimately define price or %discount to be applied on an item.
+
+![Pricing Rule Apply on]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-04-09 at 1.33.24 pm.png)
+
+####2.1 Price
+
+Price or Discount specified in the Pricing Rule will be applied only if above applicability rules are matched with values in the transaction. Price mentioned in Pricing Rule will be given priority over item's Price List rate.
+
+![Pricing Rule Price]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-04-09 at 1.30.27 pm.png)
+
+####2.2 Discount Percentage
+
+Discount Percentage can be applied for a specific Price List. To have it applied for all the Price List, %Discount field should be left blank.
+
+![Rule Discount Percent]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-04-09 at 1.31.01 pm.png)
+
+#### Validity
+
+Enter From and To date between which this Pricing Rule will be applicable. This will be useful if creating Pricing Rule for sales promotion exercise available for certain days.
+
+![Pricing Rule Validity]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-04-09 at 1.36.29 pm.png)
+
+####Disable
+
+Check Disable to inactive specific Pricing Rule.
+
+![Pricing Rule Disabled]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-04-09 at 1.37.38 pm.png)
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/recurring-order-and-invoices.html b/erpnext/docs/user/manual/en/accounts/articles/recurring-order-and-invoices.html
new file mode 100644
index 0000000..6893761
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/recurring-order-and-invoices.html
@@ -0,0 +1,3 @@
+<h1>Recurring Orders and Invoices</h1>
+
+If you have a contract with a <b>Customer</b> where you bill the Customer on a monthly, quarterly, half-yearly or annual basis, you should use recurring feature in orders and invoices. <br><br><h4>Scenario:</h4><br>Subscription for your hosted ERPNext account requires yearly renewal. We use Sales Order for generating proforma invoices. To automate proforma invoicing for renewal, we set original Sales Order as recurring. Recurring proforma invoice is created automatically just before customer's account is about to expire, and requires renewal. This recurring Proforma Invoice is also emailed automatically to the customer.<br><br>Feature of setting document as recurring is available in Sales Order, Sales Invoice, Purchase Order and Purchase Invoice.<br><br>Option to set document as recurring will be visible only after submission. Recurring is last section in document. Check <b>Is Recurring</b> to set document as recurring.<br><br><img src="{{docs_base_path}}/assets/img/articles/is-recurring.gif"><br><br><b>From Date and To Date: </b>This defines contract period with the customer.<br><br><b>Repeat on the Day of Month: </b>If recurring type is set as Monthly, then it will be day of the month on which&nbsp; recurring invoice will be generated.<br><br><b>End Date:</b> Date after which auto-creation of recurring invoice will be stopped.<br><br><b>Notification Email Address:</b> Email Addresses (separated by comma) on which recurring invoice will be emailed when auto-generated.<br><br><b>Recurring ID: </b>Recurring ID will be original document id which will be linked to all corresponding recurring document. For example, original Sales Invoice's id will be updated into all recurring Sales Invoices.<br><br><b>Recurring Print Format:</b> Select a print format to define document view which should be emailed to customer.<br><br><h4>Exception Handling:</h4><p>In a situation where recurring invoice is not created successfully, user with System Manager role is notified about it via email. Also the document on which recurring event failed, "Is Recurring" field is unchecked for it. This means system doesn't try creating recurring invoice for that document again.</p><p>Failure in creation of recurring invoice could be due to multiple reasons like wrong email id mentioned in the Email Notification field in Recurring section etc.</p><p>On receipt of notification, if cause of failure is fixed (like correcting email id) within 24 hours, then recurring invoice will be generated automatically. If issue is not fixed within the said time, then document should be created for that month/year manually.<br></p>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/update-stock-option-in-sales-invoice.html b/erpnext/docs/user/manual/en/accounts/articles/update-stock-option-in-sales-invoice.html
new file mode 100644
index 0000000..106f383
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/update-stock-option-in-sales-invoice.html
@@ -0,0 +1,3 @@
+<h1>Update Stock Option in Sales Invoice</h1>
+
+The <i>Update Stock</i> check box is available in the <i>Items</i> section within <i>Sales Invoice</i> form.<br><br><img src="{{docs_base_path}}/assets/img/articles/kb_updatestk_field.png" height="221" width="603"><br><br>Usually the Sales Invoice is a voucher specifying the amount to be paid against Quantity delivered/to be delivered as per a particular Sales Order.<br><br>Checking the update Stock option before submitting an Invoice will directly deduct the Stock from the Inventory on submission of the Sales Invoice. In such a case the Sales Invoice also satisfies the function of a Delivery Note.<br>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/updating-opening-balance-in-accounts-using-temporary-account.md b/erpnext/docs/user/manual/en/accounts/articles/updating-opening-balance-in-accounts-using-temporary-account.md
new file mode 100644
index 0000000..4962b82
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/updating-opening-balance-in-accounts-using-temporary-account.md
@@ -0,0 +1,44 @@
+<h1>Updating Opening Balance in Accounts using Temporary Account</h1>
+
+For updating opening balances in the Accounts, you will need to use temporary adjustment accounts. In the Chart of Account, two adjustment accounts will be created by default.
+
+1. Temporary Account (Assets)
+2. Temporary Account (Liabilities)
+
+Since ERPNext is a double entry accounting system, it requires balancing on debit side with credit side in an accounting entry. When start working on fresh ERPNext account, you will have to update opening balance in your Balance Sheet accounts. You can update opening balance in account(s), and use Temporary Account for balancing purpose.
+
+Let's consider a scenario of updating opening balance in an Account using temporary account.
+
+#### Identifying Accounts to Update Opening Balance
+
+Say we have following customer's ledger, and have receivable from them. This receivable should be updated as opening balance in their account.
+
+1. Comtek Solutions
+1. Walky Tele Solution
+
+Also we can update opening balance on Bank and Cash account.
+
+1. Bank of Baroda
+1. Cash
+
+All these accounts are located on the Current Asset side, hence will have Debit balance.
+
+#### Identifying Temporary Account
+
+To update debit balance in them, we will have to select Credit account for balancing it. Out of the temporary accounts available, we can use `Temporary Account (Liabilities)`.
+
+##### Opening Balance Entry
+
+For Current Asset account, their current balance will be updated on the Debit side. The total value of Debit will be entered as Credit Balance for the Temporary Account (Liability).
+
+![Debit Opening Balance]({{docs_base_url}}/assets/img/articles/$SGrab_431.png)
+
+Same way, you will update opening balance for the liability account. Since Liability accounts will have credit balance, you will have to select Temporary Account (Asset), which is a Debit account for balancing purpose.
+
+After you have updated opening balance in all the Asset and Liability account, you will find that balance in the temporary account will be equal. If balance in temporary accounts is not equal, it must be because opening balance is not updated in some account, or other account was used for balancing purpose.
+
+Since temporary account were used only for balancing purpose, it shall not have any balance in it. To nullify balance in these accounts, you should create a Journal Voucher which will set balance as zero in these account.
+
+![Temporary Account Nullified]({{docs_base_url}}/assets/img/articles/$SGrab_432.png)
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/what-is-the-differences-of-total-and-valuation-in-tax-and-charges.html b/erpnext/docs/user/manual/en/accounts/articles/what-is-the-differences-of-total-and-valuation-in-tax-and-charges.html
new file mode 100644
index 0000000..3d1c7db
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/what-is-the-differences-of-total-and-valuation-in-tax-and-charges.html
@@ -0,0 +1,34 @@
+<h1>Purchase Tax or Charges Categories</h1>
+
+Consider Tax or Charge field in Purchase Taxes and Charges master has three values.<br><br><ol>
+    <li>Total</li>
+    <li>Valuation</li>
+    <li>Total and Valuation<br><br><img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2015-04-15 at 6.04.02 pm.png"><br></li>
+</ol>
+<p>Let's consider an example to understand an effect of value selected in Consider Tax or Charge field.</p>
+<p>We purchase 10 units of item, at the rate of 800, total purchase amount would be 800. Purchased item has 4% VAT tax and INR 100 transportation charges were incurred.
+
+</p><h4>Total:</h4>
+
+<p>An amount of tax/charge categorized Total will be accounted in the total of purchase transactions, but not in the value of purchased item.</p>
+<p>If VAT 4% is applied on item, it will amount to INR 32. Since VAT is the <a href="https://frappe.io/blog/erpnext-features/managing-consumption-tax" target="_blank">consumption tax</a>, its should be added value of Purchase Order/Invoice, since it will
+    be included in payable towards supplier, but its should not be added to the value of Purchased item.</p>
+<p>Hence for tax or charge you wish to be added to transaction total but not to the valuation of item, it should be categorized as Total.</p>
+<p>When Purchase Invoice is submitted, value of tax/charge is booked in respective account.
+    <br>
+</p>
+<h4>Valuation:</h4>
+<p>An amount of tax/charge categorized as Valuation will be added in the value of purchased item, but will not be added to the value of purchase transaction.</p>
+<p>Transportation charge of INR 100 should be categorized as valuation. With this, the value of purchased item will be increased from 800 to 900. Also, it will be not be added to the total of purchase transaction, because it should not be reflected to supplier,
+    as it will be irrelevant for them.
+    <br>
+</p>
+<p>When Purchase Invoice is submitted, value of tax/charge is booked in respective account. Transportation expense will be booked
+    <br>
+</p>
+<h4>Total and Valuation:</h4>
+<p>An amount of tax/charge categorized as for Total and Valuation will be added in the value of purchase item, as well as will be included in the totals of purchase transactions.</p>
+<p>Let's assume that transporter was arranged by our supplier, but we need to pay transportation charges to them. In that case, for transportation charges, category selected should be Total and Valuation. With this INR 100 transportation charges will be
+    added to actual purchase amount of INR 800. Also, INR 100 will reflect in the total, as it will be payable for us towards supplier.
+    <br>
+</p>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/accounts/articles/withdrawing-salary-from-owners-equity-account.md b/erpnext/docs/user/manual/en/accounts/articles/withdrawing-salary-from-owners-equity-account.md
new file mode 100644
index 0000000..860f6eb
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/articles/withdrawing-salary-from-owners-equity-account.md
@@ -0,0 +1,21 @@
+<h1>WIthdrawing Salary from Owner's Equity Account</h1>
+
+### Question
+
+After meeting with my accountant here in the US, I was informed that with my company being a sole member, I should not pay myself a salary that would hit the direct expenses account but instead should take a "draw" that hits the balance sheet and not the expenses. Can you please advise how I should set this up in ERP Next please?
+
+### Answer
+
+1. Create an account for **Owner's Equity** under Liabilities if you already do not have. This account will be your investment in the business and the accumulated profits (or losses). It will have a "Credit" type balance.
+2. In an Version 5, Equity will be a new head (not under Liabilities). (In either case Assets = Owner's Equity + Liabilities, so your balance sheet will be okay [Learn more about owner's equity account](http://www.accountingcoach.com/blog/what-is-owners-equity)).
+3. Create an account for **Owner's Draws** under **Owner's Equity**.
+4. Note that the balance of **Owner's Draws** will always be negative since you are reducing money from your total equity / profits.
+
+### Example
+
+Example journal entry (using Journal Voucher in ERPNext) for a withdrawal of $1000 would be:
+
+1. Credit **Cash** $1000
+2. Debit **Owner's Draws** $1000
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/accounts/budgeting.md b/erpnext/docs/user/manual/en/accounts/budgeting.md
similarity index 76%
rename from erpnext/docs/user/guides/accounts/budgeting.md
rename to erpnext/docs/user/manual/en/accounts/budgeting.md
index 8733aa4..a5f35d2 100644
--- a/erpnext/docs/user/guides/accounts/budgeting.md
+++ b/erpnext/docs/user/manual/en/accounts/budgeting.md
@@ -16,13 +16,13 @@
 
 #### Step 1: Click on Edit.
 
-![]({{url_prefix}}/assets/old_images/erpnext/budgeting-1.png)  
+![]({{docs_base_url}}/assets/old_images/erpnext/budgeting-1.png)  
 
-<img alt="Accounts Receivable" class="screenshot" src="{{url_prefix}}/assets/img/accounts/accounts-receivable.png">
+<img alt="Accounts Receivable" class="screenshot" src="{{docs_base_url}}/assets/img/accounts/accounts-receivable.png">
 
 #### Step 2: Enter Monthly Distribution.
 
-![]({{url_prefix}}/assets/old_images/erpnext/budgeting-2-1.png)
+![]({{docs_base_url}}/assets/old_images/erpnext/budgeting-2-1.png)
 
 
 If you leave the** **distribution ID blank, ERPNext will calculate on a yearly
@@ -32,7 +32,7 @@
 
 
 
-![]({{url_prefix}}/assets/old_images/erpnext/budgeting-3.png)  
+![]({{docs_base_url}}/assets/old_images/erpnext/budgeting-3.png)  
 
 
 
@@ -41,13 +41,13 @@
 ERPNext allows you to take a few budget actions. It signifies whether to stop
 , warn or Ignore  if you exceed budgets.  
 
-![]({{url_prefix}}/assets/old_images/erpnext/budgeting-4.png)
+![]({{docs_base_url}}/assets/old_images/erpnext/budgeting-4.png)
 
 
 
 These can be defined from the Company record.
 
-![]({{url_prefix}}/assets/old_images/erpnext/budgeting-4-1.png)  
+![]({{docs_base_url}}/assets/old_images/erpnext/budgeting-4-1.png)  
 
 
 
diff --git a/erpnext/docs/user/guides/accounts/chart-of-accounts.md b/erpnext/docs/user/manual/en/accounts/chart-of-accounts.md
similarity index 91%
rename from erpnext/docs/user/guides/accounts/chart-of-accounts.md
rename to erpnext/docs/user/manual/en/accounts/chart-of-accounts.md
index 148ef02..99760e7 100644
--- a/erpnext/docs/user/guides/accounts/chart-of-accounts.md
+++ b/erpnext/docs/user/manual/en/accounts/chart-of-accounts.md
@@ -22,7 +22,7 @@
 Financial statement of your company is easily viewable in ERPNext. An Example
 of a financial statement is given below:
 
-<img class="screenshot" alt="Financial Analytics Balance Sheet" src="{{url_prefix}}/assets/img/accounts/financial-analytics-bl.png">
+<img class="screenshot" alt="Financial Analytics Balance Sheet" src="{{docs_base_url}}/assets/img/accounts/financial-analytics-bl.png">
 
 To edit your Chart of Accounts in ERPNext go to:
 
@@ -37,7 +37,7 @@
 
 Let us understand the main groups of the Chart of Accounts.
 
-<img class="screenshot" alt="Chart of Accounts" src="{{url_prefix}}/assets/img/accounts/chart-of-accounts-1.png">
+<img class="screenshot" alt="Chart of Accounts" src="{{docs_base_url}}/assets/img/accounts/chart-of-accounts-1.png">
 
 ### Balance Sheet Accounts
 
@@ -75,7 +75,7 @@
 In ERPNext it is easy to create a Profit and Loss analysis chart. An example
 of a Profit and Loss analysis chart is given below:
 
-<img class="screenshot" alt="Financial Analytics Profit and Loss Statement" src="{{url_prefix}}/assets/img/accounts/financial-analytics-pl.png">
+<img class="screenshot" alt="Financial Analytics Profit and Loss Statement" src="{{docs_base_url}}/assets/img/accounts/financial-analytics-pl.png">
 
 (On the first day of the year you have not made any profit or loss, but you
 still have assets, hence balance sheet accounts never become zero at the
@@ -95,7 +95,7 @@
 
 > Note: An Account “Ledger” is also sometimes called as Account “Head”.
 
-<img class="screenshot" alt="Chart of Accounts" src="{{url_prefix}}/assets/img/accounts/chart-of-accounts-2.png">
+<img class="screenshot" alt="Chart of Accounts" src="{{docs_base_url}}/assets/img/accounts/chart-of-accounts-2.png">
 
 ### Other Account Types
 
@@ -110,7 +110,7 @@
 group under which you want to create the new Account. On the right side, you
 will see an option to “Open” or “Add Child” a new Account.
 
-<img class="screenshot" alt="Chart of Accounts" src="{{url_prefix}}/assets/img/accounts/chart-of-accounts-3.png">
+<img class="screenshot" alt="Chart of Accounts" src="{{docs_base_url}}/assets/img/accounts/chart-of-accounts-3.png">
 
 Option to create will only appear if you click on a Group (folder) type
 Account.
diff --git a/erpnext/docs/user/guides/accounts/credit-limit.md b/erpnext/docs/user/manual/en/accounts/credit-limit.md
similarity index 81%
rename from erpnext/docs/user/guides/accounts/credit-limit.md
rename to erpnext/docs/user/manual/en/accounts/credit-limit.md
index df7f7f6..299e670 100644
--- a/erpnext/docs/user/guides/accounts/credit-limit.md
+++ b/erpnext/docs/user/manual/en/accounts/credit-limit.md
@@ -12,7 +12,7 @@
   
 #### Figure 1: Credit Limit
 
-<img class="screenshot" alt="Credit Limit" src="{{url_prefix}}/assets/img/accounts/credit-limit-1.png">
+<img class="screenshot" alt="Credit Limit" src="{{docs_base_url}}/assets/img/accounts/credit-limit-1.png">
 
 Go to the 'More Info section' and enter the amount in the field Credit Limit.
 
@@ -27,7 +27,7 @@
   
 #### Figure 2: Credit Controller
 
-<img class="screenshot" alt="Credit Limit" src="{{url_prefix}}/assets/img/accounts/credit-limit-2.png">
+<img class="screenshot" alt="Credit Limit" src="{{docs_base_url}}/assets/img/accounts/credit-limit-2.png">
 
 Save the changes.
 
diff --git a/erpnext/docs/user/guides/accounts/index.md b/erpnext/docs/user/manual/en/accounts/index.md
similarity index 100%
rename from erpnext/docs/user/guides/accounts/index.md
rename to erpnext/docs/user/manual/en/accounts/index.md
diff --git a/erpnext/docs/user/guides/accounts/index.txt b/erpnext/docs/user/manual/en/accounts/index.txt
similarity index 96%
rename from erpnext/docs/user/guides/accounts/index.txt
rename to erpnext/docs/user/manual/en/accounts/index.txt
index 5a4a391..323764e 100644
--- a/erpnext/docs/user/guides/accounts/index.txt
+++ b/erpnext/docs/user/manual/en/accounts/index.txt
@@ -14,4 +14,5 @@
 point-of-sale-pos-invoice
 multi-currency-accounting
 tools
-setup
\ No newline at end of file
+setup
+articles
diff --git a/erpnext/docs/user/guides/accounts/item-wise-tax.md b/erpnext/docs/user/manual/en/accounts/item-wise-tax.md
similarity index 84%
rename from erpnext/docs/user/guides/accounts/item-wise-tax.md
rename to erpnext/docs/user/manual/en/accounts/item-wise-tax.md
index fbc5743..8c1fc86 100644
--- a/erpnext/docs/user/guides/accounts/item-wise-tax.md
+++ b/erpnext/docs/user/manual/en/accounts/item-wise-tax.md
@@ -5,7 +5,7 @@
 
 Item master has tax table where you can list taxes which will be applied on it.
 
-![Item wise Tax]({{url_prefix}}/assets/old_images/erpnext/item-wise-tax.png)
+![Item wise Tax]({{docs_base_url}}/assets/old_images/erpnext/item-wise-tax.png)
 
 Tax rate mentioned in the item master gets preference over tax rate entered in the transactions. 
 
@@ -17,7 +17,7 @@
 
 For example, if few items has VAT 5 applied on them, other has Service Tax applied, and some other has Excise Duty applicable, then you tax master should have all these taxes selected.
 
-![item wise tax master]({{url_prefix}}/assets/old_images/erpnext/item-wise-tax-master.png)
+![item wise tax master]({{docs_base_url}}/assets/old_images/erpnext/item-wise-tax-master.png)
 
 ####Step 3: Set Tax Rate as Zero in Taxes and Charges Template
 
@@ -25,6 +25,6 @@
 
 Based on the above setting, you will have taxes applied on items as mentioned in the respective item master. Check following for an instance.
 
-![item wise tax calculation]({{url_prefix}}/assets/old_images/erpnext/item-wise-tax-calc.png)
+![item wise tax calculation]({{docs_base_url}}/assets/old_images/erpnext/item-wise-tax-calc.png)
 
 {next}
diff --git a/erpnext/docs/user/guides/accounts/journal-entry.md b/erpnext/docs/user/manual/en/accounts/journal-entry.md
similarity index 95%
rename from erpnext/docs/user/guides/accounts/journal-entry.md
rename to erpnext/docs/user/manual/en/accounts/journal-entry.md
index 9da656d..68ba22a 100644
--- a/erpnext/docs/user/guides/accounts/journal-entry.md
+++ b/erpnext/docs/user/manual/en/accounts/journal-entry.md
@@ -7,7 +7,7 @@
 
 > Accounts > Documents > Journal Entry > New
 
-<img class="screenshot" alt="Journal Entry" src="{{url_prefix}}/assets/img/accounts/journal-entry.png">
+<img class="screenshot" alt="Journal Entry" src="{{docs_base_url}}/assets/img/accounts/journal-entry.png">
 
 In a Journal Entry, you must select.
 
diff --git a/erpnext/docs/user/guides/accounts/making-payments.md b/erpnext/docs/user/manual/en/accounts/making-payments.md
similarity index 93%
rename from erpnext/docs/user/guides/accounts/making-payments.md
rename to erpnext/docs/user/manual/en/accounts/making-payments.md
index 3b6209c..2038e6f 100644
--- a/erpnext/docs/user/guides/accounts/making-payments.md
+++ b/erpnext/docs/user/manual/en/accounts/making-payments.md
@@ -6,7 +6,7 @@
   3. Enter the cheque number, cheque date.
   4. Save and Submit.
 
-<img class="screenshot" alt="Manking Payment" src="{{url_prefix}}/assets/img/accounts/make-payment.png">
+<img class="screenshot" alt="Manking Payment" src="{{docs_base_url}}/assets/img/accounts/make-payment.png">
 
 Payments can also be made independent of invoices by creating a new Journal
 Voucher and selecting the type of payment.
@@ -29,7 +29,7 @@
 
 ### Example Payment Journal Entry
 
-<img class="screenshot" alt="Manking Payment" src="{{url_prefix}}/assets/img/accounts/new-bank-entry.png">
+<img class="screenshot" alt="Manking Payment" src="{{docs_base_url}}/assets/img/accounts/new-bank-entry.png">
 
 * * *
 
diff --git a/erpnext/docs/user/guides/accounts/multi-currency-accounting.md b/erpnext/docs/user/manual/en/accounts/multi-currency-accounting.md
similarity index 85%
rename from erpnext/docs/user/guides/accounts/multi-currency-accounting.md
rename to erpnext/docs/user/manual/en/accounts/multi-currency-accounting.md
index 0b01110..a674f21 100644
--- a/erpnext/docs/user/guides/accounts/multi-currency-accounting.md
+++ b/erpnext/docs/user/manual/en/accounts/multi-currency-accounting.md
@@ -4,15 +4,15 @@
 
 To get started with multi-currency accounting, you need to assign accounting currency in Account record. You can define Currency from Chart of Accounts while creating Account.
 
-<img class="screenshot" alt="Set Currency from Chart of Accounts"  	src="{{url_prefix}}/assets/img/accounts/multi-currency/chart-of-accounts.png">
+<img class="screenshot" alt="Set Currency from Chart of Accounts"  	src="{{docs_base_url}}/assets/img/accounts/multi-currency/chart-of-accounts.png">
 
 You can also assign / modify the currency by opening specific Account record for existing Accounts.
 
-<img class="screenshot" alt="Modify Account Currency"  	src="{{url_prefix}}/assets/img/accounts/multi-currency/account.png">
+<img class="screenshot" alt="Modify Account Currency"  	src="{{docs_base_url}}/assets/img/accounts/multi-currency/account.png">
 
 For Customer / Supplier (Party), you can also define it's accounting currency in the Party record. If the Party's accounting currency is different from Company Currency, you have to mention Default Receivable / Payable Account in that currency.
 
-<img class="screenshot" alt="Customer Accounting Currency"  	src="{{url_prefix}}/assets/img/accounts/multi-currency/customer.png">
+<img class="screenshot" alt="Customer Accounting Currency"  	src="{{docs_base_url}}/assets/img/accounts/multi-currency/customer.png">
 
 
 Once you defined Accounting Currency in Party / Account record, you are ready to make transactions against them. If Party's accounting currency is different from Company Currency, system will restrict to make transaction for that party with that currency only. If accounting currency is same as Company Currency, you can make transactions for that Party in any currency. But accounting entries (GL Entries) will always be in Party's Accounting Currency. In any case, currency of Receivable Account will always be same as accounting currency of the Party.
@@ -31,7 +31,7 @@
 
 Outstanding Amount and Advance Amount will always be calculated and shown in Customer's Account Currency.
 
-<img class="screenshot" alt="Sales Invoice Outstanding"  	src="{{url_prefix}}/assets/img/accounts/multi-currency/sales-invoice.png">
+<img class="screenshot" alt="Sales Invoice Outstanding"  	src="{{docs_base_url}}/assets/img/accounts/multi-currency/sales-invoice.png">
 
 ### Purchase Invoice
 
@@ -41,14 +41,14 @@
 
 In Journal Entry, you can make transactions in different currencies. There is a checkbox "Multi Currency", to enable multi-currency entries. If "Multi Currency" option selected, you will be able to select accounts with different currencies.
 
-<img class="screenshot" alt="Journal Entry Exchange Rate"  	src="{{url_prefix}}/assets/img/accounts/multi-currency/journal-entry-multi-currency.png">
+<img class="screenshot" alt="Journal Entry Exchange Rate"  	src="{{docs_base_url}}/assets/img/accounts/multi-currency/journal-entry-multi-currency.png">
 
  
 In Accounts table, on selection of foreign currency account, system will show Currency section and fetch Account Currency and Exchange Rate automatically. You can change / modify the Exchange Rate later manually.
 
 In a single Journal Entry, you can select accounts with only one alternate currency, apart from accounts in Company Currency. Debit / Credit amount should be entered in Account Currency, system will calculate and show the Debit / Credit amount in Company Currency automatically.
 
-<img class="screenshot" alt="Journal Entry in multi currency"  	src="{{url_prefix}}/assets/img/accounts/multi-currency/journal-entry-row.png">
+<img class="screenshot" alt="Journal Entry in multi currency"  	src="{{docs_base_url}}/assets/img/accounts/multi-currency/journal-entry-row.png">
 
 #### Example 1: Payment Entry  Against Customer With Alternate Currency
 
@@ -56,7 +56,7 @@
 
 Exchange Rate in the payment entry should always be same as invoice (60), even if exchange rate on the payment date is 62. The bank account will be credited by the amount considering exchange rate as 62. Hence, Exchnage Gain / Loss will be booked based on exchange rate difference.
 
-<img class="screenshot" alt="Payment Entry"  	src="{{url_prefix}}/assets/img/accounts/multi-currency/payment-entry.png">
+<img class="screenshot" alt="Payment Entry"  	src="{{docs_base_url}}/assets/img/accounts/multi-currency/payment-entry.png">
 
 #### Example 2: Inter-bank Transfer (USD -> INR)
 
@@ -101,7 +101,7 @@
 
 Suppose, Exchange Rate on the payment date is 62 and Bank Transfer Entry will be look like below:
 
-<img class="screenshot" alt="Inter Bank Transfer"  	src="{{url_prefix}}/assets/img/accounts/multi-currency/bank-transfer.png">
+<img class="screenshot" alt="Inter Bank Transfer"  	src="{{docs_base_url}}/assets/img/accounts/multi-currency/bank-transfer.png">
 
 
 ## Reports
@@ -110,10 +110,10 @@
 
 In General Ledger, system shows debit / credit amount in both currency if filtered by an Account and Account Currency is different from Company Currency.
 
-<img class="screenshot" alt="General Ledger Report"  	src="{{url_prefix}}/assets/img/accounts/multi-currency/general-ledger.png">
+<img class="screenshot" alt="General Ledger Report"  	src="{{docs_base_url}}/assets/img/accounts/multi-currency/general-ledger.png">
 
 ### Accounts Receivable / Payable
 
 In Accounts Receivable / Payable report, system shows all the amounts in Party / Account Currency.
 
-<img class="screenshot" alt="Accounts Receivable Report"  	src="{{url_prefix}}/assets/img/accounts/multi-currency/accounts-receivable.png">
\ No newline at end of file
+<img class="screenshot" alt="Accounts Receivable Report"  	src="{{docs_base_url}}/assets/img/accounts/multi-currency/accounts-receivable.png">
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/accounts/opening-accounts.md b/erpnext/docs/user/manual/en/accounts/opening-accounts.md
similarity index 89%
rename from erpnext/docs/user/guides/accounts/opening-accounts.md
rename to erpnext/docs/user/manual/en/accounts/opening-accounts.md
index 1a39ed6..214642d 100644
--- a/erpnext/docs/user/guides/accounts/opening-accounts.md
+++ b/erpnext/docs/user/manual/en/accounts/opening-accounts.md
@@ -23,7 +23,7 @@
 
 You can select accounts based on the voucher type. In such a scenario, your balance sheet should be balanced.
 
-<img class="screenshot" alt="Opening Account" src="{{url_prefix}}/assets/img/accounts/opening-account-1.png">
+<img class="screenshot" alt="Opening Account" src="{{docs_base_url}}/assets/img/accounts/opening-account-1.png">
 
  Also, note that if there are more than 300 ledgers, the system will crash. Thus to avoid such a situation, you can open accounts by using temporary accounts.
 
@@ -46,16 +46,16 @@
 
 Complete Journal Entries on the Debit and Credit side.
 
-![Opening Entry]({{url_prefix}}/assets/old_images/erpnext/opening-entry-1.png)
+![Opening Entry]({{docs_base_url}}/assets/old_images/erpnext/opening-entry-1.png)
 
  To update opening balance is to make Journal Entry for an individual/group of accounts.
 
 For example, if you want to update balance in three bank accounts, then make Journal Entrys in this manner.
 
-![Opening Temp Entry]({{url_prefix}}/assets/old_images/erpnext/image-temp-opening.png)
+![Opening Temp Entry]({{docs_base_url}}/assets/old_images/erpnext/image-temp-opening.png)
 
 
-![Opening Entry]({{url_prefix}}/assets/old_images/erpnext/opening-entry-2.png)
+![Opening Entry]({{docs_base_url}}/assets/old_images/erpnext/opening-entry-2.png)
 
 Temporary Asset and Liability account is used for balancing purpose. When you update opening balance in Liability Account, you can use Temporary Asset Account for balancing.
 
@@ -72,7 +72,7 @@
 like the one given below:
 
 
-![Trial Balance]({{url_prefix}}/assets/old_images/erpnext/trial-balance-1.png)
+![Trial Balance]({{docs_base_url}}/assets/old_images/erpnext/trial-balance-1.png)
 
 #### Outstanding Invoices
 
diff --git a/erpnext/docs/user/guides/accounts/opening-entry.md b/erpnext/docs/user/manual/en/accounts/opening-entry.md
similarity index 62%
rename from erpnext/docs/user/guides/accounts/opening-entry.md
rename to erpnext/docs/user/manual/en/accounts/opening-entry.md
index 2f341a1..c6eb94d 100644
--- a/erpnext/docs/user/guides/accounts/opening-entry.md
+++ b/erpnext/docs/user/manual/en/accounts/opening-entry.md
@@ -2,6 +2,6 @@
 going to chart of accounts.
 
 However, if you are migrating from a legacy accounting system like Tally or a
-Fox Pro based software, please visit [Opening Entry.]({{url_prefix}}/user/guides/accounts/opening-accounts.html)
+Fox Pro based software, please visit [Opening Entry.]({{docs_base_url}}/user/guides/accounts/opening-accounts.html)
 
 {next}
diff --git a/erpnext/docs/user/guides/accounts/point-of-sale-pos-invoice.md b/erpnext/docs/user/manual/en/accounts/point-of-sale-pos-invoice.md
similarity index 92%
rename from erpnext/docs/user/guides/accounts/point-of-sale-pos-invoice.md
rename to erpnext/docs/user/manual/en/accounts/point-of-sale-pos-invoice.md
index dbcfc00..e45b460 100644
--- a/erpnext/docs/user/guides/accounts/point-of-sale-pos-invoice.md
+++ b/erpnext/docs/user/manual/en/accounts/point-of-sale-pos-invoice.md
@@ -19,7 +19,7 @@
 In ERPNext all Sales and Purchase transactions, like Sales Invoice, Quotation, Sales Order, Purchase Order etc. can be edited via the POS. There two steps to Setup POS:
 
 1. Enable POS View via (Setup > Customize > Feature Setup)
-2. Create a [POS Setting]({{url_prefix}}/user/guides/setting-up/pos-setting.html) record
+2. Create a [POS Setting]({{docs_base_url}}/user/guides/setting-up/pos-setting.html) record
 
 #### Switch to POS View
 
@@ -42,7 +42,7 @@
 
 **Barcode / Serial No** \- A Barcode / Serial No is an optical machine-readable representation of data relating to the object to which it is attached. Enter Barcode / Serial No in the box as shown in the image below and pause for a second, the item will be automatically added to the cart.
 
-![POS]({{url_prefix}}/assets/old_images/erpnext/pos-add-item.png)
+![POS]({{docs_base_url}}/assets/old_images/erpnext/pos-add-item.png)
 
 > Tip: To change the quantity of an Item, enter your desired quantity in the
 quantity box. These are mostly used if the same Item is purchased in bulk.
@@ -63,7 +63,7 @@
 
 > Delete button appears only when Items are selected.
 
-![POS]({{url_prefix}}/assets/old_images/erpnext/pos-remove-item.png)
+![POS]({{docs_base_url}}/assets/old_images/erpnext/pos-remove-item.png)
 
 ### Make Payment
 
@@ -74,7 +74,7 @@
   2. Select your “Mode of Payment”.
   3. Click on “Pay” button to Save the document.
 
-![POS Payment]({{url_prefix}}/assets/old_images/erpnext/pos-make-payment.png)
+![POS Payment]({{docs_base_url}}/assets/old_images/erpnext/pos-make-payment.png)
 
 Submit the document to finalise the record. After the document is submitted,
 you can either print or email it directly to the customer.
diff --git a/erpnext/docs/user/guides/accounts/purchase-invoice.md b/erpnext/docs/user/manual/en/accounts/purchase-invoice.md
similarity index 95%
rename from erpnext/docs/user/guides/accounts/purchase-invoice.md
rename to erpnext/docs/user/manual/en/accounts/purchase-invoice.md
index ce1aae8..433219c 100644
--- a/erpnext/docs/user/guides/accounts/purchase-invoice.md
+++ b/erpnext/docs/user/manual/en/accounts/purchase-invoice.md
@@ -9,7 +9,7 @@
 
 or click on “Make Purchase Invoice” in Purchase Order or Purchase Receipt.
 
-<img class="screenshot" alt="Purchase Invoice" src="{{url_prefix}}/assets/img/accounts/purchase-invoice.png">
+<img class="screenshot" alt="Purchase Invoice" src="{{docs_base_url}}/assets/img/accounts/purchase-invoice.png">
 
 The concept of “Posting Date” is again same as Sales Invoice. “Bill No” and
 “Bill Date” helps to track the bill number as set by your Supplier for
diff --git a/erpnext/docs/user/guides/accounts/sales-invoice.md b/erpnext/docs/user/manual/en/accounts/sales-invoice.md
similarity index 96%
rename from erpnext/docs/user/guides/accounts/sales-invoice.md
rename to erpnext/docs/user/manual/en/accounts/sales-invoice.md
index 5c95b31..f9a453e 100644
--- a/erpnext/docs/user/guides/accounts/sales-invoice.md
+++ b/erpnext/docs/user/manual/en/accounts/sales-invoice.md
@@ -6,7 +6,7 @@
 
 or Click on Make Invoice at the right hand corner of the Delivery Note.
 
-<img class="screenshot" alt="Sales Invoice" src="{{url_prefix}}/assets/img/accounts/sales-invoice.png">
+<img class="screenshot" alt="Sales Invoice" src="{{docs_base_url}}/assets/img/accounts/sales-invoice.png">
 
 #### Accounting Impact
 
diff --git a/erpnext/docs/user/guides/accounts/setup/accounts-settings.md b/erpnext/docs/user/manual/en/accounts/setup/accounts-settings.md
similarity index 78%
rename from erpnext/docs/user/guides/accounts/setup/accounts-settings.md
rename to erpnext/docs/user/manual/en/accounts/setup/accounts-settings.md
index 8465679..5242b39 100644
--- a/erpnext/docs/user/guides/accounts/setup/accounts-settings.md
+++ b/erpnext/docs/user/manual/en/accounts/setup/accounts-settings.md
@@ -1,5 +1,5 @@
 
-<img class="screenshot" alt="Account Settings" src="{{url_prefix}}/assets/img/accounts/account-settings.png">
+<img class="screenshot" alt="Account Settings" src="{{docs_base_url}}/assets/img/accounts/account-settings.png">
 
 * Accounts Frozen Upto: Freeze accounting transactions upto specified date, nobody can make / modify entry except specified role.
 
diff --git a/erpnext/docs/user/guides/accounts/setup/cost-center.md b/erpnext/docs/user/manual/en/accounts/setup/cost-center.md
similarity index 93%
rename from erpnext/docs/user/guides/accounts/setup/cost-center.md
rename to erpnext/docs/user/manual/en/accounts/setup/cost-center.md
index 79f1a3c..8b9fcc1 100644
--- a/erpnext/docs/user/guides/accounts/setup/cost-center.md
+++ b/erpnext/docs/user/manual/en/accounts/setup/cost-center.md
@@ -32,7 +32,7 @@
 
 > Accounts > Setup > Chart of Cost Centers
 
-![Chart of Cost Center]({{url_prefix}}/assets/old_images/erpnext/chart-of-cost-centers.png)
+![Chart of Cost Center]({{docs_base_url}}/assets/old_images/erpnext/chart-of-cost-centers.png)
 
 Cost centers help you in one more activity, budgeting.
 
@@ -53,7 +53,7 @@
 
 > Accounts > Setup > Budget Distribution > New Budget Distribution
 
-![Budget Distribution]({{url_prefix}}/assets/old_images/erpnext/budgeting.png)
+![Budget Distribution]({{docs_base_url}}/assets/old_images/erpnext/budgeting.png)
 
 #### Budget Actions
 
diff --git a/erpnext/docs/user/guides/accounts/setup/fiscal-year.md b/erpnext/docs/user/manual/en/accounts/setup/fiscal-year.md
similarity index 92%
rename from erpnext/docs/user/guides/accounts/setup/fiscal-year.md
rename to erpnext/docs/user/manual/en/accounts/setup/fiscal-year.md
index 5509e2f..618d20b 100644
--- a/erpnext/docs/user/guides/accounts/setup/fiscal-year.md
+++ b/erpnext/docs/user/manual/en/accounts/setup/fiscal-year.md
@@ -18,6 +18,6 @@
 income will be for that year, and can adjust their expenses to maintain their
 desired profit margins.
 
-<img class="screenshot" alt="Fiscal Year" src="{{url_prefix}}/assets/img/accounts/fiscal-year.png">
+<img class="screenshot" alt="Fiscal Year" src="{{docs_base_url}}/assets/img/accounts/fiscal-year.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/accounts/setup/index.md b/erpnext/docs/user/manual/en/accounts/setup/index.md
similarity index 100%
rename from erpnext/docs/user/guides/accounts/setup/index.md
rename to erpnext/docs/user/manual/en/accounts/setup/index.md
diff --git a/erpnext/docs/user/guides/accounts/setup/index.txt b/erpnext/docs/user/manual/en/accounts/setup/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/accounts/setup/index.txt
rename to erpnext/docs/user/manual/en/accounts/setup/index.txt
diff --git a/erpnext/docs/user/manual/en/accounts/setup/tax-rule.md b/erpnext/docs/user/manual/en/accounts/setup/tax-rule.md
new file mode 100644
index 0000000..72ecf11
--- /dev/null
+++ b/erpnext/docs/user/manual/en/accounts/setup/tax-rule.md
@@ -0,0 +1,21 @@
+You can define which [Tax Template]({{docs_base_url}}/user/guides/setting-up/setting-up-taxes.html) must be applied on a Sales / Purchase transaction using Tax Rule.
+
+<img class="screenshot" alt="Tax Rule" src="{{docs_base_url}}/assets/img/accounts/tax-rule.png">
+
+You can define Tax Rules for Sales or Purchase Taxes. 
+While making a Transaction the system will select and apply tax template based on the tax rule defined.
+The system selects Tax Rule with maximum matching Filters.
+
+Let us consider a senario to understand Tax Rule Better.
+
+Suppose we define 2 Tax Rules as below.
+
+<img class="screenshot" alt="Tax Rule" src="{{docs_base_url}}/assets/img/accounts/tax-rule-1.png">
+
+<img class="screenshot" alt="Tax Rule" src="{{docs_base_url}}/assets/img/accounts/tax-rule-2.png">
+
+Here Tax Rule 1 has Billing Country as India and Tax Rule 2 has Billing Country as United Kingdom
+
+Now supposed we try to create a Sales Order for a customer whose default Billing Country is India, system shall select Tax Rule 1.
+In case the customers Billing Country was United Kingdom, the system would have selected Tax Rule 2.
+
diff --git a/erpnext/docs/user/guides/accounts/tools/bank-reconciliation.md b/erpnext/docs/user/manual/en/accounts/tools/bank-reconciliation.md
similarity index 89%
rename from erpnext/docs/user/guides/accounts/tools/bank-reconciliation.md
rename to erpnext/docs/user/manual/en/accounts/tools/bank-reconciliation.md
index 1fd0b37..f2afe76 100644
--- a/erpnext/docs/user/guides/accounts/tools/bank-reconciliation.md
+++ b/erpnext/docs/user/manual/en/accounts/tools/bank-reconciliation.md
@@ -15,7 +15,7 @@
 
 #### Figure 1: Bank Reconciliation Statement
 
-![]({{url_prefix}}/assets/old_images/erpnext/bank-reconciliation-2.png)  
+![]({{docs_base_url}}/assets/old_images/erpnext/bank-reconciliation-2.png)  
 
   
 
@@ -45,7 +45,7 @@
 
 #### Figure 2: Bank Reconciliation Tool
 
-<img class="screenshot" alt="Bank Reconciliation" src="{{url_prefix}}/assets/img/accounts/bank-reconciliation.png">
+<img class="screenshot" alt="Bank Reconciliation" src="{{docs_base_url}}/assets/img/accounts/bank-reconciliation.png">
 
 __Step 5:__ Click on the button 'Update Clearance Date'.
  
diff --git a/erpnext/docs/user/guides/accounts/tools/index.md b/erpnext/docs/user/manual/en/accounts/tools/index.md
similarity index 100%
rename from erpnext/docs/user/guides/accounts/tools/index.md
rename to erpnext/docs/user/manual/en/accounts/tools/index.md
diff --git a/erpnext/docs/user/guides/accounts/tools/index.txt b/erpnext/docs/user/manual/en/accounts/tools/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/accounts/tools/index.txt
rename to erpnext/docs/user/manual/en/accounts/tools/index.txt
diff --git a/erpnext/docs/user/guides/accounts/tools/payment-reconciliation.md b/erpnext/docs/user/manual/en/accounts/tools/payment-reconciliation.md
similarity index 89%
rename from erpnext/docs/user/guides/accounts/tools/payment-reconciliation.md
rename to erpnext/docs/user/manual/en/accounts/tools/payment-reconciliation.md
index bf4a65f..c719623 100644
--- a/erpnext/docs/user/guides/accounts/tools/payment-reconciliation.md
+++ b/erpnext/docs/user/manual/en/accounts/tools/payment-reconciliation.md
@@ -11,7 +11,7 @@
 
 Accounts > Tools > Payment Reconciliation
 
-<img class="screenshot" alt="Payment Reconciliation" src="{{url_prefix}}/assets/img/accounts/payment-reconcile-tool.png">
+<img class="screenshot" alt="Payment Reconciliation" src="{{docs_base_url}}/assets/img/accounts/payment-reconcile-tool.png">
 
 __Step 1:__ Select the Account against whom the payments need to be reconciled.
 
diff --git a/erpnext/docs/user/guides/accounts/tools/payment-tool.md b/erpnext/docs/user/manual/en/accounts/tools/payment-tool.md
similarity index 80%
rename from erpnext/docs/user/guides/accounts/tools/payment-tool.md
rename to erpnext/docs/user/manual/en/accounts/tools/payment-tool.md
index f96ca5b..a5d6966 100644
--- a/erpnext/docs/user/guides/accounts/tools/payment-tool.md
+++ b/erpnext/docs/user/manual/en/accounts/tools/payment-tool.md
@@ -11,14 +11,14 @@
 6. Click on Get Outstanding Vouchers to fetch all the valid Vouchers, Invoices and Orders against which a payment can be made/received. These will appear in the Against Voucher section.
 	* __Note:__ In case User is paying a customer or receiving payment from a supplier, add the details regarding the relevant invoices and orders manually.
 
-<img class="screenshot" alt="Payment Tool" src="{{url_prefix}}/assets/img/accounts/payment-tool-1.png">
+<img class="screenshot" alt="Payment Tool" src="{{docs_base_url}}/assets/img/accounts/payment-tool-1.png">
 
 7. Once details have been fetched, click on the detail entry and enter the payment amount made against that Invoice/Order/Voucher
 
-<img class="screenshot" alt="Payment Tool" src="{{url_prefix}}/assets/img/accounts/payment-tool-2.png">
+<img class="screenshot" alt="Payment Tool" src="{{docs_base_url}}/assets/img/accounts/payment-tool-2.png">
 
 8. Click on 'Make Journal Entry' to generate a new Journal Entry with the relevant Party Details and Credit/Debit details filled in.
 
-<img class="screenshot" alt="Payment Tool" src="{{url_prefix}}/assets/img/accounts/payment-tool-3.png">
+<img class="screenshot" alt="Payment Tool" src="{{docs_base_url}}/assets/img/accounts/payment-tool-3.png">
 	
 {next}
diff --git a/erpnext/docs/user/guides/accounts/tools/period-closing-voucher.md b/erpnext/docs/user/manual/en/accounts/tools/period-closing-voucher.md
similarity index 93%
rename from erpnext/docs/user/guides/accounts/tools/period-closing-voucher.md
rename to erpnext/docs/user/manual/en/accounts/tools/period-closing-voucher.md
index 5c0e203..fbec8d1 100644
--- a/erpnext/docs/user/guides/accounts/tools/period-closing-voucher.md
+++ b/erpnext/docs/user/manual/en/accounts/tools/period-closing-voucher.md
@@ -19,7 +19,7 @@
 
 **Closing Fiscal Year** will be an year for which you are closing your financial statement.
 
-<img class="screenshot" alt="Period Closing Voucher" src="{{url_prefix}}/assets/img/accounts/period-closing-voucher.png">
+<img class="screenshot" alt="Period Closing Voucher" src="{{docs_base_url}}/assets/img/accounts/period-closing-voucher.png">
 
 This voucher will transfer Profit or Loss (availed from P&L statment) to Closing Account Head. You should select a libility account like Reserves and Surplus, or Capital Fund account as Closing Account.
 
diff --git a/erpnext/docs/user/manual/en/buying/articles/index.md b/erpnext/docs/user/manual/en/buying/articles/index.md
new file mode 100644
index 0000000..4e1be28
--- /dev/null
+++ b/erpnext/docs/user/manual/en/buying/articles/index.md
@@ -0,0 +1 @@
+{content}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/buying/articles/index.txt b/erpnext/docs/user/manual/en/buying/articles/index.txt
new file mode 100644
index 0000000..c0ed867
--- /dev/null
+++ b/erpnext/docs/user/manual/en/buying/articles/index.txt
@@ -0,0 +1,3 @@
+maintaining-suppliers-part-no-in-item
+managing-purchase-uom-and-stock-uom
+select-material-requests-based-on-supplier
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/buying/articles/maintaining-suppliers-part-no-in-item.md b/erpnext/docs/user/manual/en/buying/articles/maintaining-suppliers-part-no-in-item.md
new file mode 100644
index 0000000..52f4c97
--- /dev/null
+++ b/erpnext/docs/user/manual/en/buying/articles/maintaining-suppliers-part-no-in-item.md
@@ -0,0 +1,20 @@
+<h1>Maintaining Supplier's Item Code in the Item master</h1>
+
+Since each company has their own item coding standards, for each item, your item code differ from supplier's Item Code. ERPNext allows you to track Supplier's Item Code in your item master, so that you refer to each others item code while transacting. Also you can fetch Supplier's Item Code in your purchase transactions, so that they can easily recognize item referring to their Item Code.
+
+#### 1. Updating Supplier Item Code In Item
+
+Under Purchase section in the Item master, you will find table to track Item Code for each Supplier.
+
+![Item Supplier Item Code]({{docs_base_url}}/assets/img/articles/Supplier Item Code.png)
+
+#### 2. Supplier's Item Code in Transactions
+
+Each purchase transaction has field in the Item table where Supplier's Item Code is fetched. This field is hidden in form as well as in the Standard print format. You can make it visible by changing property for this field from [Customize Form](https://erpnext.com/user-guide/customize-erpnext/customize-form).
+
+Supplier Item Code will only be fetched in the purchase transaction, if both Supplier and Item Code selected in purchase transaction is mapped with value mentioned in the Item master.
+
+![Supplier Item Code in transaction]({{docs_base_url}}/assets/img/articles/Supplier Item Code in Purchase Order.png)
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/buying/articles/managing-purchase-uom-and-stock-uom.md b/erpnext/docs/user/manual/en/buying/articles/managing-purchase-uom-and-stock-uom.md
new file mode 100644
index 0000000..d4d97be
--- /dev/null
+++ b/erpnext/docs/user/manual/en/buying/articles/managing-purchase-uom-and-stock-uom.md
@@ -0,0 +1,47 @@
+<h1>Managing Purchase UoM and Stock UoM</h1>
+
+When purchasing an item, you can set purchase UoM (Unit of Measurement) which could be different from item's stock UoM.
+
+### Scenario:
+
+Item ABC is stocked in Nos, but purchased in Cartons. Hence in the Purchase Order, you will need to update UoM as Carton.
+
+### 1. Editing Purchase UoM
+
+
+#### Step 1.1: Edit UoM in the Purchase Order
+
+In the Purchase Order, you will find two UoM fied.
+
+- UoM
+- Stock UoM
+
+In both the fields, default UoM of an item will be updated. You should edit UoM field, and select Purchase UoM (Carton in this case).
+
+![Item Purchase UoM]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-19 at 4.10.35 pm.png)
+
+#### Step 1.2: Update UoM Conversion Factor
+
+In one Carton, if you get 20 Nos. of item ABC, then UoM Conversion Factor would be 20. 
+
+![Item Conversion Factor]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-19 at 4.11.58 pm.png)
+
+Based on the Qty and Conversion Factor, qty will be calculated in the Stock UoM of an item. If you purchase just one carton, then Qty in the stock UoM will be set as 20.
+
+![Purchase Qty in Default UoM]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-19 at 4.14.46 pm.png)
+
+### 2. Stock Ledger Posting
+
+Irrespective of the Purchase UoM selected, stock ledger posting will be done in the Default UoM of an item only. Hence you should ensure that conversion factor is entered correctly while purchasing item in different UoM.
+
+With this, we can conclude that, updating Purchase UoM is mainly for the reference of the supplier. In the print format, you will see item qty in the Purchase UoM.
+
+![Print Format in Purchase UoM]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-19 at 4.15.27 pm.png)
+
+### 3. Setting Conversion Factor in the Item master
+
+In the Item master, under Purchase section, you can list all the possible purchase UoM of an item, with its UoM Conversion Factor.
+
+![Purchase UoM master]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-19 at 4.13.16 pm.png)
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/buying/articles/select-material-requests-based-on-supplier.md b/erpnext/docs/user/manual/en/buying/articles/select-material-requests-based-on-supplier.md
new file mode 100644
index 0000000..6b59695
--- /dev/null
+++ b/erpnext/docs/user/manual/en/buying/articles/select-material-requests-based-on-supplier.md
@@ -0,0 +1,19 @@
+<h1>Select Material Requests based on Supplier</h1>
+
+<b>Question</b>: How to create a single Purchase Order from multiple Material Requests for all Items that are purchased from common Supplier?<br>
+<br><b>Answer</b>:
+<br>
+<br>Material Requests can be individually fetched from Purchase Orders using the 'From Material Request' button. However this procedure becomes tedious when there are multiple Material Requests for items that are purchased from a single supplier.<br>
+<br>A more efficient way;
+<br>
+<br><u><b>Step 1:</b></u> When creating a Purchase order use the <i>'For Supplier'</i> button in the form.
+<br>
+<br><img src="{{docs_base_url}}/assets/img/articles/kb_po_forsupp.png" height="238" width="747"><br>
+<br><u><b>Step 2:</b></u> In the 'Get From Supplier' pop-up enter the Supplier name and click on <i>'Get'</i>.
+<br>
+<br><img src="{{docs_base_url}}/assets/img/articles/kb_po_popup.png"><br>
+<br><u><b>Step 3:</b></u> All the items associated with a Material Request and having the default Supplier, will be fetched in the Items Table. Any Item that is not required can be deleted.
+<br>
+<br><img src="{{docs_base_url}}/assets/img/articles/kb_po_itemtable.png" height="388" width="645"><br>
+<br><div class="well">Note: For this feature to map the Items correctly, the Default Supplier field in the Item Master must be filled.</div>
+<br>
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/buying/index.md b/erpnext/docs/user/manual/en/buying/index.md
similarity index 100%
rename from erpnext/docs/user/guides/buying/index.md
rename to erpnext/docs/user/manual/en/buying/index.md
diff --git a/erpnext/docs/user/guides/buying/index.txt b/erpnext/docs/user/manual/en/buying/index.txt
similarity index 67%
rename from erpnext/docs/user/guides/buying/index.txt
rename to erpnext/docs/user/manual/en/buying/index.txt
index 9c87d09..a12bb06 100644
--- a/erpnext/docs/user/guides/buying/index.txt
+++ b/erpnext/docs/user/manual/en/buying/index.txt
@@ -2,3 +2,5 @@
 supplier-quotation
 purchase-order
 setup
+articles
+purchase-taxes
diff --git a/erpnext/docs/user/guides/buying/purchase-order.md b/erpnext/docs/user/manual/en/buying/purchase-order.md
similarity index 90%
rename from erpnext/docs/user/guides/buying/purchase-order.md
rename to erpnext/docs/user/manual/en/buying/purchase-order.md
index b6badf6..e7f2429 100644
--- a/erpnext/docs/user/guides/buying/purchase-order.md
+++ b/erpnext/docs/user/manual/en/buying/purchase-order.md
@@ -7,7 +7,7 @@
 
 #### Purchase Order Flow Chart
 
-![Purchase Order]({{url_prefix}}/assets/old_images/erpnext/purchase-order-f.jpg)
+![Purchase Order]({{docs_base_url}}/assets/old_images/erpnext/purchase-order-f.jpg)
 
 In ERPNext, you can also make a Purchase Order directly by going to:
 
@@ -15,7 +15,7 @@
 
 #### Create Purchase Order
 
-<img class="screenshot" alt="Purchase Order" src="{{url_prefix}}/assets/img/buying/purchase-order.png">
+<img class="screenshot" alt="Purchase Order" src="{{docs_base_url}}/assets/img/buying/purchase-order.png">
 
 Entering a Purchase Order is very similar to a Purchase Request, additionally
 you will have to set:
@@ -73,7 +73,7 @@
 #### Figure 3: Conversion of Purchase UOM to stock UOM
 
 
-<img class="screenshot" alt="Purchase Order - UOM" src="{{url_prefix}}/assets/img/buying/purchase-order-uom.png">
+<img class="screenshot" alt="Purchase Order - UOM" src="{{docs_base_url}}/assets/img/buying/purchase-order-uom.png">
 
 __Step 4:__ Mention the UOM conversion factor. For example, (100);If one box has
 100 pieces.  
diff --git a/erpnext/docs/user/guides/buying/purchase-taxes.md b/erpnext/docs/user/manual/en/buying/purchase-taxes.md
similarity index 95%
rename from erpnext/docs/user/guides/buying/purchase-taxes.md
rename to erpnext/docs/user/manual/en/buying/purchase-taxes.md
index 0e5ebb3..871ff96 100644
--- a/erpnext/docs/user/guides/buying/purchase-taxes.md
+++ b/erpnext/docs/user/manual/en/buying/purchase-taxes.md
@@ -8,7 +8,7 @@
 > Buying > Setup > Purchase Taxes and Charges Template > New Purchase Taxes and Charges
 Master
 
-![Purchase-Taxes]({{url_prefix}}/assets/old_images/erpnext/purchase-taxes.png)
+![Purchase-Taxes]({{docs_base_url}}/assets/old_images/erpnext/purchase-taxes.png)
 
   
 
diff --git a/erpnext/docs/user/guides/buying/setup/buying-settings.md b/erpnext/docs/user/manual/en/buying/setup/buying-settings.md
similarity index 89%
rename from erpnext/docs/user/guides/buying/setup/buying-settings.md
rename to erpnext/docs/user/manual/en/buying/setup/buying-settings.md
index dc9fa8e..c89c5d1 100644
--- a/erpnext/docs/user/guides/buying/setup/buying-settings.md
+++ b/erpnext/docs/user/manual/en/buying/setup/buying-settings.md
@@ -1,6 +1,6 @@
 Buying Settings is where you can define properties which will be applied in the Buying module's transactions. 
 
-![Buying Settings]({{url_prefix}}/assets/img/buying/buying-settings.png)
+![Buying Settings]({{docs_base_url}}/assets/img/buying/buying-settings.png)
 
 Let us look at the various options that can be configured:
 
@@ -14,7 +14,7 @@
 
 > Setup > Settings > Naming Series
 
-[Click here to know more about defining a Naming Series.]({{url_prefix}}/user/guides/setting-up/settings/naming-series.html)
+[Click here to know more about defining a Naming Series.]({{docs_base_url}}/user/guides/setting-up/settings/naming-series.html)
 
 ### 2. Default Supplier Type
 
diff --git a/erpnext/docs/user/guides/buying/setup/index.md b/erpnext/docs/user/manual/en/buying/setup/index.md
similarity index 100%
rename from erpnext/docs/user/guides/buying/setup/index.md
rename to erpnext/docs/user/manual/en/buying/setup/index.md
diff --git a/erpnext/docs/user/guides/buying/setup/index.txt b/erpnext/docs/user/manual/en/buying/setup/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/buying/setup/index.txt
rename to erpnext/docs/user/manual/en/buying/setup/index.txt
diff --git a/erpnext/docs/user/guides/buying/setup/supplier-type.md b/erpnext/docs/user/manual/en/buying/setup/supplier-type.md
similarity index 90%
rename from erpnext/docs/user/guides/buying/setup/supplier-type.md
rename to erpnext/docs/user/manual/en/buying/setup/supplier-type.md
index 9ca8978..61f65fa 100644
--- a/erpnext/docs/user/guides/buying/setup/supplier-type.md
+++ b/erpnext/docs/user/manual/en/buying/setup/supplier-type.md
@@ -14,7 +14,7 @@
 
 > Buying > Setup > Supplier Type > New Supplier Type
 
-<img class="screenshot" alt="Supplier Type" src="{{url_prefix}}/assets/img/buying/supplier-type.png">
+<img class="screenshot" alt="Supplier Type" src="{{docs_base_url}}/assets/img/buying/supplier-type.png">
 
 You can classify your suppliers from a range of choice available in ERPNext.
 Choose from a set of given options like Distributor, Electrical,Hardware,
diff --git a/erpnext/docs/user/guides/buying/supplier-quotation.md b/erpnext/docs/user/manual/en/buying/supplier-quotation.md
similarity index 84%
rename from erpnext/docs/user/guides/buying/supplier-quotation.md
rename to erpnext/docs/user/manual/en/buying/supplier-quotation.md
index a0047e6..0f1d51a 100644
--- a/erpnext/docs/user/guides/buying/supplier-quotation.md
+++ b/erpnext/docs/user/manual/en/buying/supplier-quotation.md
@@ -8,7 +8,7 @@
 
 #### Supplier Quotation Flow-Chart
 
-![Supplier Quotation]({{url_prefix}}/assets/old_images/erpnext/supplier-quotation-f.jpg)
+![Supplier Quotation]({{docs_base_url}}/assets/old_images/erpnext/supplier-quotation-f.jpg)
 
 You can also make a Supplier Quotation directly from:
 
@@ -16,7 +16,7 @@
 
 #### Create Supplier Quotation
 
-<img class="screenshot" alt="Supplier Quotation" src="{{url_prefix}}/assets/img/buying/supplier-quotation.png">
+<img class="screenshot" alt="Supplier Quotation" src="{{docs_base_url}}/assets/img/buying/supplier-quotation.png">
 
 If you have multiple Suppliers who supply you with the same Item, you
 usually send out a message (Request for Quote) to various Suppliers. In
diff --git a/erpnext/docs/user/guides/buying/supplier.md b/erpnext/docs/user/manual/en/buying/supplier.md
similarity index 91%
rename from erpnext/docs/user/guides/buying/supplier.md
rename to erpnext/docs/user/manual/en/buying/supplier.md
index 9e20642..455e060 100644
--- a/erpnext/docs/user/guides/buying/supplier.md
+++ b/erpnext/docs/user/manual/en/buying/supplier.md
@@ -5,7 +5,7 @@
 
 > Buying > Documents > Supplier > New Supplier
 
-<img class="screenshot" alt="Supplier Master" src="{{url_prefix}}/assets/img/buying/supplier-master.png">
+<img class="screenshot" alt="Supplier Master" src="{{docs_base_url}}/assets/img/buying/supplier-master.png">
 
 ### Contacts and Addresses
 
diff --git a/erpnext/docs/user/guides/customer-portal/customer-orders-invoices-and-shipping-status.md b/erpnext/docs/user/manual/en/customer-portal/customer-orders-invoices-and-shipping-status.md
similarity index 62%
rename from erpnext/docs/user/guides/customer-portal/customer-orders-invoices-and-shipping-status.md
rename to erpnext/docs/user/manual/en/customer-portal/customer-orders-invoices-and-shipping-status.md
index b176d10..83d7bf6 100644
--- a/erpnext/docs/user/guides/customer-portal/customer-orders-invoices-and-shipping-status.md
+++ b/erpnext/docs/user/manual/en/customer-portal/customer-orders-invoices-and-shipping-status.md
@@ -2,21 +2,21 @@
 and Shipments Customers can check the status of their orders, invoices, and
 shipping status by logging on to the web.
 
-![Portal Menu]({{url_prefix}}/assets/old_images/erpnext/portal-menu.png)
+![Portal Menu]({{docs_base_url}}/assets/old_images/erpnext/portal-menu.png)
 
 Once an order is raised, either using the Shopping Cart or from within
 ERPNext, your customer can view the order and keep an eye on the billing and
 shipment status. When the invoice and payment against these orders are
 submitted, the customer can see the updated status on the portal, at a glance.
 
-![Customer Portal]({{url_prefix}}/assets/old_images/erpnext/customer-portal-orders-1.png)
+![Customer Portal]({{docs_base_url}}/assets/old_images/erpnext/customer-portal-orders-1.png)
 
 #### Invoice with paid status.
 
-![Invoice Paid]({{url_prefix}}/assets/old_images/erpnext/portal-invoice-paid.png)
+![Invoice Paid]({{docs_base_url}}/assets/old_images/erpnext/portal-invoice-paid.png)
 
 #### Invoice with billed status.
 
-![Billed Invoice]({{url_prefix}}/assets/old_images/erpnext/portal-order-billed.png)
+![Billed Invoice]({{docs_base_url}}/assets/old_images/erpnext/portal-order-billed.png)
 
 {next}
diff --git a/erpnext/docs/user/guides/customer-portal/index.md b/erpnext/docs/user/manual/en/customer-portal/index.md
similarity index 100%
rename from erpnext/docs/user/guides/customer-portal/index.md
rename to erpnext/docs/user/manual/en/customer-portal/index.md
diff --git a/erpnext/docs/user/guides/customer-portal/index.txt b/erpnext/docs/user/manual/en/customer-portal/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/customer-portal/index.txt
rename to erpnext/docs/user/manual/en/customer-portal/index.txt
diff --git a/erpnext/docs/user/manual/en/customer-portal/issues.md b/erpnext/docs/user/manual/en/customer-portal/issues.md
new file mode 100644
index 0000000..79ac676
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customer-portal/issues.md
@@ -0,0 +1,22 @@
+The customer portal makes it very easy for a customer to raise concerns. A
+simple and intuitive interface facilitates your customer to report their
+concerns as Issues. They can view the complete thread of their
+conversation.
+
+#### Empty Ticket List
+
+![Ticket List]({{docs_base_url}}/assets/old_images/erpnext/portal-ticket-list-empty.png)
+
+#### New Issue
+
+![New Ticket]({{docs_base_url}}/assets/old_images/erpnext/portal-new-ticket.png)
+
+#### Open Issue
+
+![Open Issue]({{docs_base_url}}/assets/old_images/erpnext/portal-ticket-1.png)
+
+#### Reply on Issue
+
+![Reply Issue]({{docs_base_url}}/assets/old_images/erpnext/portal-ticket-reply.png)
+
+{next}
diff --git a/erpnext/docs/user/guides/customer-portal/portal-login.md b/erpnext/docs/user/manual/en/customer-portal/portal-login.md
similarity index 65%
rename from erpnext/docs/user/guides/customer-portal/portal-login.md
rename to erpnext/docs/user/manual/en/customer-portal/portal-login.md
index 9d657a8..4a3b60c 100644
--- a/erpnext/docs/user/guides/customer-portal/portal-login.md
+++ b/erpnext/docs/user/manual/en/customer-portal/portal-login.md
@@ -1,6 +1,6 @@
 To login into the customer account, the customer has to use his email id and
 the password sent by ERPNext; generated through the sign-up process.
 
-![Login]({{url_prefix}}/assets/old_images/erpnext/customer-portal-login.png)
+![Login]({{docs_base_url}}/assets/old_images/erpnext/customer-portal-login.png)
 
 {next}
diff --git a/erpnext/docs/user/manual/en/customer-portal/sign-up.md b/erpnext/docs/user/manual/en/customer-portal/sign-up.md
new file mode 100644
index 0000000..01929ec
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customer-portal/sign-up.md
@@ -0,0 +1,22 @@
+Customers have to log-in to the Company Website, and sign-up as a customer.
+
+#### Step 1: Click on Login Icon
+
+![Sign Up]({{docs_base_url}}/assets/old_images/erpnext/customer-portal-sign-up-1.png)
+
+  
+
+#### Step 2: Click on Sign Up Icon
+
+![Sign Up]({{docs_base_url}}/assets/old_images/erpnext/customer-portal-sign-up-2.png)
+
+  
+
+#### Step 3: Enter Customer Name and ID
+
+![Sign Up]({{docs_base_url}}/assets/old_images/erpnext/customer-portal-sign-up-3.png)
+
+After the sign up process, a mail will be sent to the customers email id with
+the password details.
+
+{next}
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/allow-fields-to-be-changed-after-submit.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/allow-fields-to-be-changed-after-submit.md
new file mode 100644
index 0000000..7460568
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/allow-fields-to-be-changed-after-submit.md
@@ -0,0 +1,26 @@
+<h1>Allow Fields to be Changed After Submit</h1>
+
+In many cases a field may need to be changed even after the document has been submitted to allow flexibility. The _Allow On Submit_ option is available for such a purpose. Certain standard fields in Doctypes are set as Allow On Submit by default (such as _Letterhead_ and _Print Heading_ in Invoices). The user can set Custom Fields as Allow On Submit using Customize Form.
+
+**Note:** Standard Fields cannot be set as Allow On Submit by a User
+
+#### Step 1: Go to Customize Form in Setup Module.
+
+```Setup >> Customize >> Customize Form```
+
+#### 
+####Step 2: Select the form containing the desired Custom Field in _Enter Form Type_ field.
+
+![]({{docs_base_url}}/assets/img/articles/kb_custom_name.png)
+
+#### **Step 3:** In the _Fields_ section, scroll down, click on the Custom field and check the _Allow On Submit._
+
+![]({{docs_base_url}}/assets/img/articles/kb_allowonsubmit_checkinform.png)
+
+_This field can now be changed even after the Document is submitted_.
+
+**Note:** The Custom Fields can also be set as Allow On Submit during the time of creation by checking the Allow On Submit option that is available.
+![]({{docs_base_url}}/assets/img/articles/kb_allowonsubmit_checkinfield.png)
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/creating-custom-link-field.html b/erpnext/docs/user/manual/en/customize-erpnext/articles/creating-custom-link-field.html
new file mode 100644
index 0000000..cf27229
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/creating-custom-link-field.html
@@ -0,0 +1,7 @@
+<h1>Creating Custom Link Fields</h1>
+
+Users can create Custom Link Fields within DocTypes by following these steps;
+
+
+
+<br><h4>Step 1: Go to Customize Form in Setup Module.</h4><code>Setup &gt;&gt; Customize &gt;&gt; Customize Form</code><br><br><h4>Step 2: Select the desired form in <em>Enter Form Type</em> field.</h4><img src="{{docs_base_path}}/assets/img/articles/kb_custom_name.png" height="194" width="697"><br><br><h4><strong>Step 3:</strong> In the <em>Fields</em> section;</h4><p>Insert a new Field row and set the attributes as;</p><ul><li><b>Label: </b>Desired label that user wishes to display in the form</li><li><b>Type: </b>Set as 'Link'</li><li><b>Name: </b>Desired name for the field</li><li><b>Options: </b>Enter the name of the Doctype to which the field is linked<br></li></ul><br><img src="{{docs_base_path}}/assets/img/articles/kb_customlink_newfield.png" height="311" width="697"><br><br><br><h4>Note: Please refer to https://frappe.io/kb/customization/form-architecture for more information about the form structure<br></h4><!-- html -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/customizing-sorting-order-in-the-list-view.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/customizing-sorting-order-in-the-list-view.md
new file mode 100644
index 0000000..cc7ac01
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/customizing-sorting-order-in-the-list-view.md
@@ -0,0 +1,29 @@
+<h1>Customizing Sorting Order in the List View</h1>
+
+**Question:** I want records in my Item List sorted based on Desc Order of Item Code.
+
+**Answers:** Following are the steps to customize Sort Order for the Item master. These steps will be applicable for customizing Sort Order for the other documents as well.
+
+####Step 1: Go to Customize Form
+
+`Setup > Customize > Customize Form`
+
+####Step 2: Select Doctype
+
+Select document for which you Sort Order is to be customized. Considering a scenario, Item should be selected in the Doctype field.
+
+####Step 3: Update Sort Details
+
+In the Customize Form, you will find these fields.
+
+![Sort Order field]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-04-02 at 3.26.51 pm.png)
+
+1. Sort Field
+
+Select field based on which sorting will be done. It will be "Item_Code" field in scenario.
+
+2. Sort Order
+
+Sort Order will be two possible options, **Asc** for ascending, and **Desc** for descending.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/deleting-custom-reports.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/deleting-custom-reports.md
new file mode 100644
index 0000000..bb0461c
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/deleting-custom-reports.md
@@ -0,0 +1,23 @@
+<h1>Deleting Custom Reports</h1>
+
+ERPNext has several [types of reports](https://erpnext.com/kb/report/making-custom-reports-in-erpnext) which can be customize as per the companies/users requirement.
+
+If there is a report custom report which needs to be deleted, it can be achieved by following steps given below. Please note that its applicable only for the Custom Report, and not for the standard reports.
+
+####Report List
+
+In the Awesome Bar, type and select "Report List" for an option.
+
+![Report Search]({{docs_base_url}}/assets/img/articles/$SGrab_316.png)
+
+####Selecting and Deleting Report
+
+The Report List will have all the standard and custom reports of your account. You can select Custom Report to be deleted from the list itself, and click on Delete icon.
+
+![Report List]({{docs_base_url}}/assets/img/articles/$SGrab_317.png)
+
+Or you can open that report, and delete it from File menu option.
+
+![Report Delete]({{docs_base_url}}/assets/img/articles/$SGrab_318.png)
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/disable-rounded-total.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/disable-rounded-total.md
new file mode 100644
index 0000000..2f9655c
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/disable-rounded-total.md
@@ -0,0 +1,23 @@
+<h1>Disable Rounded Total</h1>
+
+Each transaction in ERPNext has Standard print format. For transactions, Standard print format covers Rounded Total for that transaction by default.
+
+![Print Preview]({{docs_base_url}}/assets/img/articles/Selection_053.png)
+
+If you don't wish rounded total to be shown in the Standard Print Format, please complete following settings.
+
+####1. Go to Global Settings
+
+`Setup > Settings > Global Settings`
+
+####2. Set Global Defaults
+
+Check Disable Rounded Total, and Save Global Defaults.
+
+![Global Default]({{docs_base_url}}/assets/img/articles/Selection_052.png)
+
+For system to take effect of this setting, you should clear cache and refresh your ERPNext account. Then your print formats shall not render value for the Rounded Total in the print formats.
+   
+<div class=well>Note: This setting will only affect Standard print formats.</div>
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/field-types.html b/erpnext/docs/user/manual/en/customize-erpnext/articles/field-types.html
new file mode 100644
index 0000000..6b1c38b
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/field-types.html
@@ -0,0 +1,168 @@
+<h1>Field Types</h1>
+
+<p>Following are the types of fields you can define while creating new ones, or while amend standard ones.</p>
+<ul>
+    <li><b>Attach:</b>
+
+        <br>
+        <br>Attach field allows you browsing file from File Manager and attach in the transaction.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_184.png">
+        <br>
+        <br>
+    </li>
+    <li><b>Button:</b>
+
+        <br>
+        <br>This Field Type will generate a Button, on clicking which you can execute some function.
+        <br>
+        <br>
+    </li>
+    <li><b>Check:</b>
+
+        <br>
+        <br>Check will generate a check box field.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_185.png">
+        <br>
+        <br>
+    </li>
+    <li><b>Column Break:</b>
+
+        <br>
+        <br>Since ERPNext has two column layout, using Column Break fields, you can divide set of fields on either side.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_186.png">
+        <br>
+        <br>
+    </li>
+    <li><b>Currency:</b>
+
+        <br>
+        <br>Currency field holds numeric value, upto two decimal place. Also you can have currency symbol being shown for the currency field.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_187.png">
+        <br>
+        <br>
+    </li>
+</ul>
+<ul>
+    <li><b>Data:</b>
+
+        <br>
+        <br>Data field allows you entering value upto 255 character.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_183.png">
+        <br>
+        <br>
+    </li>
+    <li><b>Date and Time:<br><br></b>This field will give you date and time picker, with value for current date and time (as provided by your computer) set by default.
+        <br>
+        <br><b><img src="{{docs_base_path}}/assets/img/articles/$SGrab_188.png"><br><br></b>
+
+    </li>
+    <li><b>Dynamic Link:<br><br></b>Link field is one which pulls data from another master/table. Dynamic link field is connected with multiple masters at the same time. Its link is determined based on value selected in the previous field.
+        <br>
+        <br>Example: Customer will be Dynamic field in the Quotation form. If use selects Quotation made for Customer, then Customer field will be linked to Customer master, and suggest records accordingly. If user selects that Quotation is for Lead, then same Customer
+        field will be linked to Lead master.
+        <br>
+        <br>
+    </li>
+    <li><b>Float:</b>
+
+        <br>
+        <br>Float field carries numeric value, upto six decimal place. Float Precision set in Setup &gt;&gt; Settings &gt;&gt; System Setting will be applicable on all the link field. For float field, decimal places generated will be as define in Float Precision.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_189.png">
+        <br>If you need more than two decimal place in the Currency field, you can change its field type to Float field from Customize Form.
+        <br>
+        <br>
+    </li>
+    <li><b>Image:</b>
+
+        <br>
+        <br>Image field will render an image file selected in another attach field.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_190b611f3.png">
+        <br>
+        <br>For the Image field, under Option, Attach field name should be provide which this field will refer to for image file, and render that image file.
+        <br>
+        <br>
+    </li>
+    <li><b>Int (Integer):</b>
+
+        <br>
+        <br>Integer field holds numeric value, without decimal place.
+        <br>
+        <br>
+    </li>
+    <li>Link Field:
+        <br>
+        <br>Link field is connected with another master from where it fetches data.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_191.png">
+        <br>
+        <br>
+    </li>
+    <li><b>Password:<br><br></b>Password field will decode value in it. Extra coding will be required for validating password of specific user.<b><br><br></b>
+
+    </li>
+    <li><b>Read Only:<br><br></b>Read Only field will carry data fetched from another form, but they themselves will be non-editable. You should set Read Only as field type if its source for value is predetermined.
+        <br>
+        <br>
+    </li>
+    <li><b>Section Break:</b>
+
+        <br>
+        <br>Section Break can be used to divide form in multiple section.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_192.png">
+        <br>
+        <br>
+    </li>
+    <li><b>Select:<br><br></b>Select will be the drop-down field, with possible results (separate by row) define in the Option.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_193.png">
+        <br><b><br></b>
+
+    </li>
+    <li><b>Small Text:</b>
+
+        <br>
+        <br>Small Text field carries general text content, has little more character limit than Data field.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_194.png">
+        <br>
+        <br>
+    </li>
+    <li><b>Table:</b>
+
+        <br>
+        <br>Table will be (sort of) Link field which will render another docytpe within the current form. For example, Item table in the Sales Order form is Table field, which is linked to Sales Order Item doctype.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_196.png">
+        <br>
+        <br>
+    </li>
+    <li><b>Text Editor:</b>
+
+        <br>
+        <br>Text Editor will be large text field, with tools to format text.
+        <br>
+        <br>
+        <img src="{{docs_base_path}}/assets/img/articles/$SGrab_198.png">
+        <br>
+    </li>
+</ul>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/increase-max-attachments.html b/erpnext/docs/user/manual/en/customize-erpnext/articles/increase-max-attachments.html
new file mode 100644
index 0000000..450bfb1
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/increase-max-attachments.html
@@ -0,0 +1,24 @@
+<h1>Increase Max Attachments</h1>
+
+You can increase Number of attachments which can be added to particular documents via Customize Form.
+<br>
+<br>Let's assume we need to increase Max Attachment limit for Quotation to five. Following will be the steps to achieve this.
+<br>
+<br>
+<b>Step 1</b>: Go to Setup &gt; Customize &gt; Customize Form.
+    <br>
+    <br><b>Step 2</b>: Enter Form Type.<br>&nbsp;
+    <br>In our case, it will be "Quotation".
+    <br><br><img src="{{docs_base_path}}/assets/img/articles/Selection_0179888b3.png"><br>
+    <br><b>Step 3:</b> Increase Numbers under the Max Attachments field.
+<br>
+    <br><br>
+<img src="{{docs_base_path}}/assets/img/articles/Selection_018ea50ef.png">
+    <br>
+    <br>After increasing numbers update the Customization Form.
+<br>
+<br>
+<div class="well">Note: Max limit/size of an attachment is 1MB.</div>
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/index.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/index.md
new file mode 100644
index 0000000..4e1be28
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/index.md
@@ -0,0 +1 @@
+{content}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/index.txt b/erpnext/docs/user/manual/en/customize-erpnext/articles/index.txt
new file mode 100644
index 0000000..3ac0897
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/index.txt
@@ -0,0 +1,16 @@
+allow-fields-to-be-changed-after-submit
+creating-custom-link-field
+customizing-sorting-order-in-the-list-view
+deleting-custom-reports
+disable-rounded-total
+field-types
+increase-max-attachments
+make-field-visible-in-print-format
+making-custom-reports-in-erpnext
+managing-dynamic-link-fields
+module-visibility
+perm-level-error-in-permission-manager-1
+search-record-by-specific-field
+set-language
+set-precision-for-float-currency-and-percent-fields
+user-restriction
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/make-field-visible-in-print-format.html b/erpnext/docs/user/manual/en/customize-erpnext/articles/make-field-visible-in-print-format.html
new file mode 100644
index 0000000..ffdd9d2
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/make-field-visible-in-print-format.html
@@ -0,0 +1,5 @@
+<h1>Make Fields Visible In Print Format</h1>
+
+The standard print formats only display certain fields by default. In case the user prefers more information from fields to be displayed, this can be achieved by using the <i>Customize Form</i> feature.<b><br><br>Step 1:</b> Go to Customize Form in Setup Module.<br><br>
+<div class="well">Setup &gt;&gt; Customize &gt;&gt; Customize Form</div>
+<b>Step 2: </b>Select the desired form in <i>Enter Form Type</i> field.<br><br><img src="{{docs_base_path}}/assets/img/articles/kb_custom_name.png"><br><br><b>Step 3:</b> In the <i>Fields</i> section, click on the field that must be visible in the Print Format and remove the check on <i>Print Hide</i> field.<br><br><img src="{{docs_base_path}}/assets/img/articles/kb_custom_printhide.png" height="214" width="674"><br><br>The field will now be visible in all print formats for that Document type.<br>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/making-custom-reports-in-erpnext.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/making-custom-reports-in-erpnext.md
new file mode 100644
index 0000000..540d1cd
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/making-custom-reports-in-erpnext.md
@@ -0,0 +1,53 @@
+<h1>Reports in ERPNext</h1>
+
+There are three kind of reports in ERPNext.
+
+###1. Query Report
+
+Query Report is written in SQL which pull values from database and fetch in the report. Though SQL queries can be written from front end, like HTML for customer print format, its restricted from hosted users. Because it will allow users with no access to specific report to query data from query report.
+
+Check Purchase Order Item to be Received report in Stock module for example of Query report.
+
+###2. Script Report
+
+Script Reports are written in Python and stored on server side. These are complex reports which involves exception of logic and calculation. Since these reports are written on server side, its not available for hosted users.
+
+Check Financial Analytics report in Accounts module for example of Script Report.
+
+###3. Report Builder
+
+Report Builder is an in-built report customization tool in ERPNext. This allows you to define fields of the form which shall appear as column in the report. Also you can set required filters and do sorting as per your preference.
+
+Each form in ERPNext has Report Builder option in its list view.
+
+![Report Builder Icon]({{docs_base_url}}/assets/img/articles/Selection_046.png)
+
+####Adding Column in Report
+
+Go to Menu and click on Pick Column option to select field which should be added as column in the report. You can also select the field from the child table (eg. Item table in Sales Invoice) of the form.
+
+![Report Pick Column]({{docs_base_url}}/assets/img/articles/Selection_050.png)
+
+####Applying Filters
+
+All the fields of the form will be applicable for setting filter as well.
+
+![Report Pick Column]({{docs_base_url}}/assets/img/articles/$SGrab_238.png)
+
+####Sorting
+
+Select field based on which report will be sorted.
+
+![Report Pick Column]({{docs_base_url}}/assets/img/articles/Selection_052f7b160.png)
+
+####Save Report
+
+Go to Menu and click on Save button to have this report saved with selected column, filters and sorting.
+
+![Report Pick Column]({{docs_base_url}}/assets/img/articles/$SGrab_241.png)
+
+Saved reports appear under Customize section in the module's home page. Customize Report section only appear if you have custom reports being saved for documents of that module.
+
+![Report Pick Column]({{docs_base_url}}/assets/img/articles/$SGrab_242.png)
+
+<!-- markdown --> 
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/managing-dynamic-link-fields.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/managing-dynamic-link-fields.md
new file mode 100644
index 0000000..c14ef39
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/managing-dynamic-link-fields.md
@@ -0,0 +1,46 @@
+<h1>Managing Dynamic Link Fields</h1>
+
+Dynamic Link field is one which can search and hold value of any document/doctype. Let's consider an example to learn how Dynamic Link field can benefit us.
+
+While creating Opportunity or Quotation, we have to explicitly define if it is for Lead or Customer. Based on our selection (Lead/Customer), another link field shows up where we can select actual Lead or Customer for whom we are creating this Quotation.
+
+If you set later field as Dynamic Link, where we select actual Lead or Customer, this field will be able to search Leads as well as Customers. Hence we need not insert separate link fields for Customer and Lead.
+
+Let's check steps to insert Custom Dynamic Field. For an instance, we will insert it under Journal Voucher Form.
+
+####Insert Link Field for Doctype
+
+Firstly we will create a link field which will be linked to the Doctype.
+
+![Custom Link Field]({{docs_base_url}}/assets/img/articles/$SGrab_349.png)
+
+By **Doctype** mentioned in the Option field, we mean parent Doctype. So, just like Quotation is one Doctype, which has multiple Quotation under it. Same way, Doctype is also a Doctype which has Sales Order Doctype, Purchase Order Doctype and other form's doctype created under it as child Doctype.
+
+-- Doctype<br>
+----- Sales Order<br>
+----- Purchase Invoice<br>
+----- Quotation<br>
+----- Sales Invoice<br>
+----- Employee<br>
+----- Production Order<br>
+and so on, till all the forms/document of ERPNext is covered.
+
+So linking this field with parent Doctype master list all the child doctypes/forms.
+
+![journal Voucher Link Field]({{docs_base_url}}/assets/img/articles/$SGrab_352.png)
+
+####Insert Dynamic Link Field
+
+It will be "Dynamic Link" for Field Type, and field name of Doctype field mentioned in its Option field.
+
+![Custom Dynamic Field]({{docs_base_url}}/assets/img/articles/$SGrab_350.png)
+
+This field will allow us to select document id, based on value selected in the Doctype link field. For example, if we select Sales Order in the prior field, this field will list all the Sales Orders id. If we select Purchase Invoice in the prior field, this field will render all the Purchase Order for our selection.
+
+![Journal Voucher Dynamic Field ]({{docs_base_url}}/assets/img/articles/$SGrab_353.png)
+
+####Customizing options in the Doctype Link field
+
+Bydefault, Docytpe link field will provide all the forms/doctypes for selection. If you wish this field to show certain specific doctypes in the search result, you will need to write Custom Script for it.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/module-visibility.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/module-visibility.md
new file mode 100644
index 0000000..837ca92
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/module-visibility.md
@@ -0,0 +1,17 @@
+<h1>Module Visibility</h1>
+
+If you have permission on specific module, but it is still not visible to you, following is how you should go about checking setting to make it visible again.
+
+As step zero, reassure that you have role assigned which is required for accessing Website and Shopping Cart module. For modules in question, you should have "Website Manager" role assigned. If permissions has been customized in your account, check Role Permission Manager to know which Role has permission on Website and Shopping Cart module.
+
+If modules are hidden in-spite of assignment of required permission, then you should check if Website and Shopping Cart module is not disabled from All Application option on your desk/home page.
+
+![All Applications]({{docs_base_url}}/assets/img/articles/$SGrab_223.png)
+
+If modules are still not visible, check if it is hidden by System Manager from Show/Hide Modules option in the Setup module.
+
+<div class="well">Setup &gt;&gt; Settings &gt;&gt; Show / Hide Modules</div>Ensure required module are checked, and not disabled in this page. If you just enabled/activated it, update Show/Hide Module page, and check your home page after Help &gt;&gt; Clear Cache.
+
+<div class="well">Note: In this help page, Website and Shopping Cart module is considered as an example. You can troubleshoot visibility issues for other modules following same steps.</div>
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/perm-level-error-in-permission-manager-1.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/perm-level-error-in-permission-manager-1.md
new file mode 100644
index 0000000..2fb27b6
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/perm-level-error-in-permission-manager-1.md
@@ -0,0 +1,19 @@
+<h1>Perm Level Error in Permission Manager</h1>
+
+While customizing rules in the [Permission Manager](https://erpnext.com/user-guide/setting-up/permissions/role-based-permissions), you might receive an error message saying:
+
+`For System Manager_ (or other role) _at level 2_ (or other level) _in Customer_ (or document) _in row 8: Permission at level 0 must be set before higher levels are set`.
+
+Error message indicates problem in the existing permission setting for this document.
+
+For any role, before assigning permission at Perm Level 1, 2, permission at Perm Level 0 must be assigned. Error message says that System Manager has been assigned permission at Perm Level 1 and 2, but not at level 0. You should first correct the permission for System Manager's role by:
+
+- Assigning permission to System Manager at level 0.
+
+Or
+
+- By removing permission at level 1 and 2.
+
+After executing one of the above step, you should try adding additional rules in the Role Permission Manager.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/search-record-by-specific-field.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/search-record-by-specific-field.md
new file mode 100644
index 0000000..1505964
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/search-record-by-specific-field.md
@@ -0,0 +1,21 @@
+<h1>Search Record by Specific Field</h1>
+
+While creating any document in ERPNext, you might have to select other record id in it (like selecting Customer in Quotation). For ease in selecting other record, you can search them based on value in various fields of that record. Search By functionality enables you searching and filtering records based on value in the specific fields of that record.
+
+Let's consider an example to learn Search By functionality better. While creating Sales Order, we need to select Customer in it. If we need to filter search result of Customer for specific Customer Group, we should go about following these steps to achieve it.
+
+####Search By in Customize Form
+
+In the Customize Form tool, you will find field called Search Field. You should enter field names based on which we can search and filter result for this document.
+
+Considering our scenario, we should update name of Customer Group field for Customer in the Customize Form.
+
+![Search By in Customize Form]()
+
+####Searching in Another Record.
+
+While creating transaction, to get filtered result for Customer, you should firstly click on search magnifier.
+
+![Search for master]()
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/set-language.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/set-language.md
new file mode 100644
index 0000000..91e9e5f
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/set-language.md
@@ -0,0 +1,38 @@
+<h1>Change the Language</h1>
+
+ERPNext is an multi-lingual application, which means user can select a preferred language for one's ERPNext account.
+
+### 1. Setting Language in User's Account
+
+Following are the steps to set language in your ERPNext account.
+
+#### 1.1 Go to My Setting
+
+![My Setting]({{docs_base_url}}/assets/img/articles/$SGrab_428.png)
+
+#### 1.2 Select Language
+
+![Select Language]({{docs_base_url}}/assets/img/articles/$SGrab_429.png)
+
+#### 1.3 Save User
+
+On saving User after selecting language, your ERPNext account will be refresh automatically. Then you will see ERPNext translated in your selected language.
+
+Being a System Manager, you can set language in other user's master as well.
+
+### 2. Set Language Globally for an Account
+
+#### 2.1 Go to Setup
+
+`Setup > Settings > System Settings`
+
+#### Set Language
+
+![Global Language]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-05 at 4.35.12 pm.png)
+
+#### Save
+
+Save System Settings, and refresh your EPRNext account. On refreshing, you should language in your ERPNext account changed as per your preference.
+
+Note: For now, we have translation available only for few languages. You can contribute to make translation better, and add new languages from [here](https://frappe.io/translator).
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/set-precision-for-float-currency-and-percent-fields.md b/erpnext/docs/user/manual/en/customize-erpnext/articles/set-precision-for-float-currency-and-percent-fields.md
new file mode 100644
index 0000000..2cc39e1
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/set-precision-for-float-currency-and-percent-fields.md
@@ -0,0 +1,26 @@
+<h1>Set Precision for Float, Currency and Percent fields</h1>
+
+In ERPNext, default precision for `Float`, `Currency` and `Percent` field is 3. So, you can enter any number up-to 3 decimals in such fields.
+
+You can also change / customize the precision settings globally or for a specific field.
+
+To change the precision globally, go to `Setup > Settings > System Settings`.
+![Global Precision]({{docs_base_url}}/assets/img/articles/precision-global.png)
+
+You can also set field specific precision. To do that go to `Setup > Customize > Customize Form` and select the DocType there. Then go to the specific field row and change precision. Precision field is only visible if field-type is one of the Float, Currency and Percent.
+![Field-wise Precision]({{docs_base_url}}/assets/img/articles/precision-fieldwise.png)
+
+**Note:**
+If you are changing precision of a field to a higher number, all the related fields should also be set to the same precision.
+
+For example, if you want to calculate invoice total upto 5 decimals, you need to change the precision of all related fields, which resulted total. In this case you have to change following fields to get correct total.
+
+    Sales Invoice Item: price_list_rate, base_price_list_rate, rate, base_rate, amount and base_amount
+    
+    Taxes and Charges: tax_amount, total and tax_amount_after_discount
+    
+    Sales Invoice: net_total, other_charges_total, discount_amount and grand_total
+
+And precision should be changed in all related documents as well, to get correct mapping. In this case, same precision should be set for Quotation, Sales order, Delivery Note and Sales Invoice.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/customize-erpnext/articles/user-restriction.html b/erpnext/docs/user/manual/en/customize-erpnext/articles/user-restriction.html
new file mode 100644
index 0000000..09f9cb1
--- /dev/null
+++ b/erpnext/docs/user/manual/en/customize-erpnext/articles/user-restriction.html
@@ -0,0 +1,29 @@
+<h1>Owner Restriction</h1>
+
+To restricting user based on Owner (creator of record),&nbsp; form/document should have field linked with User master. If that document is not linked with user, then you should create <a href="https://erpnext.com/user-guide/customize-erpnext/custom-field" target="_blank">custom field</a> and link it with User master.
+<br>
+<br>Following are the steps to restrict User based on Owner.
+<br>
+<br><b>Step 1: </b>Go to:
+<br>
+<br>Setup &gt; Permissions &gt; Role Permissions Manager
+<br>
+<br><b>Step 2:</b> Select Document Type for which you want to set user permission. After permissions are loaded for selected document, scroll to role for which you want to set restriction.
+<br>&nbsp;
+<img src="{{docs_base_path}}/assets/img/articles/Selection_0045d151c.png"><br>
+<br><b>Step 3:</b> For Role to be resricted (Sales User in this case), check "Apply User Restriction". On checking Apply User Permission, two links will be show up called:
+<br>
+<br>- Select Document Type
+<br>- Select User Permissions
+<br>
+<br>Click on "Select Document Type".
+<br>
+<br>
+<img src="{{docs_base_path}}/assets/img/articles/Selection_0028834c2.png" height="168" width="691">
+<br>
+<br><b>Step 4:</b> Check mark on User, and un-check for others. If you want user to be restricted based on some other criteria as well, like territory, customer groups, then that should be checked as well.
+<br>
+<br>
+<img src="{{docs_base_path}}/assets/img/articles/Selection_003fea339.png">&nbsp;
+<br>
+<div class="well">When restricting User based on User master itself, then there is no need to create User Permission Setting.</div>
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-doctype.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-doctype.md
similarity index 80%
rename from erpnext/docs/user/guides/customize-erpnext/custom-doctype.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-doctype.md
index 02b08de..fdca8da 100644
--- a/erpnext/docs/user/guides/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]({{url_prefix}}/assets/img/setup/customize/doctype-basics.png)
+![Doctype Basic]({{docs_base_url}}/assets/img/setup/customize/doctype-basics.png)
 
 #### Fields
 
@@ -34,7 +34,7 @@
 1. Actions (button)
 1. Attachments or Images
 
-![Doctype fields]({{url_prefix}}/assets/img/setup/customize/Doctype-all-fields.png)
+![Doctype fields]({{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]({{url_prefix}}/assets/img/setup/customize/doctype-field-naming.png)
+![Doctype Naming]({{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]({{url_prefix}}/assets/img/setup/customize/Doctype-permissions.png)
+![Doctype Permissions]({{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]({{url_prefix}}/assets/img/setup/customize/Doctype-save.png)
+![Doctype Save]({{docs_base_url}}/assets/img/setup/customize/Doctype-save.png)
 
 #### Doctype in System
 
@@ -65,10 +65,10 @@
 
 `Human Resource > Document > Book`
 
-![Doctype List]({{url_prefix}}/assets/img/setup/customize/Doctype-list-view.png)
+![Doctype List]({{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]({{url_prefix}}/assets/img/setup/customize/Doctype-book-added.png)
+![Doctype List]({{docs_base_url}}/assets/img/setup/customize/Doctype-book-added.png)
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-field.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-field.md
similarity index 80%
rename from erpnext/docs/user/guides/customize-erpnext/custom-field.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-field.md
index ed30f52..8aefa80 100644
--- a/erpnext/docs/user/guides/customize-erpnext/custom-field.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/custom-field.md
@@ -13,7 +13,7 @@
 
 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]({{url_prefix}}/assets/old_images/erpnext/customize-form-custom-field.png)
+![Customize Form Custom Field]({{docs_base_url}}/assets/old_images/erpnext/customize-form-custom-field.png)
 
 Following are the steps to insert Custom Field in the existing form.
 
@@ -25,35 +25,35 @@
 
 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".
 
-![Custom Field Document]({{url_prefix}}/assets/old_images/erpnext/custom-field-document.png)
+![Custom Field Document]({{docs_base_url}}/assets/old_images/erpnext/custom-field-document.png)
 
 ####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]({{url_prefix}}/assets/old_images/erpnext/custom-field-label.png)
+![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]({{url_prefix}}/assets/old_images/erpnext/custom-field-insert.png)
+![Custom Field Insert]({{docs_base_url}}/assets/old_images/erpnext/custom-field-insert.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.
 
-![Custom Field Type]({{url_prefix}}/assets/old_images/erpnext/custom-field-type.png)
+![Custom Field Type]({{docs_base_url}}/assets/old_images/erpnext/custom-field-type.png)
 
 ####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.
 
-![Custom Field Link]({{url_prefix}}/assets/old_images/erpnext/custom-field-link.png)
+![Custom Field Link]({{docs_base_url}}/assets/old_images/erpnext/custom-field-link.png)
 
 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]({{url_prefix}}/assets/old_images/erpnext/custom-field-option.png)
+![Custom Field Option]({{docs_base_url}}/assets/old_images/erpnext/custom-field-option.png)
 
 For other field types, like Data, Date, Currency etc., Opton field will be left blank.
 
@@ -68,7 +68,7 @@
 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]({{url_prefix}}/assets/old_images/erpnext/custom-field-properties.png)
+![Custom Field Properties]({{docs_base_url}}/assets/old_images/erpnext/custom-field-properties.png)
 
 ####Deleting Custom Field
 
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/custom-button.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/custom-button.md
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/custom-button.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/custom-button.md
diff --git a/erpnext/docs/user/guides/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
similarity index 82%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/custom-script-fetch-values-from-master.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/custom-script-fetch-values-from-master.md
index 792460a..38395f9 100644
--- a/erpnext/docs/user/guides/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
@@ -20,6 +20,6 @@
 
 * * *
 
-See: [How to create a custom script]({{url_prefix}}/user/guides/customize-erpnext/custom-scripts.html)
+See: [How to create a custom script]({{docs_base_url}}/user/guides/customize-erpnext/custom-scripts.html)
 
 {next}
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/date-validation.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/date-validation.md
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/date-validation.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/date-validation.md
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/generate-item-code-based-on-custom-logic.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/generate-item-code-based-on-custom-logic.md
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/generate-item-code-based-on-custom-logic.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/generate-item-code-based-on-custom-logic.md
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/index.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/index.md
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/index.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/index.md
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/index.txt b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/index.txt
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/index.txt
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/make-read-only-after-saving.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/make-read-only-after-saving.md
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/make-read-only-after-saving.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/make-read-only-after-saving.md
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/restrict-cancel-rights.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/restrict-cancel-rights.md
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/restrict-cancel-rights.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/restrict-cancel-rights.md
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/restrict-purpose-of-stock-entry.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/restrict-purpose-of-stock-entry.md
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/restrict-purpose-of-stock-entry.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/restrict-purpose-of-stock-entry.md
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/restrict-user-based-on-child-record.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/restrict-user-based-on-child-record.md
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/restrict-user-based-on-child-record.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/restrict-user-based-on-child-record.md
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/sales-invoice-id-based-on-sales-order-id.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/sales-invoice-id-based-on-sales-order-id.md
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/sales-invoice-id-based-on-sales-order-id.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/sales-invoice-id-based-on-sales-order-id.md
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/update-date-field-based-on-value-in-other-date-field.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/update-date-field-based-on-value-in-other-date-field.md
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/custom-script-examples/update-date-field-based-on-value-in-other-date-field.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/custom-script-examples/update-date-field-based-on-value-in-other-date-field.md
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/index.md b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/index.md
similarity index 77%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/index.md
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/index.md
index 13ba6c6..e5e9d74 100644
--- a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/index.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/index.md
@@ -4,7 +4,7 @@
 
 > Setup > Customization > Custom Script
 
-![Custom Script]({{url_prefix}}/assets/old_images/erpnext/custom-script.png)
+![Custom Script]({{docs_base_url}}/assets/old_images/erpnext/custom-script.png)
 
 ### Topics
 
diff --git a/erpnext/docs/user/guides/customize-erpnext/custom-scripts/index.txt b/erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/custom-scripts/index.txt
rename to erpnext/docs/user/manual/en/customize-erpnext/custom-scripts/index.txt
diff --git a/erpnext/docs/user/guides/customize-erpnext/customize-form.md b/erpnext/docs/user/manual/en/customize-erpnext/customize-form.md
similarity index 90%
rename from erpnext/docs/user/guides/customize-erpnext/customize-form.md
rename to erpnext/docs/user/manual/en/customize-erpnext/customize-form.md
index c76d657..232f34b 100644
--- a/erpnext/docs/user/guides/customize-erpnext/customize-form.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/customize-form.md
@@ -11,13 +11,13 @@
 
 System Manager will find Customize Form option in the Sales Order list (or any other form for that matter) view as well.
 
-![Customize Form List View]({{url_prefix}}/assets/old_images/erpnext/customize-form-list-view.png)
+![Customize Form List View]({{docs_base_url}}/assets/old_images/erpnext/customize-form-list-view.png)
 
 ####Step 2: Select Docytpe/Document
 
 You should select Docytpe/Document which has field-to-be-customized located in it.
 
-![Customize Form Document]({{url_prefix}}/assets/old_images/erpnext/customize-form-document.png)
+![Customize Form Document]({{docs_base_url}}/assets/old_images/erpnext/customize-form-document.png)
 
 ####Step 3:Edit Property
 
@@ -25,7 +25,7 @@
 
 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.
 
-![Customize Form Mandatory]({{url_prefix}}/assets/old_images/erpnext/customize-form-mandatory.png)
+![Customize Form Mandatory]({{docs_base_url}}/assets/old_images/erpnext/customize-form-mandatory.png)
 
 Like this, you can customize following properties of the field.
 
@@ -38,7 +38,7 @@
 
 ####Step 4: Update
 
-![Customize Form Update]({{url_prefix}}/assets/old_images/erpnext/customize-form-update.png)
+![Customize Form Update]({{docs_base_url}}/assets/old_images/erpnext/customize-form-update.png)
 
 Before checking Sales Order form, you should clear cache and refresh browser tab for customization to take effect.
 
diff --git a/erpnext/docs/user/guides/customize-erpnext/document-title.md b/erpnext/docs/user/manual/en/customize-erpnext/document-title.md
similarity index 91%
rename from erpnext/docs/user/guides/customize-erpnext/document-title.md
rename to erpnext/docs/user/manual/en/customize-erpnext/document-title.md
index 338068a..639e358 100644
--- a/erpnext/docs/user/guides/customize-erpnext/document-title.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/document-title.md
@@ -21,13 +21,13 @@
     {customer_name} for {project}
 
 <img class="screenshot" alt = "Customize Title"
-    src="{{url_prefix}}/assets/img/customize/customize-title.gif">
+    src="{{docs_base_url}}/assets/img/customize/customize-title.gif">
 
 #### Fixed or Editable Titles
 
 If your title is generated as a default title, it can be edited by the user by clicking on the heading of the document.
 
 <img class="screenshot" alt = "Editable Title"
-    src="{{url_prefix}}/assets/img/customize/editable-title.gif">
+    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.
diff --git a/erpnext/docs/user/guides/customize-erpnext/hiding-modules-and-features.md b/erpnext/docs/user/manual/en/customize-erpnext/hiding-modules-and-features.md
similarity index 82%
rename from erpnext/docs/user/guides/customize-erpnext/hiding-modules-and-features.md
rename to erpnext/docs/user/manual/en/customize-erpnext/hiding-modules-and-features.md
index 57154ad..60addc1 100644
--- a/erpnext/docs/user/guides/customize-erpnext/hiding-modules-and-features.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/hiding-modules-and-features.md
@@ -7,7 +7,7 @@
 
 > Setup > Tools > Hide/Unhide Features
 
-![Hide Features]({{url_prefix}}/assets/old_images/erpnext/hide-features.png)
+![Hide Features]({{docs_base_url}}/assets/old_images/erpnext/hide-features.png)
 
 Check / uncheck the features you want to use and refresh your page for the
 changes to take effect.
@@ -20,7 +20,7 @@
 
 Setup > Tools> Modules Setup
 
-![Hide/Unhide Modules]({{url_prefix}}/assets/old_images/erpnext/hide-module.png)
+![Hide/Unhide Modules]({{docs_base_url}}/assets/old_images/erpnext/hide-module.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
diff --git a/erpnext/docs/user/guides/customize-erpnext/index.md b/erpnext/docs/user/manual/en/customize-erpnext/index.md
similarity index 100%
rename from erpnext/docs/user/guides/customize-erpnext/index.md
rename to erpnext/docs/user/manual/en/customize-erpnext/index.md
diff --git a/erpnext/docs/user/guides/customize-erpnext/index.txt b/erpnext/docs/user/manual/en/customize-erpnext/index.txt
similarity index 92%
rename from erpnext/docs/user/guides/customize-erpnext/index.txt
rename to erpnext/docs/user/manual/en/customize-erpnext/index.txt
index a225d44..1113395 100644
--- a/erpnext/docs/user/guides/customize-erpnext/index.txt
+++ b/erpnext/docs/user/manual/en/customize-erpnext/index.txt
@@ -5,3 +5,4 @@
 document-title
 hiding-modules-and-features
 print-format
+articles
diff --git a/erpnext/docs/user/guides/customize-erpnext/print-format.md b/erpnext/docs/user/manual/en/customize-erpnext/print-format.md
similarity index 95%
rename from erpnext/docs/user/guides/customize-erpnext/print-format.md
rename to erpnext/docs/user/manual/en/customize-erpnext/print-format.md
index c373d06..e3c9450 100644
--- a/erpnext/docs/user/guides/customize-erpnext/print-format.md
+++ b/erpnext/docs/user/manual/en/customize-erpnext/print-format.md
@@ -18,7 +18,7 @@
 
 > Setup > Printing > Print Formats
 
-![Print Format]({{url_prefix}}/assets/old_images/erpnext/customize/print-format.png)
+![Print Format]({{docs_base_url}}/assets/old_images/erpnext/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”
@@ -45,7 +45,7 @@
 
 > Setup > Printing and Branding > Print Settings
 
-![Print Format]({{url_prefix}}/assets/old_images/erpnext/customize/print-settings.png)
+![Print Format]({{docs_base_url}}/assets/old_images/erpnext/customize/print-settings.png)
 
 #### Example
 
diff --git a/erpnext/docs/user/guides/human-resources/appraisal.md b/erpnext/docs/user/manual/en/human-resources/appraisal.md
similarity index 75%
rename from erpnext/docs/user/guides/human-resources/appraisal.md
rename to erpnext/docs/user/manual/en/human-resources/appraisal.md
index 021d470..d3ec301 100644
--- a/erpnext/docs/user/guides/human-resources/appraisal.md
+++ b/erpnext/docs/user/manual/en/human-resources/appraisal.md
@@ -6,13 +6,13 @@
 
 #### Step 1: Select an Appraisal Template
 
-<img class="screenshot" alt="Appraisal" src="{{url_prefix}}/assets/img/human-resources/appraisal.png">
+<img class="screenshot" alt="Appraisal" src="{{docs_base_url}}/assets/img/human-resources/appraisal.png">
 
 After you select the template, the remaining form appears.
 
 #### Step 2: Enter Employee Details
 
-<img class="screenshot" alt="Appraisal" src="{{url_prefix}}/assets/img/human-resources/appraisal-employee.png">
+<img class="screenshot" alt="Appraisal" src="{{docs_base_url}}/assets/img/human-resources/appraisal-employee.png">
 
 Once the Appraisal Template is completed, you can create Appraisal records for
 each period where you track performance. You can give points out of 5 for each
diff --git a/erpnext/docs/user/manual/en/human-resources/articles/employees-loan-management.md b/erpnext/docs/user/manual/en/human-resources/articles/employees-loan-management.md
new file mode 100644
index 0000000..fddab31
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/articles/employees-loan-management.md
@@ -0,0 +1,55 @@
+<h1>Employees Loan Management</h1>
+
+Employee Loan is an sum of money paid by Employer to Employee based on certain terms and condition. There are multiple ways accounting for the Employee loan can be managed. Company could collect loan from an employee separately. Or they can choose to deduct loan installment from the employee's salary.
+
+Let's check below how accounting can be managed for Employee Loan in ERPNext.
+
+### 1. Setup Masters
+
+Create following Groups and Ledgers in Chart of Accounts if not there.
+      
+#### 1.1  Employee Loan Account
+
+Create Group as 'Employees Loans' under Current Assets and create employee loan A/C (Ledger) under it. [Check this link for new account creation](https://erpnext.com/kb/setup/managing-tree-structure-masters)
+
+![CoA]({{docs_base_url}}/assets/img/articles/Selection_433.png)
+
+#### 1.2 Salaries Account
+
+Create Group as 'Salaries' under Current Liabilities and create employee salary loan A/C (Ledger) under it.
+
+![CoA]({{docs_base_url}}/assets/img/articles/Selection_434.png)
+
+#### 1.3 Interest Account
+
+Create Ledger as 'Interest on Loan' under Indirect Income.
+
+### 2. Book Loan Amount
+
+Once loan amount is finalized, make journal voucher to book loan payment entry. You should Credit Loan amount to Bank/Cash account and Debit Loan amount employee loan account.  
+
+![Loan Entry]({{docs_base_url}}/assets/img/articles/Selection_435.png)
+
+### 3. Book Loan Recovery and Interest
+
+#### 3.1 Loan Recovery Entry
+
+If your employee pays separately for his/her loan installment and loan interest, then create journal voucher. 
+
+![Loan Reco]({{docs_base_url}}/assets/img/articles/Selection_436.png)
+
+#### 3.2 Loan Adjustment in Salary
+
+And if you deduct loan installment and interest from employees salary, then book journal entry for the same.
+
+![Loan Reco]({{docs_base_url}}/assets/img/articles/Selection_437.png)
+
+In the Salary Slip of an employee, then create two Deduction Types in Salary Structure. One as 'Loan Installment' and other one as 'Loan Interest'. So that you can update those values under this deduction heads.
+
+### 4. Loan Account Report
+
+After recovering loan and loan interest, General Ledger report will show the loan account details as follows.
+
+![Loan Reco]({{docs_base_url}}/assets/img/articles/Selection_439.png)
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/human-resources/articles/index.md b/erpnext/docs/user/manual/en/human-resources/articles/index.md
new file mode 100644
index 0000000..4e1be28
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/articles/index.md
@@ -0,0 +1 @@
+{content}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/human-resources/articles/index.txt b/erpnext/docs/user/manual/en/human-resources/articles/index.txt
new file mode 100644
index 0000000..3fbdc5b
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/articles/index.txt
@@ -0,0 +1,2 @@
+employees-loan-management
+leave-calculation-in-salary-slip
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/human-resources/articles/leave-calculation-in-salary-slip.md b/erpnext/docs/user/manual/en/human-resources/articles/leave-calculation-in-salary-slip.md
new file mode 100644
index 0000000..7153708
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/articles/leave-calculation-in-salary-slip.md
@@ -0,0 +1,52 @@
+<h1>Leave Calculation In Salary Slip</h1>
+
+There are two types of leave which user can apply for.
+<br>
+<br>
+<ol>
+    <li>Paid Leave (Sick Leave, Privilege Leave, Casual Leave etc.)</li>
+    <li>Unpaid Leave
+        <br>
+    </li>
+</ol>Paid Leave are firstly allocated by HR manager. As and when Employee creates Leave Application, leaves allocated to him/her are deducted. These leaves doesn't have impact on the employee's Salary Slip.
+<br>
+<br>When Employee is out of paid leave, he create Leave Application for unpaid leave. The term used for unpaid leave in ERPNext is Leave Without Pay (LWP). These leaves does have impact on the Employee's Salary Slip.
+<br>
+<br>
+<div class="well">Just marking Absent in the Attendance record do not have impact on salary calculation of an Employee, as that absenteeism could be because of paid leave. Hence creating Leave Application should be created incase of absenteeism.<br></div>Let's consider
+a scenario to understand how leaves impact employees Salary Slip.
+<br>
+<br><b>Masters:</b>
+
+<br>
+<br>
+<ol>
+    <li>Setup Employee</li>
+    <li>Allocate him paid leaves</li>
+    <li>Create Salary Structure for that Employee. In the Earning and Deduction table, select which component of salary should be affected if Employee takes LWP.</li>
+    <li>Create Holiday List (if any), and link it with Employee master.</li>
+</ol>
+<p>When creating Salary Slip for an Employee, following is what you will see:</p>
+<img src="{{docs_base_url}}/assets/img/articles/SGrab_282.png">
+<br>
+<br><b>Working Days:</b> Working Days in Salary Slip are calculated based on number of days selected above. If you don't wish to consider holiday in Working Days, then you should do following setting.
+<br>
+<br>
+<div class="well">Human Resource &gt;&gt; Setup &gt;&gt; HR Setting
+    <br>
+    <br>Uncheck field "Include Holidays in Total No. of Working Days"
+    <br>
+</div>Holidays are counted based on Holiday List attached to the Employee's master.<b><br><br>Leave Without Pay: </b>Leave Without Pay is updated based on Leave Application made for this Employee, in the month for which Salary Slip is created, and which has
+Leave Type as "Leave Without Pay".
+<br>
+<br><b>Payment Days:</b> Following is how Payment Days are calculated:
+<br>
+<br>Payment Days = Working Days - Leave Without Pay
+<br>
+<br>As indicated above, if you have LWP checked for components in the earning and deducted table, you will notice a reduction in Amount based on no. of LWP of an Employee for that month.
+<br>
+<br>
+<img src="{{docs_base_url}}/assets/img/articles/SGrab_283.png" width="760"><br>
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/attendance.md b/erpnext/docs/user/manual/en/human-resources/attendance.md
similarity index 64%
rename from erpnext/docs/user/guides/human-resources/attendance.md
rename to erpnext/docs/user/manual/en/human-resources/attendance.md
index 66c3a4c..961d528 100644
--- a/erpnext/docs/user/guides/human-resources/attendance.md
+++ b/erpnext/docs/user/manual/en/human-resources/attendance.md
@@ -3,12 +3,12 @@
 
 > Human Resources > Attendance > New Attendance
 
-<img class="screenshot" alt="Attendence" src="{{url_prefix}}/assets/img/human-resources/attendence.png">
+<img class="screenshot" alt="Attendence" src="{{docs_base_url}}/assets/img/human-resources/attendence.png">
 
 You can get a monthly report of your Attendance data by going to the “Monthly
 Attendance Details” report.
 
-You can also bulk uppload attendence using the [Upload Attendence Tool ]({{url_prefix}}/user/guides/human-resources/tools/upload-attendance.html)
+You can also bulk uppload attendence using the [Upload Attendence Tool ]({{docs_base_url}}/user/guides/human-resources/tools/upload-attendance.html)
 
 {next}
 
diff --git a/erpnext/docs/user/manual/en/human-resources/employee.md b/erpnext/docs/user/manual/en/human-resources/employee.md
new file mode 100644
index 0000000..fd14aa9
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/employee.md
@@ -0,0 +1,9 @@
+There are many fields you can add in your Employee records.
+
+To create new Employee go to:
+
+> Human Resources > Employee > New
+
+<img class="screenshot" alt="Employee" src="{{docs_base_url}}/assets/img/human-resources/employee.png">
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/expense-claim.md b/erpnext/docs/user/manual/en/human-resources/expense-claim.md
similarity index 87%
rename from erpnext/docs/user/guides/human-resources/expense-claim.md
rename to erpnext/docs/user/manual/en/human-resources/expense-claim.md
index 0a86f9a..187bf49 100644
--- a/erpnext/docs/user/guides/human-resources/expense-claim.md
+++ b/erpnext/docs/user/manual/en/human-resources/expense-claim.md
@@ -6,7 +6,7 @@
 
 > HR > Expense Claim > New Expense Claim
 
-<img class="screenshot" alt="Expense Claim" src="{{url_prefix}}/assets/img/human-resources/expense_claim.png">
+<img class="screenshot" alt="Expense Claim" src="{{docs_base_url}}/assets/img/human-resources/expense_claim.png">
 
 Set the Employee ID, date and the list of expenses that are to be claimed and
 “Submit” the record.
@@ -34,6 +34,6 @@
 
 * To Link Expense Claim with Task or Project specify the Task or the Project while making an Expense Claim
 
-<img class="screenshot" alt="Expense Claim - Project Link" src="{{url_prefix}}/assets/img/project/project_expense_claim_link.png">
+<img class="screenshot" alt="Expense Claim - Project Link" src="{{docs_base_url}}/assets/img/project/project_expense_claim_link.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/human-resources/holiday-list.md b/erpnext/docs/user/manual/en/human-resources/holiday-list.md
similarity index 91%
rename from erpnext/docs/user/guides/human-resources/holiday-list.md
rename to erpnext/docs/user/manual/en/human-resources/holiday-list.md
index 9676785..1a98ad3 100644
--- a/erpnext/docs/user/guides/human-resources/holiday-list.md
+++ b/erpnext/docs/user/manual/en/human-resources/holiday-list.md
@@ -17,7 +17,7 @@
   
 #### Figure 1: Holiday List
 
-![]({{url_prefix}}/assets/old_images/erpnext/holiday-list-1.png)  
+![]({{docs_base_url}}/assets/old_images/erpnext/holiday-list-1.png)  
 
   
 
@@ -40,7 +40,7 @@
   
 #### Figure 2: Adding new holidays to the list
 
-![]({{url_prefix}}/assets/old_images/erpnext/holiday-list-2.png)  
+![]({{docs_base_url}}/assets/old_images/erpnext/holiday-list-2.png)  
 
   
 
diff --git a/erpnext/docs/user/guides/human-resources/human-resource-setup.md b/erpnext/docs/user/manual/en/human-resources/human-resource-setup.md
similarity index 100%
rename from erpnext/docs/user/guides/human-resources/human-resource-setup.md
rename to erpnext/docs/user/manual/en/human-resources/human-resource-setup.md
diff --git a/erpnext/docs/user/manual/en/human-resources/human-resources-reports.md b/erpnext/docs/user/manual/en/human-resources/human-resources-reports.md
new file mode 100644
index 0000000..664c07d
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/human-resources-reports.md
@@ -0,0 +1,34 @@
+Human Resources Reports
+
+### Employee Leave Balance
+
+Employee Leave Balance Report shows employees and their respective balance leaves under various leave types. Report is generated as per the number of allowed leaves.
+
+<img alt="Employee Leave Balance" class="screenshot" src="{{docs_base_url}}/assets/img/human-resources/employee-leave-balance-report.png">
+
+### Employee Birthday
+
+Employee Birthday Report shows Birthdays of your employees.
+
+<img alt="Employee Birthday" class="screenshot" src="{{docs_base_url}}/assets/img/human-resources/employee-birthday-report.png">
+
+### Employee Information
+
+Employee Information Report shows Report View of important information recorded in Employee master.
+
+<img alt="Employee Information" class="screenshot" src="{{docs_base_url}}/assets/img/human-resources/employee-information-report.png">
+
+### Monthly Salary Register
+
+Monthly Salary Register shows net pay and its components of employee(s) at a glance.
+
+<img alt="Monthly Salary Register" class="screenshot" src="{{docs_base_url}}/assets/img/human-resources/monthly-salary-register-report.png">
+
+
+### Monthly Attendance Sheet
+
+Monthly Attendance Sheet shows monthly attendance of selected employee at a glance.
+
+<img alt="Monthly Attendance Sheet" class="screenshot" src="{{docs_base_url}}/assets/img/human-resources/monthly-attendance-sheet-report.png">
+
+{next}
diff --git a/erpnext/docs/user/guides/human-resources/index.md b/erpnext/docs/user/manual/en/human-resources/index.md
similarity index 100%
rename from erpnext/docs/user/guides/human-resources/index.md
rename to erpnext/docs/user/manual/en/human-resources/index.md
diff --git a/erpnext/docs/user/guides/human-resources/index.txt b/erpnext/docs/user/manual/en/human-resources/index.txt
similarity index 78%
rename from erpnext/docs/user/guides/human-resources/index.txt
rename to erpnext/docs/user/manual/en/human-resources/index.txt
index eba8acc..caa3292 100644
--- a/erpnext/docs/user/guides/human-resources/index.txt
+++ b/erpnext/docs/user/manual/en/human-resources/index.txt
@@ -10,3 +10,6 @@
 tools
 human-resources-reports
 setup
+holiday-list
+human-resource-setup
+articles
diff --git a/erpnext/docs/user/guides/human-resources/job-applicant.md b/erpnext/docs/user/manual/en/human-resources/job-applicant.md
similarity index 66%
rename from erpnext/docs/user/guides/human-resources/job-applicant.md
rename to erpnext/docs/user/manual/en/human-resources/job-applicant.md
index 3fafa95..3e885d9 100644
--- a/erpnext/docs/user/guides/human-resources/job-applicant.md
+++ b/erpnext/docs/user/manual/en/human-resources/job-applicant.md
@@ -1,10 +1,10 @@
-You can mantain a list of People who have applied for a [Job Opening]({{url_prefix}}/user/guides/human-resources/job-opening.html).
+You can mantain a list of People who have applied for a [Job Opening]({{docs_base_url}}/user/guides/human-resources/job-opening.html).
 
 To create a new Job Applicant go to 
 
 > Human Resource > Job Applicant > New
 
-<img class="screenshot" alt="Job Applicant" src="{{url_prefix}}/assets/img/human-resources/job-applicant.png">
+<img class="screenshot" alt="Job Applicant" src="{{docs_base_url}}/assets/img/human-resources/job-applicant.png">
 
 ### Linking with an Email Account
 
@@ -20,6 +20,6 @@
 
 * In 'Append To' select 'Job Applicant'
 
-<img class="screenshot" alt="Email Account" src="{{url_prefix}}/assets/img/human-resources/email-account.png">
+<img class="screenshot" alt="Email Account" src="{{docs_base_url}}/assets/img/human-resources/email-account.png">
 
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/human-resources/job-opening.md b/erpnext/docs/user/manual/en/human-resources/job-opening.md
new file mode 100644
index 0000000..7e4f0c3
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/job-opening.md
@@ -0,0 +1,10 @@
+You can make a record of the open vacancies in your company using Job Opening.
+
+To create a new Job Opening go to 
+
+> Human Resource > Job Opening > New
+
+<img class="screenshot" alt="Job Opening" src="{{docs_base_url}}/assets/img/human-resources/job-opening.png">
+
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/leave-application.md b/erpnext/docs/user/manual/en/human-resources/leave-application.md
similarity index 68%
rename from erpnext/docs/user/guides/human-resources/leave-application.md
rename to erpnext/docs/user/manual/en/human-resources/leave-application.md
index ecc4677..04e3144 100644
--- a/erpnext/docs/user/guides/human-resources/leave-application.md
+++ b/erpnext/docs/user/manual/en/human-resources/leave-application.md
@@ -5,7 +5,7 @@
 
 > Human Resources > Leave Application > New Leave Application
 
-<img class="screenshot" alt="Leave Application" src="{{url_prefix}}/assets/img/human-resources/leave-application.png">
+<img class="screenshot" alt="Leave Application" src="{{docs_base_url}}/assets/img/human-resources/leave-application.png">
 
 ###Setting Leave Approver
 
@@ -13,12 +13,12 @@
 
 * You need to mention a list of Leave Approvers against an Employee in the Employee Master.
 
-<img class="screenshot" alt="Leave Approver" src="{{url_prefix}}/assets/img/human-resources/employee-leave-approver.png">
+<img class="screenshot" alt="Leave Approver" src="{{docs_base_url}}/assets/img/human-resources/employee-leave-approver.png">
 
 > Tip : If you want all users to create their own Leave Applications, you can set
 their “Employee ID” as a match rule in the Leave Application Permission
-settings. See the earlier discussion on [Setting Up Permissions]({{url_prefix}}/user/guides/setting-up/users-and-permissions.html)
+settings. See the earlier discussion on [Setting Up Permissions]({{docs_base_url}}/user/guides/setting-up/users-and-permissions.html)
 for more info.
 
-You assign Leaves aginast an Employee check [Leave Allocation]({{url_prefix}}/user/guides/human-resources/setup/leave-allocation.html)
+You assign Leaves aginast an Employee check [Leave Allocation]({{docs_base_url}}/user/guides/human-resources/setup/leave-allocation.html)
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/offer-letter.md b/erpnext/docs/user/manual/en/human-resources/offer-letter.md
similarity index 61%
rename from erpnext/docs/user/guides/human-resources/offer-letter.md
rename to erpnext/docs/user/manual/en/human-resources/offer-letter.md
index 16176f1..c48fe64 100644
--- a/erpnext/docs/user/guides/human-resources/offer-letter.md
+++ b/erpnext/docs/user/manual/en/human-resources/offer-letter.md
@@ -5,12 +5,12 @@
 
 > Human Resource > Offer Letter > New
 
-<img class="screenshot" alt="Offer Letter" src="{{url_prefix}}/assets/img/human-resources/offer-letter.png">
+<img class="screenshot" alt="Offer Letter" src="{{docs_base_url}}/assets/img/human-resources/offer-letter.png">
 
-> Note: An offer letter can be made only against a [Job Applicant]({{url_prefix}}/user/guides/human-resources/job-applicant.html)
+> Note: An offer letter can be made only against a [Job Applicant]({{docs_base_url}}/user/guides/human-resources/job-applicant.html)
 
 There is a pre-designed print format to print you offer letter.
 
-<img class="screenshot" alt="Offer Letter" src="{{url_prefix}}/assets/img/human-resources/offer-letter-print.png">
+<img class="screenshot" alt="Offer Letter" src="{{docs_base_url}}/assets/img/human-resources/offer-letter-print.png">
 
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/salary-and-payroll.md b/erpnext/docs/user/manual/en/human-resources/salary-and-payroll.md
similarity index 93%
rename from erpnext/docs/user/guides/human-resources/salary-and-payroll.md
rename to erpnext/docs/user/manual/en/human-resources/salary-and-payroll.md
index 64c8f3c..05e01e1 100644
--- a/erpnext/docs/user/guides/human-resources/salary-and-payroll.md
+++ b/erpnext/docs/user/manual/en/human-resources/salary-and-payroll.md
@@ -44,7 +44,7 @@
 
 #### Figure 1:Salary Structure
 
-<img class="screenshot" alt="Salary Structure" src="{{url_prefix}}/assets/img/human-resources/salary-structure.png">
+<img class="screenshot" alt="Salary Structure" src="{{docs_base_url}}/assets/img/human-resources/salary-structure.png">
 
 ### In the Salary Structure,
 
@@ -76,7 +76,7 @@
 
 #### Figure 2: Salary Slip
 
-<img class="screenshot" alt="Salary Slip" src="{{url_prefix}}/assets/img/human-resources/salary-slip.png">
+<img class="screenshot" alt="Salary Slip" src="{{docs_base_url}}/assets/img/human-resources/salary-slip.png">
 
 You can also create salary slip for multiple employees using Process Payroll:
 
@@ -84,7 +84,7 @@
 
 #### Figure 3: Process Payroll
 
-<img class="screenshot" alt="Process Payroll" src="{{url_prefix}}/assets/img/human-resources/process-payroll.png">
+<img class="screenshot" alt="Process Payroll" src="{{docs_base_url}}/assets/img/human-resources/process-payroll.png">
 
 In Process Payroll,
 
diff --git a/erpnext/docs/user/manual/en/human-resources/setup/branch.md b/erpnext/docs/user/manual/en/human-resources/setup/branch.md
new file mode 100644
index 0000000..8116ca4
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/setup/branch.md
@@ -0,0 +1,5 @@
+Branches of your organization
+
+<img class="screenshot" alt="Branch" src="{{docs_base_url}}/assets/img/human-resources/branch.png">
+
+{next}
diff --git a/erpnext/docs/user/guides/human-resources/setup/deduction-type.md b/erpnext/docs/user/manual/en/human-resources/setup/deduction-type.md
similarity index 61%
rename from erpnext/docs/user/guides/human-resources/setup/deduction-type.md
rename to erpnext/docs/user/manual/en/human-resources/setup/deduction-type.md
index dde17a3..4371b62 100644
--- a/erpnext/docs/user/guides/human-resources/setup/deduction-type.md
+++ b/erpnext/docs/user/manual/en/human-resources/setup/deduction-type.md
@@ -4,7 +4,7 @@
 
 > Human Resource > Setup > Deduction Type > New
 
-<img class="screenshot" alt="Deduction Type" src="{{url_prefix}}/assets/img/human-resources/deduction-type.png">
+<img class="screenshot" alt="Deduction Type" src="{{docs_base_url}}/assets/img/human-resources/deduction-type.png">
 
 
 {next}
diff --git a/erpnext/docs/user/manual/en/human-resources/setup/department.md b/erpnext/docs/user/manual/en/human-resources/setup/department.md
new file mode 100644
index 0000000..1b088b1
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/setup/department.md
@@ -0,0 +1,5 @@
+Departments in your organization
+
+<img class="screenshot" alt="Department" src="{{docs_base_url}}/assets/img/human-resources/department.png">
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/human-resources/setup/designation.md b/erpnext/docs/user/manual/en/human-resources/setup/designation.md
new file mode 100644
index 0000000..1de779e
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/setup/designation.md
@@ -0,0 +1,5 @@
+Designations in your organization
+
+<img class="screenshot" alt="Designation" src="{{docs_base_url}}/assets/img/human-resources/designation.png">
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/human-resources/setup/earning-type.md b/erpnext/docs/user/manual/en/human-resources/setup/earning-type.md
new file mode 100644
index 0000000..e5c35c6
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/setup/earning-type.md
@@ -0,0 +1,10 @@
+You can make a record of the Salary Components and describe it as Earning Type
+
+To create a new Earning Type
+
+> Human Resource > Setup > Earning Type > New
+
+<img class="screenshot" alt="Earning Type" src="{{docs_base_url}}/assets/img/human-resources/earning-type.png">
+
+
+{next}
diff --git a/erpnext/docs/user/manual/en/human-resources/setup/employment-type.md b/erpnext/docs/user/manual/en/human-resources/setup/employment-type.md
new file mode 100644
index 0000000..37d0fd3
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/setup/employment-type.md
@@ -0,0 +1,5 @@
+Various employment contracts you have with your employees.
+
+<img class="screenshot" alt="Employment Type" src="{{docs_base_url}}/assets/img/human-resources/employment-type.png">
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/human-resources/setup/holiday-list.md b/erpnext/docs/user/manual/en/human-resources/setup/holiday-list.md
new file mode 100644
index 0000000..31094f7
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/setup/holiday-list.md
@@ -0,0 +1,5 @@
+You can specify the Holidays for a particular year using Holiday List.
+
+<img class="screenshot" alt="Holiday List" src="{{docs_base_url}}/assets/img/human-resources/holiday-list.png">
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/human-resources/setup/hr-settings.md b/erpnext/docs/user/manual/en/human-resources/setup/hr-settings.md
new file mode 100644
index 0000000..1741df4
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/setup/hr-settings.md
@@ -0,0 +1,7 @@
+# HR Settings
+
+GLobal settings for HR related documents
+
+<img class="screenshot" alt="HR Settings" src="{{docs_base_url}}/assets/img/human-resources/hr-settings.png">
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/setup/index.md b/erpnext/docs/user/manual/en/human-resources/setup/index.md
similarity index 100%
rename from erpnext/docs/user/guides/human-resources/setup/index.md
rename to erpnext/docs/user/manual/en/human-resources/setup/index.md
diff --git a/erpnext/docs/user/guides/human-resources/setup/index.txt b/erpnext/docs/user/manual/en/human-resources/setup/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/human-resources/setup/index.txt
rename to erpnext/docs/user/manual/en/human-resources/setup/index.txt
diff --git a/erpnext/docs/user/manual/en/human-resources/setup/leave-allocation.md b/erpnext/docs/user/manual/en/human-resources/setup/leave-allocation.md
new file mode 100644
index 0000000..91cf990
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/setup/leave-allocation.md
@@ -0,0 +1,7 @@
+Helps you allocate Leaves to a particular Employee
+
+<img class="screenshot" alt="Leave Allocation" src="{{docs_base_url}}/assets/img/human-resources/leave-allocation.png">
+
+To assign leaves to multiple employees use the [Leave Allocation Tool]({{docs_base_url}}/user/guides/human-resources/tools/leave-allocation-tool.html)
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/human-resources/setup/leave-type.md b/erpnext/docs/user/manual/en/human-resources/setup/leave-type.md
similarity index 74%
rename from erpnext/docs/user/guides/human-resources/setup/leave-type.md
rename to erpnext/docs/user/manual/en/human-resources/setup/leave-type.md
index 78b3ab6..d52cb2e 100644
--- a/erpnext/docs/user/guides/human-resources/setup/leave-type.md
+++ b/erpnext/docs/user/manual/en/human-resources/setup/leave-type.md
@@ -1,6 +1,6 @@
 Specify the Type of Leave that can be allocated against an Employee
 
-<img class="screenshot" alt="Leave Type" src="{{url_prefix}}/assets/img/human-resources/leave-type.png">
+<img class="screenshot" alt="Leave Type" src="{{docs_base_url}}/assets/img/human-resources/leave-type.png">
 
 * 'Max Days Leave Allowed' specifies the maximum number of days this type of leave can be taken at a strech.
 * 'Is LWP' specifies if the Leave is without Pay.
diff --git a/erpnext/docs/user/guides/human-resources/tools/index.md b/erpnext/docs/user/manual/en/human-resources/tools/index.md
similarity index 100%
rename from erpnext/docs/user/guides/human-resources/tools/index.md
rename to erpnext/docs/user/manual/en/human-resources/tools/index.md
diff --git a/erpnext/docs/user/guides/human-resources/tools/index.txt b/erpnext/docs/user/manual/en/human-resources/tools/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/human-resources/tools/index.txt
rename to erpnext/docs/user/manual/en/human-resources/tools/index.txt
diff --git a/erpnext/docs/user/manual/en/human-resources/tools/leave-allocation-tool.md b/erpnext/docs/user/manual/en/human-resources/tools/leave-allocation-tool.md
new file mode 100644
index 0000000..56e8d3d
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/tools/leave-allocation-tool.md
@@ -0,0 +1,5 @@
+Leave Allocation tool helps you allocated a specific number of leaves for your employees.
+
+<img class="screenshot" alt="Leave Application" src="{{docs_base_url}}/assets/img/human-resources/leave-application.png">
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/human-resources/tools/upload-attendance.md b/erpnext/docs/user/manual/en/human-resources/tools/upload-attendance.md
new file mode 100644
index 0000000..adfc66d
--- /dev/null
+++ b/erpnext/docs/user/manual/en/human-resources/tools/upload-attendance.md
@@ -0,0 +1,9 @@
+This tool helps you to upload bulk attendence from a csv file.
+
+To upload the attendance go to:
+
+> Human Resources > Upload Attendance
+
+<img class="screenshot" alt="Attendence upload" src="{{docs_base_url}}/assets/img/human-resources/attendence-upload.png">
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/index.md b/erpnext/docs/user/manual/en/index.md
new file mode 100644
index 0000000..2184273
--- /dev/null
+++ b/erpnext/docs/user/manual/en/index.md
@@ -0,0 +1,5 @@
+# User Manual (English)
+
+### Contents:
+
+{index}
diff --git a/erpnext/docs/user/guides/index.txt b/erpnext/docs/user/manual/en/index.txt
similarity index 87%
rename from erpnext/docs/user/guides/index.txt
rename to erpnext/docs/user/manual/en/index.txt
index e9e30ed..97a8cd8 100644
--- a/erpnext/docs/user/guides/index.txt
+++ b/erpnext/docs/user/manual/en/index.txt
@@ -11,5 +11,5 @@
 human-resources
 customer-portal
 website
-collaboration-tools
-customize-erpnext
\ No newline at end of file
+using-erpnext
+customize-erpnext
diff --git a/erpnext/docs/user/guides/introduction/concepts-and-terms.md b/erpnext/docs/user/manual/en/introduction/concepts-and-terms.md
similarity index 100%
rename from erpnext/docs/user/guides/introduction/concepts-and-terms.md
rename to erpnext/docs/user/manual/en/introduction/concepts-and-terms.md
diff --git a/erpnext/docs/user/guides/introduction/do-i-need-an-erp.md b/erpnext/docs/user/manual/en/introduction/do-i-need-an-erp.md
similarity index 100%
rename from erpnext/docs/user/guides/introduction/do-i-need-an-erp.md
rename to erpnext/docs/user/manual/en/introduction/do-i-need-an-erp.md
diff --git a/erpnext/docs/user/guides/introduction/getting-started-with-erpnext.md b/erpnext/docs/user/manual/en/introduction/getting-started-with-erpnext.md
similarity index 100%
rename from erpnext/docs/user/guides/introduction/getting-started-with-erpnext.md
rename to erpnext/docs/user/manual/en/introduction/getting-started-with-erpnext.md
diff --git a/erpnext/docs/user/guides/introduction/implementation-strategy.md b/erpnext/docs/user/manual/en/introduction/implementation-strategy.md
similarity index 100%
rename from erpnext/docs/user/guides/introduction/implementation-strategy.md
rename to erpnext/docs/user/manual/en/introduction/implementation-strategy.md
diff --git a/erpnext/docs/user/guides/introduction/index.md b/erpnext/docs/user/manual/en/introduction/index.md
similarity index 100%
rename from erpnext/docs/user/guides/introduction/index.md
rename to erpnext/docs/user/manual/en/introduction/index.md
diff --git a/erpnext/docs/user/guides/introduction/index.txt b/erpnext/docs/user/manual/en/introduction/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/introduction/index.txt
rename to erpnext/docs/user/manual/en/introduction/index.txt
diff --git a/erpnext/docs/user/guides/introduction/key-workflows.md b/erpnext/docs/user/manual/en/introduction/key-workflows.md
similarity index 69%
rename from erpnext/docs/user/guides/introduction/key-workflows.md
rename to erpnext/docs/user/manual/en/introduction/key-workflows.md
index f83c8a6..8c8d6ec 100644
--- a/erpnext/docs/user/guides/introduction/key-workflows.md
+++ b/erpnext/docs/user/manual/en/introduction/key-workflows.md
@@ -3,10 +3,10 @@
 This diagram covers how ERPNext tracks your company information across key
 functions. This diagram does not cover all the features of ERPNext.
 
-![]({{url_prefix}}/assets/old_images/erpnext/overview.png)
+![]({{docs_base_url}}/assets/old_images/erpnext/overview.png)
 
 
-[Full Resolution]({{url_prefix}}/assets/old_images/erpnext/overview.png)
+[Full Resolution]({{docs_base_url}}/assets/old_images/erpnext/overview.png)
 
 _Note: Not all of the steps are mandatory. ERPNext allows you to freely skip
 steps if you want to simplify the process._
diff --git a/erpnext/docs/user/guides/introduction/open-source.md b/erpnext/docs/user/manual/en/introduction/open-source.md
similarity index 100%
rename from erpnext/docs/user/guides/introduction/open-source.md
rename to erpnext/docs/user/manual/en/introduction/open-source.md
diff --git a/erpnext/docs/user/guides/introduction/the-champion.md b/erpnext/docs/user/manual/en/introduction/the-champion.md
similarity index 93%
rename from erpnext/docs/user/guides/introduction/the-champion.md
rename to erpnext/docs/user/manual/en/introduction/the-champion.md
index 596ff4b..21a2383 100644
--- a/erpnext/docs/user/guides/introduction/the-champion.md
+++ b/erpnext/docs/user/manual/en/introduction/the-champion.md
@@ -2,7 +2,7 @@
 
 <h1 class="white">The Champion</h1>
 
-<img class="cover" src="{{url_prefix}}/assets/old_images/erpnext/implementation-image.png">
+<img class="cover" src="{{docs_base_url}}/assets/old_images/erpnext/implementation-image.png">
 
 We have seen dozens of ERP implementations over the past few years and we
 realize that successful implementation is a lot about intangibles and
diff --git a/erpnext/docs/user/manual/en/manufacturing/articles/index.md b/erpnext/docs/user/manual/en/manufacturing/articles/index.md
new file mode 100644
index 0000000..4e1be28
--- /dev/null
+++ b/erpnext/docs/user/manual/en/manufacturing/articles/index.md
@@ -0,0 +1 @@
+{content}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/manufacturing/articles/index.txt b/erpnext/docs/user/manual/en/manufacturing/articles/index.txt
new file mode 100644
index 0000000..59f3503
--- /dev/null
+++ b/erpnext/docs/user/manual/en/manufacturing/articles/index.txt
@@ -0,0 +1,4 @@
+nested-bom-structure
+partial-production-entry
+production-planning-subassembly
+valuation-based-on-field-in-bom
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/manufacturing/articles/nested-bom-structure.md b/erpnext/docs/user/manual/en/manufacturing/articles/nested-bom-structure.md
new file mode 100644
index 0000000..266ae12
--- /dev/null
+++ b/erpnext/docs/user/manual/en/manufacturing/articles/nested-bom-structure.md
@@ -0,0 +1,30 @@
+<h1>Nested BOM Structure</h1>
+
+**Question:** Our manufacturing process involves producing sub-assembly items before final product. How should we manage BOM master in this scenario?
+
+**Answer:** You should create BOM for item in the order of their production. Let's consider an example to understand this better.
+
+If Computer manufacturer assembles Hard Disk and DVD Drive (sub-assemblies) themselves, they should first create BOM for Hard Disk and DVD Drive. After that BOM for Computer will be created, which is finished and saleable item. BOM of computer will have&nbsp;
+Hard Disk and DVD Drive (sub-assemblies) will be selected as raw-material items in it. BOM ID will be fetched for the respective sub-assembly item.
+
+
+<img src="{{docs_base_url}}/assets/img/articles/Screen Shot 2015-04-02 at 3.58.19 pm.png">
+
+<br>Following is how the structure of nested BOM will look:
+<br>
+<br><b>Computer (FG Item)</b>
+<br><b>---</b> Mother Board
+<br><b>---</b> SMTP
+<br><b>---</b> Accessories and wires
+<br><b>---</b>  <i>Hard Disk (sub-assembly)</i>
+<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ------ Item A
+<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ------ Item B
+<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ------ Item C
+<br><b>---</b>  <i>DVD Drive (sub-assembly)</i>
+<br>&nbsp;&nbsp;&nbsp; &nbsp; ------ Item X
+<br>&nbsp; &nbsp; &nbsp; ------ Item Y
+<br>&nbsp;&nbsp; &nbsp;&nbsp; ------ Item Z
+<br>
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/manufacturing/articles/partial-production-entry.md b/erpnext/docs/user/manual/en/manufacturing/articles/partial-production-entry.md
new file mode 100644
index 0000000..e2a702e
--- /dev/null
+++ b/erpnext/docs/user/manual/en/manufacturing/articles/partial-production-entry.md
@@ -0,0 +1,25 @@
+<h1>Partial Production Entry</h1>
+
+If you completed production for few items, then you can make Partial Production Entry for that items in system. For example, your production order is for 15 quantity and you completed production for 10 quantity only. Then you can make production entry for 5 quantity. Following are step to make Partial Production Entry
+
+#### 1. Stock Entry
+
+Click on Update Finish Goods button from submitted Product Order, You will land on new Stock entry form.
+
+#### 2. Edit Manufacturing Quantity
+
+In the Update Finished Goods entry, check "From Bill of Material section", and edit Manufacturing Quantity to actual quantity produced.  Production Order quantity will be fetched as Manufacturing Quantity by default.
+
+#### 3. Update Qty of Items
+
+Click on **Get Items**. With this, quantity will be updated for both raw-material as well as finish good item. 
+
+![FGE STE]({{docs_base_url}}/assets/img/articles/Selection_078.png)
+
+#### 4. Save and Submit 
+
+After updating quantity in stock entry form, save and submit the stock entry. On submit stock will update for quantity entered in this stock entry.
+
+When will you create another finish goods entry against this Production Order, system will only fetch pending quantity to be produced.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/manufacturing/articles/production-planning-subassembly.html b/erpnext/docs/user/manual/en/manufacturing/articles/production-planning-subassembly.html
new file mode 100644
index 0000000..5568750
--- /dev/null
+++ b/erpnext/docs/user/manual/en/manufacturing/articles/production-planning-subassembly.html
@@ -0,0 +1,8 @@
+<h1>Production Planning & Subassembly</h1>
+
+if you need Production Planning Tool to consider raw-materials required for the manufacturing of sub-assembly items selected in the BOM, please check following instructions to achieve the same.<br><br>Production Planning Tool has field called "Use Multi-Level BOM", checking which will consider raw-material of sub-assemblies as well in the material planning. If this field is not checked, then it will consider sub-assembly as an item, and won't consider raw-material required for the manufacturing of that sub-assembly.<br><br><img src="{{docs_base_path}}/assets/img/articles/$SGrab_203.png"><br><br>You will find same field in the Production Order and Stock Entry as well.<br><br>This feature is very useful for the companies who create BOM for the
+ sub-assemblies, but Production Order is created only for the finished 
+item. They do not create separate Production Order for the 
+sub-assemblies, but raw-materials as listed in the BOM of sub-assembly 
+items are consumed in the production process, and not sub-assembly item 
+directly.<br>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/manufacturing/articles/valuation-based-on-field-in-bom.html b/erpnext/docs/user/manual/en/manufacturing/articles/valuation-based-on-field-in-bom.html
new file mode 100644
index 0000000..4460ce0
--- /dev/null
+++ b/erpnext/docs/user/manual/en/manufacturing/articles/valuation-based-on-field-in-bom.html
@@ -0,0 +1,10 @@
+<h1>'Valuation Based On' Field in BOM</h1>
+
+<div><b>Question:</b> What do the various options in <i>Valuation Based On </i>Field in Bill Of Materials (BOM) Form mean? <br><br><b>Answer:</b> There are 3 available options in the <i>Valuation Based On</i> field;<br><br><img src="{{docs_base_path}}/assets/img/articles/kb_bom_field.png"><br><br><ul><li><b><i>Valuation Rate:</i></b> <br></li><ul><li>Item valuation rate is 
+defined based on it's purchase/manufacture value + other charges. <br></li><li>For 
+Purchase Item, it is defined based on charges entered in the Purchase 
+Receipt. If you don't have any Purchase Receipt
+ made for an item or a Stock Reconciliation, then you won't have 
+Valuation Rate for that item.</li></ul></ul><ul><li><b><i>Price List Rate:</i></b> <br></li><ul><li>Just like you pull item prices in sales and purchase transaction, it can be pulled in BOM via Price List Rate.</li></ul></ul></div><div><ul><li><i><b>Last Purchase Rate</b>:</i> <br></li><ul><li>It will be the last Purchase Rate value of an item. This 
+value is updated in the item master as well, based on rate in the 
+Purchase Order for this item.</li></ul></ul><p><br></p></div>
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/manufacturing/bill-of-materials.md b/erpnext/docs/user/manual/en/manufacturing/bill-of-materials.md
similarity index 75%
rename from erpnext/docs/user/guides/manufacturing/bill-of-materials.md
rename to erpnext/docs/user/manual/en/manufacturing/bill-of-materials.md
index 9ddf81a..34d8530 100644
--- a/erpnext/docs/user/guides/manufacturing/bill-of-materials.md
+++ b/erpnext/docs/user/manual/en/manufacturing/bill-of-materials.md
@@ -8,11 +8,11 @@
 
 > Manufacturing > Bill of Materials > New BOM
 
-<img class="screenshot" alt="Task" src="{{url_prefix}}/assets/img/manufacturing/bom.png">
+<img class="screenshot" alt="Task" src="{{docs_base_url}}/assets/img/manufacturing/bom.png">
 
 * To add Operations select 'With Operation'. The Operations table shall appear.
 
-<img class="screenshot" alt="Task" src="{{url_prefix}}/assets/img/manufacturing/bom-operations.png">
+<img class="screenshot" alt="Task" src="{{docs_base_url}}/assets/img/manufacturing/bom-operations.png">
 
   * Select the Item for which you want to make the BOM.
   * Add the operations that you have to go through to make that particular Item in the “Operations” table. For each operation, you will be asked to enter a Workstation. You must create new Workstations as and when necessary.
@@ -25,17 +25,17 @@
 
 * Add the list of Items you require for each operation, with its quantity. This Item could be a purchased Item or a sub-assembly with its own BOM. If the row Item is a manufactured Item and has multiple BOMs, select the appropriate BOM. You can also define if a part of the Item goes into scrap.
 
-<img class="screenshot" alt="Costing" src="{{url_prefix}}/assets/img/manufacturing/bom-costing.png">
+<img class="screenshot" alt="Costing" src="{{docs_base_url}}/assets/img/manufacturing/bom-costing.png">
 
 * This cost can be updated on by using the 'Update Cost' button.
 
-<img class="screenshot" alt="Update Cost" src="{{url_prefix}}/assets/img/manufacturing/bom-update-cost.png">
+<img class="screenshot" alt="Update Cost" src="{{docs_base_url}}/assets/img/manufacturing/bom-update-cost.png">
 
 ### Materials Required(exploded) 
 
 This table lists down all the Material required for the Item to be Manufactured.
 It also fetches sub-assemblies along with the quantity.
 
-<img class="screenshot" alt="Exploded Section" src="{{url_prefix}}/assets/img/manufacturing/bom-exploded.png">
+<img class="screenshot" alt="Exploded Section" src="{{docs_base_url}}/assets/img/manufacturing/bom-exploded.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/manufacturing/index.md b/erpnext/docs/user/manual/en/manufacturing/index.md
similarity index 100%
rename from erpnext/docs/user/guides/manufacturing/index.md
rename to erpnext/docs/user/manual/en/manufacturing/index.md
diff --git a/erpnext/docs/user/guides/manufacturing/index.txt b/erpnext/docs/user/manual/en/manufacturing/index.txt
similarity index 90%
rename from erpnext/docs/user/guides/manufacturing/index.txt
rename to erpnext/docs/user/manual/en/manufacturing/index.txt
index 1fe03a6..3b932a5 100644
--- a/erpnext/docs/user/guides/manufacturing/index.txt
+++ b/erpnext/docs/user/manual/en/manufacturing/index.txt
@@ -5,4 +5,5 @@
 operation
 subcontracting
 tools
-setup
\ No newline at end of file
+setup
+articles
diff --git a/erpnext/docs/user/guides/manufacturing/introduction.md b/erpnext/docs/user/manual/en/manufacturing/introduction.md
similarity index 92%
rename from erpnext/docs/user/guides/manufacturing/introduction.md
rename to erpnext/docs/user/manual/en/manufacturing/introduction.md
index 2d60e67..f9d827c 100644
--- a/erpnext/docs/user/guides/manufacturing/introduction.md
+++ b/erpnext/docs/user/manual/en/manufacturing/introduction.md
@@ -1,4 +1,4 @@
-<img class="screenshot" alt="Task" src="{{url_prefix}}/assets/img/manufacturing/manufacturing.png">
+<img class="screenshot" alt="Task" src="{{docs_base_url}}/assets/img/manufacturing/manufacturing.png">
 
 ### Types of Production Planning
 
diff --git a/erpnext/docs/user/guides/manufacturing/operation.md b/erpnext/docs/user/manual/en/manufacturing/operation.md
similarity index 67%
rename from erpnext/docs/user/guides/manufacturing/operation.md
rename to erpnext/docs/user/manual/en/manufacturing/operation.md
index 6c77089..b21304e 100644
--- a/erpnext/docs/user/guides/manufacturing/operation.md
+++ b/erpnext/docs/user/manual/en/manufacturing/operation.md
@@ -6,6 +6,6 @@
 
 > Manufacturing > Documents > Operation > New
 
-<img class="screenshot" alt="Operation" src="{{url_prefix}}/assets/img/manufacturing/operation.png">
+<img class="screenshot" alt="Operation" src="{{docs_base_url}}/assets/img/manufacturing/operation.png">
 
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/manufacturing/production-order.md b/erpnext/docs/user/manual/en/manufacturing/production-order.md
similarity index 79%
rename from erpnext/docs/user/guides/manufacturing/production-order.md
rename to erpnext/docs/user/manual/en/manufacturing/production-order.md
index c9729be..6438d81 100644
--- a/erpnext/docs/user/guides/manufacturing/production-order.md
+++ b/erpnext/docs/user/manual/en/manufacturing/production-order.md
@@ -10,7 +10,7 @@
 
 > Manufacturing > Documents > Production Order > New
 
-<img class="screenshot" alt="Production Order" src="{{url_prefix}}/assets/img/manufacturing/production-order.png">
+<img class="screenshot" alt="Production Order" src="{{docs_base_url}}/assets/img/manufacturing/production-order.png">
 
 ### Creating Production Orders
 
@@ -26,11 +26,11 @@
 
 * By default the system fetchs workstation and duration for Production Order Operations from the selected BOM.
 
-<img class="screenshot" alt="PO Opeartions" src="{{url_prefix}}/assets/img/manufacturing/PO-operations.png">
+<img class="screenshot" alt="PO Opeartions" src="{{docs_base_url}}/assets/img/manufacturing/PO-operations.png">
 
 * If you wish to reassign the wrokstation for a particular opeeration in the Production Order, you can do so before submitting the Production Order.
 
-<img class="screenshot" alt="PO reassigning Operations" src="{{url_prefix}}/assets/img/manufacturing/PO-reassigning-operations.png">
+<img class="screenshot" alt="PO reassigning Operations" src="{{docs_base_url}}/assets/img/manufacturing/PO-reassigning-operations.png">
 
 * Select the respective operation, and change its workstation.
 * You can also change the Operating Time for that operation
@@ -47,28 +47,28 @@
 
 * Click on 'Transfer Materials for Manufacturing'.
 
-<img class="screenshot" alt="Transfer Materials" src="{{url_prefix}}/assets/img/manufacturing/PO-material-transfer.png">
+<img class="screenshot" alt="Transfer Materials" src="{{docs_base_url}}/assets/img/manufacturing/PO-material-transfer.png">
 
 * Mention the quantity of materials to be transfered.
 
-<img class="screenshot" alt="Material Transfer Qty" src="{{url_prefix}}/assets/img/manufacturing/PO-material-transfer-qty.png">
+<img class="screenshot" alt="Material Transfer Qty" src="{{docs_base_url}}/assets/img/manufacturing/PO-material-transfer-qty.png">
 
 * Submit the Stock Entry
 
-<img class="screenshot" alt="Stock Entry for PO" src="{{url_prefix}}/assets/img/manufacturing/PO-SE-for-material-transfer.png">
+<img class="screenshot" alt="Stock Entry for PO" src="{{docs_base_url}}/assets/img/manufacturing/PO-SE-for-material-transfer.png">
 
 * Material Transfered for Manufacturing will be updated in the Production Order based on the Stock Entry.
 
-<img class="screenshot" alt="Stock Entry for PO" src="{{url_prefix}}/assets/img/manufacturing/PO-material-transfer-updated.png">
+<img class="screenshot" alt="Stock Entry for PO" src="{{docs_base_url}}/assets/img/manufacturing/PO-material-transfer-updated.png">
 
 ### Making Time Logs
 
-* Progress in the Production Order can be tracked using [Time Log]({{url_prefix}}/user/guides/projects/time-log.html)
+* Progress in the Production Order can be tracked using [Time Log]({{docs_base_url}}/user/guides/projects/time-log.html)
 * Time Logs are created against Production Order Operations.
 * Drafts of Time Logs are also created based on the scheduled operations when an Production Order is Submitted.
 * To create more Time Logs against an operation select 'Make TIme Log' in the respective operation.
 
-<img class="screenshot" alt="Make TL against PO" src="{{url_prefix}}/assets/img/manufacturing/PO-operations-make-tl.png">
+<img class="screenshot" alt="Make TL against PO" src="{{docs_base_url}}/assets/img/manufacturing/PO-operations-make-tl.png">
 
 ###Updating Finished Goods
 
@@ -76,11 +76,11 @@
 * This will create a Stock Entry that will deduct all the sub-Items from the WIP Warehouse and add them to the Finished Goods Warehouse.
 * Click on 'Update Finished Goods'.
 
-<img class="screenshot" alt="Update Finished Goods" src="{{url_prefix}}/assets/img/manufacturing/PO-FG-update.png">
+<img class="screenshot" alt="Update Finished Goods" src="{{docs_base_url}}/assets/img/manufacturing/PO-FG-update.png">
 
 * Mention the quantity of materials to be transfered.
 
-<img class="screenshot" alt="Update Finished Goods Qty" src="{{url_prefix}}/assets/img/manufacturing/PO-FG-update-qty.png">
+<img class="screenshot" alt="Update Finished Goods Qty" src="{{docs_base_url}}/assets/img/manufacturing/PO-FG-update-qty.png">
 
  > Tip : You can also partially complete a Production Order by updating the Finished Goods stock creating a Stock Entry.
  
@@ -95,7 +95,7 @@
   4. Update Finished Goods: This will create a Stock Entry that will deduct all the sub-Items from the WIP Warehouse and add them to the Finished Goods Warehouse.
   5. To check all Time Logs made against the Production Order click on 'Show Time Logs'
 
-<img class="screenshot" alt="PO - stop" src="{{url_prefix}}/assets/img/manufacturing/PO-stop.png">
+<img class="screenshot" alt="PO - stop" src="{{docs_base_url}}/assets/img/manufacturing/PO-stop.png">
 
 * You can Also re-start a stopped Production Order.
 
diff --git a/erpnext/docs/user/guides/manufacturing/setup/index.md b/erpnext/docs/user/manual/en/manufacturing/setup/index.md
similarity index 100%
rename from erpnext/docs/user/guides/manufacturing/setup/index.md
rename to erpnext/docs/user/manual/en/manufacturing/setup/index.md
diff --git a/erpnext/docs/user/guides/manufacturing/setup/index.txt b/erpnext/docs/user/manual/en/manufacturing/setup/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/manufacturing/setup/index.txt
rename to erpnext/docs/user/manual/en/manufacturing/setup/index.txt
diff --git a/erpnext/docs/user/guides/manufacturing/setup/manufacturing-settings.md b/erpnext/docs/user/manual/en/manufacturing/setup/manufacturing-settings.md
similarity index 79%
rename from erpnext/docs/user/guides/manufacturing/setup/manufacturing-settings.md
rename to erpnext/docs/user/manual/en/manufacturing/setup/manufacturing-settings.md
index eb0a08c..dc59689 100644
--- a/erpnext/docs/user/guides/manufacturing/setup/manufacturing-settings.md
+++ b/erpnext/docs/user/manual/en/manufacturing/setup/manufacturing-settings.md
@@ -2,7 +2,7 @@
 
 > Manufacturing > Production Order > Setup > Manufacturing Settings
 
-<img class="screenshot" alt="Manufacturing Settings" src="{{url_prefix}}/assets/img/manufacturing/manufacturing-settings.png">
+<img class="screenshot" alt="Manufacturing Settings" src="{{docs_base_url}}/assets/img/manufacturing/manufacturing-settings.png">
 
 * Allow Overtime - Specify if workstations are to allow overtime.(schedule operations outside working hours)
 
diff --git a/erpnext/docs/user/guides/manufacturing/subcontracting.md b/erpnext/docs/user/manual/en/manufacturing/subcontracting.md
similarity index 96%
rename from erpnext/docs/user/guides/manufacturing/subcontracting.md
rename to erpnext/docs/user/manual/en/manufacturing/subcontracting.md
index 832e8a2..6f2b86b 100644
--- a/erpnext/docs/user/guides/manufacturing/subcontracting.md
+++ b/erpnext/docs/user/manual/en/manufacturing/subcontracting.md
@@ -15,7 +15,7 @@
   2. Create a Warehouse for your Supplier so that you can keep track of Items supplied. (you may supply a months worth of Items in one go).
   3. For the processed Item, in the Item master, set “Is Sub Contracted Item” to “Yes”.
 
-![Subcontract]({{url_prefix}}/assets/old_images/erpnext/subcontract.png)
+![Subcontract]({{docs_base_url}}/assets/old_images/erpnext/subcontract.png)
 
   
 
diff --git a/erpnext/docs/user/guides/manufacturing/tools/bom-replace-tool.md b/erpnext/docs/user/manual/en/manufacturing/tools/bom-replace-tool.md
similarity index 91%
rename from erpnext/docs/user/guides/manufacturing/tools/bom-replace-tool.md
rename to erpnext/docs/user/manual/en/manufacturing/tools/bom-replace-tool.md
index 8722d26..794d982 100644
--- a/erpnext/docs/user/guides/manufacturing/tools/bom-replace-tool.md
+++ b/erpnext/docs/user/manual/en/manufacturing/tools/bom-replace-tool.md
@@ -33,7 +33,7 @@
 
 To update new BOM updated in the BOM of finished item, where CPU is selected as raw-material, you can use BOM Replace tool.
 
-<img class="screenshot" alt="BOM replace Tool" src="{{url_prefix}}/assets/img/manufacturing/bom-replace-tool.png">
+<img class="screenshot" alt="BOM replace Tool" src="{{docs_base_url}}/assets/img/manufacturing/bom-replace-tool.png">
 
 In this tool, you should select Current BOM, and New BOM. On clicking Replace button, current BOM of CPU will be replaced with New BOM in the BOM of finished Item (Computer).
 
diff --git a/erpnext/docs/user/guides/manufacturing/tools/index.md b/erpnext/docs/user/manual/en/manufacturing/tools/index.md
similarity index 100%
rename from erpnext/docs/user/guides/manufacturing/tools/index.md
rename to erpnext/docs/user/manual/en/manufacturing/tools/index.md
diff --git a/erpnext/docs/user/guides/manufacturing/tools/index.txt b/erpnext/docs/user/manual/en/manufacturing/tools/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/manufacturing/tools/index.txt
rename to erpnext/docs/user/manual/en/manufacturing/tools/index.txt
diff --git a/erpnext/docs/user/guides/manufacturing/tools/production-planning-tool.md b/erpnext/docs/user/manual/en/manufacturing/tools/production-planning-tool.md
similarity index 69%
rename from erpnext/docs/user/guides/manufacturing/tools/production-planning-tool.md
rename to erpnext/docs/user/manual/en/manufacturing/tools/production-planning-tool.md
index b966e7a..61ec4c7 100644
--- a/erpnext/docs/user/guides/manufacturing/tools/production-planning-tool.md
+++ b/erpnext/docs/user/manual/en/manufacturing/tools/production-planning-tool.md
@@ -11,7 +11,7 @@
 
 > Manufacturing > Tools > Production Planning Tool
 
-<img class="screenshot" alt="Production Planing Tool" src="{{url_prefix}}/assets/img/manufacturing/ppt.png">
+<img class="screenshot" alt="Production Planing Tool" src="{{docs_base_url}}/assets/img/manufacturing/ppt.png">
 
 
 
@@ -20,7 +20,7 @@
 * Select sales orders for MRP using filters (Time, Item, and Customer)
 * Click on Get Sales Order to generate a list.
 
-<img class="screenshot" alt="Production Planing Tool" src="{{url_prefix}}/assets/img/manufacturing/ppt-get-sales-orders.png">
+<img class="screenshot" alt="Production Planing Tool" src="{{docs_base_url}}/assets/img/manufacturing/ppt-get-sales-orders.png">
 
 
 
@@ -28,11 +28,11 @@
 
 You can add/remove or change quantity of these Items.
 
-<img class="screenshot" alt="Production Planing Tool" src="{{url_prefix}}/assets/img/manufacturing/ppt-get-item.png">
+<img class="screenshot" alt="Production Planing Tool" src="{{docs_base_url}}/assets/img/manufacturing/ppt-get-item.png">
 
 #### Step 3: Create Production Orders
 
-<img class="screenshot" alt="Production Planing Tool" src="{{url_prefix}}/assets/img/manufacturing/ppt-create-production-order.png">
+<img class="screenshot" alt="Production Planing Tool" src="{{docs_base_url}}/assets/img/manufacturing/ppt-create-production-order.png">
 
 
 
@@ -40,7 +40,7 @@
 
 Create Material Request for Items with projected shortfall.
 
-<img class="screenshot" alt="Production Planing Tool" src="{{url_prefix}}/assets/img/manufacturing/ppt-create-material-request.png">
+<img class="screenshot" alt="Production Planing Tool" src="{{docs_base_url}}/assets/img/manufacturing/ppt-create-material-request.png">
 
 
 
diff --git a/erpnext/docs/user/guides/manufacturing/workstation.md b/erpnext/docs/user/manual/en/manufacturing/workstation.md
similarity index 77%
rename from erpnext/docs/user/guides/manufacturing/workstation.md
rename to erpnext/docs/user/manual/en/manufacturing/workstation.md
index abc8933..4e27eb5 100644
--- a/erpnext/docs/user/guides/manufacturing/workstation.md
+++ b/erpnext/docs/user/manual/en/manufacturing/workstation.md
@@ -8,12 +8,12 @@
 
 > Manufacturing > Documents > Workstation > New
 
-<img class="screenshot" alt="Workstation" src="{{url_prefix}}/assets/img/manufacturing/workstation.png">
+<img class="screenshot" alt="Workstation" src="{{docs_base_url}}/assets/img/manufacturing/workstation.png">
 
 In workstation specify the workstation working hours under the 'working hour' section. 
 You can also specify the working hours based on shifts.
 While scheduling Production Order, system will check for the availability of the workstation based on the working hours specified.	
 
-> Note : You can enable overtime for your workstation in [Manufacturing Settings]({{url_prefix}}/user/guides/manufacturing/setup/manufacturing-settings.html)
+> Note : You can enable overtime for your workstation in [Manufacturing Settings]({{docs_base_url}}/user/guides/manufacturing/setup/manufacturing-settings.html)
 
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/projects/activity-cost.md b/erpnext/docs/user/manual/en/projects/activity-cost.md
similarity index 65%
rename from erpnext/docs/user/guides/projects/activity-cost.md
rename to erpnext/docs/user/manual/en/projects/activity-cost.md
index 3ad95fc..d4e2106 100644
--- a/erpnext/docs/user/guides/projects/activity-cost.md
+++ b/erpnext/docs/user/manual/en/projects/activity-cost.md
@@ -1,4 +1,4 @@
 Activity Cost records the per-hour billing rate and costing rate of an Employee against an Activity Type.
 This rate is pulled by the system while making Time Logs. It is used for Project Costing.
 
-<img class="screenshot" alt="Activity Cost" src="{{url_prefix}}/assets/img/project/activity_cost.png">
+<img class="screenshot" alt="Activity Cost" src="{{docs_base_url}}/assets/img/project/activity_cost.png">
diff --git a/erpnext/docs/user/guides/projects/activity-type.md b/erpnext/docs/user/manual/en/projects/activity-type.md
similarity index 68%
rename from erpnext/docs/user/guides/projects/activity-type.md
rename to erpnext/docs/user/manual/en/projects/activity-type.md
index a598853..7f37f51 100644
--- a/erpnext/docs/user/guides/projects/activity-type.md
+++ b/erpnext/docs/user/manual/en/projects/activity-type.md
@@ -1,6 +1,6 @@
 Activity Type makes a list of the different types of activities against which a Time Log can be made.
 
-<img class="screenshot" alt="Activity Type" src="{{url_prefix}}/assets/img/project/activity_type.png">
+<img class="screenshot" alt="Activity Type" src="{{docs_base_url}}/assets/img/project/activity_type.png">
 
 By default the following Activity Types are created.
 
diff --git a/erpnext/docs/user/manual/en/projects/articles/index.md b/erpnext/docs/user/manual/en/projects/articles/index.md
new file mode 100644
index 0000000..4e1be28
--- /dev/null
+++ b/erpnext/docs/user/manual/en/projects/articles/index.md
@@ -0,0 +1 @@
+{content}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/projects/articles/index.txt b/erpnext/docs/user/manual/en/projects/articles/index.txt
new file mode 100644
index 0000000..56c193c
--- /dev/null
+++ b/erpnext/docs/user/manual/en/projects/articles/index.txt
@@ -0,0 +1 @@
+project-costing
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/projects/articles/project-costing.md b/erpnext/docs/user/manual/en/projects/articles/project-costing.md
new file mode 100644
index 0000000..e5c5940
--- /dev/null
+++ b/erpnext/docs/user/manual/en/projects/articles/project-costing.md
@@ -0,0 +1,39 @@
+<h1>Project Costing</h1>
+
+Each project has multiple task associated with it. To track actual costing of a Project, primarily in terms of services, user has to create Time Log based on actual time spent on Project-Task. Following the steps on how you can track actual service cost against Project.
+
+#### Activity Type
+
+Activity Type is a master of service offered by your personnel. You can add new Activity type from:
+
+`Project > Activity Type > New`	
+
+#### Activity Cost
+
+Activity Cost is a master where you can track billing and costing rate for each Employee, and for each Activity Type.
+
+![Activity Cost]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-06-11 at 4.57.01 pm.png)
+
+#### Time Log
+
+Based on Actual Time spent on the Project-Task, Employee will create a time log.
+
+![Time Log]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-06-11 at 4.59.49 pm.png)
+
+On selection of Activity Type in the Time Log, Billing and Costing Rate will fetched for that Employee from respective Activity Cost master. 
+
+![Time Log Costing]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-06-11 at 5.00.06 pm.png)
+
+Multiplying these rates with total no. of Hours in the Time Log gives Costing Amount and Billing Amount for the specific Time Log.
+
+#### Costing in Project and Task
+
+Based on total Time Logs created for a specific Task, its costing will be updated in the respective Task master. 
+
+![Costing in Task]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-06-11 at 5.02.54 pm.png)
+
+Same way, Project master will have cost updated based on Time Log created against that Projects, and tasks associated with that Project.
+
+![Costing in Project]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-06-11 at 5.02.29 pm.png)
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/projects/index.md b/erpnext/docs/user/manual/en/projects/index.md
similarity index 100%
rename from erpnext/docs/user/guides/projects/index.md
rename to erpnext/docs/user/manual/en/projects/index.md
diff --git a/erpnext/docs/user/guides/projects/index.txt b/erpnext/docs/user/manual/en/projects/index.txt
similarity index 86%
rename from erpnext/docs/user/guides/projects/index.txt
rename to erpnext/docs/user/manual/en/projects/index.txt
index e5ef847..f2bae77 100644
--- a/erpnext/docs/user/guides/projects/index.txt
+++ b/erpnext/docs/user/manual/en/projects/index.txt
@@ -3,4 +3,5 @@
 time-log
 time-log-batch
 activity-type
-activity-cost
\ No newline at end of file
+activity-cost
+articles
diff --git a/erpnext/docs/user/manual/en/projects/project.md b/erpnext/docs/user/manual/en/projects/project.md
new file mode 100644
index 0000000..e4558e1
--- /dev/null
+++ b/erpnext/docs/user/manual/en/projects/project.md
@@ -0,0 +1,87 @@
+Project management in ERPNext is Task driven. You can create Project and assign multiple Tasks against it.
+
+<img class="screenshot" alt="Project" src="{{docs_base_url}}/assets/img/project/project.png">
+
+### Managing tasks
+Project can be divided into multiple Tasks.
+Task can be created via Project document itself or can be created via  [Task]({{docs_base_url}}/user/guides/projects/tasks.html)
+
+<img class="screenshot" alt="Project" src="{{docs_base_url}}/assets/img/project/project_task.png">
+
+* To view Task made against a Project click on 'Tasks'
+
+<img class="screenshot" alt="Project - View Task" src="{{docs_base_url}}/assets/img/project/project_view_task.png">
+
+<img class="screenshot" alt="Project - Task List" src="{{docs_base_url}}/assets/img/project/project_task_list.png">
+
+* You can also view the Tasks from the Project document itself
+
+<img class="screenshot" alt="Project - Task Grid" src="{{docs_base_url}}/assets/img/project/project_task_grid.png">
+
+### Managing time
+
+ERPNext uses [Time Log]({{docs_base_url}}/user/guides/projects/time-log.html) to track the progress of a Project.
+You can create Time Logs against each task.
+The Actual Start and End Time along with the costing shall then be updated based on the Time Log.
+
+* To view Time Log made against a Project click on 'Time Logs'
+
+<img class="screenshot" alt="Project - View Time Log" src="{{docs_base_url}}/assets/img/project/project_view_time_log.png">
+
+<img class="screenshot" alt="Project - Time Log List" src="{{docs_base_url}}/assets/img/project/project_time_log_list.png">
+
+* You can also create a Time Log directlly and link it to the Project.
+
+<img class="screenshot" alt="Project - Link Time Log" src="{{docs_base_url}}/assets/img/project/project_time_log_link.png">
+
+### Managing expenses
+
+You can book [Expense Claim]({{docs_base_url}}/user/guides/human-resources/expense-claim.html) against a project task.
+The system shall update the total amount from expense claims in the project costing section.
+
+* To view Expense Claims made against a Project click on 'Expense Claims'
+
+<img class="screenshot" alt="Project - View Expense Claim" src="{{docs_base_url}}/assets/img/project/project_view_expense_claim.png">
+
+* You can also create a Expense Claims directlly and link it to the Project.
+
+<img class="screenshot" alt="Project - Link Expense Claim" src="{{docs_base_url}}/assets/img/project/project_expense_claim_link.png">
+
+* Total amount of Expense Claims booked against a project is shown under 'Total Expense Claim' in the Project Costing Section
+
+<img class="screenshot" alt="Project - Total Expense Claim" src="{{docs_base_url}}/assets/img/project/project_total_expense_claim.png">
+
+### Cost Center
+
+You can make a [Cost Center]({{docs_base_url}}/user/guides/accounts/setup/cost-center.html) against a Project or use an existing cost center to track all expenses made against that project.
+
+<img class="screenshot" alt="Project - Cost Center" src="{{docs_base_url}}/assets/img/project/project_cost_center.png">
+
+###Project Costing
+
+The Project Costing section helps you track the time and expenses incurred against the project.
+
+<img class="screenshot" alt="Project - Costing" src="{{docs_base_url}}/assets/img/project/project_costing.png">
+
+* The Costing Section is updated based on Time Logs made.
+
+* Gross Margin is the difference between Total Costing Amount and Total Billing Amount
+
+###Billing
+
+You can make/link a [Sales Order]({{docs_base_url}}/user/guides/selling/sales-order.html) against a project. Once linked you can use the standard sales module to bill your customer against the Project.
+
+<img class="screenshot" alt="Project - Sales Order" src="{{docs_base_url}}/assets/img/project/project_sales_order.png">
+
+###Gantt Chart
+
+A Gantt Chart illustrates a project schedule.
+ERPNext gives you a illustrated view of tasks scheduled against that project in Gantt Chart View.
+
+* To view gantt chart against a project, go to that project and click on 'Gantt Chart'
+
+<img class="screenshot" alt="Project - View Gantt Chart" src="{{docs_base_url}}/assets/img/project/project_view_gantt_chart.png">
+
+<img class="screenshot" alt="Project - Gantt Chart" src="{{docs_base_url}}/assets/img/project/project_gantt_chart.png">
+
+{next}
diff --git a/erpnext/docs/user/manual/en/projects/tasks.md b/erpnext/docs/user/manual/en/projects/tasks.md
new file mode 100644
index 0000000..bf1e9af
--- /dev/null
+++ b/erpnext/docs/user/manual/en/projects/tasks.md
@@ -0,0 +1,59 @@
+Project is divided into Tasks. 
+In ERPNext, you can also create a Task independently.
+
+<img class="screenshot" alt="Task" src="{{docs_base_url}}/assets/img/project/task.png">
+
+### Status of the Task
+
+A Task can have either of the following status - Open, Working, Pending Review, Closed, Cancelled.
+
+<img class="screenshot" alt="Task - Status" src="{{docs_base_url}}/assets/img/project/task_status.png">
+
+* By default each new Task created shall have the status set to 'Open'.
+
+* If a Time Log is made against a task, its status shall be set to 'Working'.
+
+### Dependent Task
+
+You can specify a list of dependent task under the 'Depends On' section.
+
+<img class="screenshot" alt="Depends On" src="{{docs_base_url}}/assets/img/project/task_depends_on.png">
+
+* You cannot close the parent Task until all 'Dependant Task' are closed.
+
+* If the Dependent Task are delayed and overlap with the expected Start Date of the Parent task, the system will reschedule the parent task.
+
+### Managing Time
+
+ERPNext uses [Time Log]({{docs_base_url}}/user/guides/projects/time-log.html) to track the progress of a Task.
+You can create multiple Time Logs against each task.
+The Actual Start and End Time along with the costing shall then be updated based on the Time Log.
+
+* To view Time Log made against a Task click on 'Time Logs'
+
+<img class="screenshot" alt="Task - View Time Log" src="{{docs_base_url}}/assets/img/project/task_view_time_log.png">
+
+<img class="screenshot" alt="Task - Time Log List" src="{{docs_base_url}}/assets/img/project/task_time_log_list.png">
+
+* You can also create a Time Log directlly and link it to the Task.
+
+<img class="screenshot" alt="Task - Link Time Log" src="{{docs_base_url}}/assets/img/project/task_time_log_link.png">
+
+### Managing Expenses
+
+You can book [Expense Claim]({{docs_base_url}}/user/guides/human-resource-management/expense-claim.html) against a task.
+The system shall update the total amount from expense claims in the costing section.
+
+* To view Expense Claims made against a Task click on 'Expense Claims'
+
+<img class="screenshot" alt="Task - View Expense Claim" src="{{docs_base_url}}/assets/img/project/task_view_expense_claim.png">
+
+* You can also create a Expense Claims directlly and link it to the Task.
+
+<img class="screenshot" alt="Task - Link Expense Claim" src="{{docs_base_url}}/assets/img/project/task_expense_claim_link.png">
+
+* Total amount of Expense Claims booked against a task is shown under 'Total Expense Claim' in the Task Costing Section
+
+<img class="screenshot" alt="Task - Total Expense Claim" src="{{docs_base_url}}/assets/img/project/task_total_expense_claim.png">
+
+{next}
diff --git a/erpnext/docs/user/guides/projects/time-log-batch.md b/erpnext/docs/user/manual/en/projects/time-log-batch.md
similarity index 66%
rename from erpnext/docs/user/guides/projects/time-log-batch.md
rename to erpnext/docs/user/manual/en/projects/time-log-batch.md
index e16383b..d48633a 100644
--- a/erpnext/docs/user/guides/projects/time-log-batch.md
+++ b/erpnext/docs/user/manual/en/projects/time-log-batch.md
@@ -6,17 +6,17 @@
 
 Just open your Time Log list and check the Items to you want to add to the Time Log. Then click on "Make Time Log Batch" button and these Time Logs will be selected.
 
-<img class="screenshot" alt="Time Log - Drag Calender" src="{{url_prefix}}/assets/img/project/time_log_batch.gif">
+<img class="screenshot" alt="Time Log - Drag Calender" src="{{docs_base_url}}/assets/img/project/time_log_batch.gif">
 
 ###Making Sales Invoice
 
 * After submitting the Time Log Batch, "Make Invoice" button shall appear.
 
-<img class="screenshot" alt="Time Log - Drag Calender" src="{{url_prefix}}/assets/img/project/time_log_batch_make_invoice.png">
+<img class="screenshot" alt="Time Log - Drag Calender" src="{{docs_base_url}}/assets/img/project/time_log_batch_make_invoice.png">
 
 * Click on that button to raise a Sales Invoice against the Time Log Batch.
 
-<img class="screenshot" alt="Time Log - Drag Calender" src="{{url_prefix}}/assets/img/project/time_log_batch_sales_invoice.png">
+<img class="screenshot" alt="Time Log - Drag Calender" src="{{docs_base_url}}/assets/img/project/time_log_batch_sales_invoice.png">
 
 * When you "Submit" the Sales Invoice, the Sales Invoice number will get updated in the Time Logs and Time Log Batch and their status will change to "Billed".
 
diff --git a/erpnext/docs/user/guides/projects/time-log.md b/erpnext/docs/user/manual/en/projects/time-log.md
similarity index 62%
rename from erpnext/docs/user/guides/projects/time-log.md
rename to erpnext/docs/user/manual/en/projects/time-log.md
index c180208..1739240 100644
--- a/erpnext/docs/user/guides/projects/time-log.md
+++ b/erpnext/docs/user/manual/en/projects/time-log.md
@@ -7,7 +7,7 @@
 * Project
 * Internal References
 
-<img class="screenshot" alt="Time Log" src="{{url_prefix}}/assets/img/project/time_log.png">
+<img class="screenshot" alt="Time Log" src="{{docs_base_url}}/assets/img/project/time_log.png">
 
 ###Creating Time Logs
 
@@ -18,15 +18,15 @@
 
 To create Time Logs via Calender, go to Time Log and select Calendar.
 
-<img class="screenshot" alt="Time Log - View Calender" src="{{url_prefix}}/assets/img/project/time_log_view_calendar.png">
+<img class="screenshot" alt="Time Log - View Calender" src="{{docs_base_url}}/assets/img/project/time_log_view_calendar.png">
 
 * To create a Time Log for multiple days, click and drag the cursor across days.
 
-<img class="screenshot" alt="Time Log - Drag Calender" src="{{url_prefix}}/assets/img/project/time_log_calendar_day.gif">
+<img class="screenshot" alt="Time Log - Drag Calender" src="{{docs_base_url}}/assets/img/project/time_log_calendar_day.gif">
 
 * You can also create Time Logs from 'week' and 'day' view of the calender.
 
-<img class="screenshot" alt="Time Log - Drag Calender" src="{{url_prefix}}/assets/img/project/time_log_calendar_week.gif">
+<img class="screenshot" alt="Time Log - Drag Calender" src="{{docs_base_url}}/assets/img/project/time_log_calendar_week.gif">
 
 * Time Logs for Manufacturing processes needs to be created from the Production Order. 
 * To create more Time Logs against Operations select the respective operation and click on the 'Make Time Log' button.
@@ -35,15 +35,15 @@
 
 * If you wish to bill against a Time Log you need to select the 'Billable' option.
 
-* In the costing section, the system will pull up the Costing & Billing rate from [Activity Cost]({{url_prefix}}/user/guides/projects/activity-cost.html) 
+* In the costing section, the system will pull up the Costing & Billing rate from [Activity Cost]({{docs_base_url}}/user/guides/projects/activity-cost.html) 
 	based on the Employee and Activity Type specified.
 
 * The system shall then calculate the Costing and Billing amount based on the Hours mentioned in the Time Log.
 
 * If 'Billable' is not selected, the system shall display the 'Billing Amount' as 0.
 
-<img class="screenshot" alt="Time Log - Costing" src="{{url_prefix}}/assets/img/project/time_log_costing.png">
+<img class="screenshot" alt="Time Log - Costing" src="{{docs_base_url}}/assets/img/project/time_log_costing.png">
 
-* After submitting the Time Log, you need to create [Time Log batch]({{url_prefix}}/user/guides/projects/time-log-batch.html) to further bill the Time Log.
+* After submitting the Time Log, you need to create [Time Log batch]({{docs_base_url}}/user/guides/projects/time-log-batch.html) to further bill the Time Log.
 
 {next}
diff --git a/erpnext/docs/user/manual/en/selling/articles/applying-discount.md b/erpnext/docs/user/manual/en/selling/articles/applying-discount.md
new file mode 100644
index 0000000..9dfc730
--- /dev/null
+++ b/erpnext/docs/user/manual/en/selling/articles/applying-discount.md
@@ -0,0 +1,31 @@
+<h1>Applying Discount</h1>
+
+There are two ways Discount can be applied on an items in the sales transactions.
+
+#### 1. Discount on "Price List Rate" of an item
+
+In the Item table of transaction, after Price List Rate field, you will find Discount (%) field. Discount Rate applied in this field will be applicable on the Price List Rate of an item.
+
+Before applying Discount (%). 
+
+![Before discount]({{docs_base_url}}/assets/img/articles/Selection_00616c670.png)
+
+After applying Discount (%) under Discount on Price List Rate (%) field.
+
+![After discount]({{docs_base_url}}/assets/img/articles/Selection_007f81dc2.png)
+     
+You can apply percent discount in all sales and purchase transactions.
+
+#### 2. Discount on Grand Total
+
+In transactions, after Taxes and Charges table, you will find option to enter "Additional Discount Amount". Based on Amount entered in this field, item's Basic Rate and Taxes will be recalculated.
+
+Before applying Additional Discount Amount,
+
+![Discount]({{docs_base_url}}/assets/img/articles/Selection_0085ca13e.png)
+
+After applying Additional Discount Amount.
+
+![Discount Amount]({{docs_base_url}}/assets/img/articles/Selection_010496ae2.png)
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/selling/drop-shipping.md b/erpnext/docs/user/manual/en/selling/articles/drop-shipping.md
similarity index 76%
rename from erpnext/docs/user/guides/selling/drop-shipping.md
rename to erpnext/docs/user/manual/en/selling/articles/drop-shipping.md
index e05fb1b..8c3af05 100644
--- a/erpnext/docs/user/guides/selling/drop-shipping.md
+++ b/erpnext/docs/user/manual/en/selling/articles/drop-shipping.md
@@ -7,28 +7,28 @@
 #### Setup on Item Master
 
 Set **_Delivered by Supplier (Drop Ship)_** and **_Default Supplier_** in Item Master.
-<img class="screenshot" alt="Setup Item Master" src="{{url_prefix}}/assets/img/selling/setup-drop-ship-on-item-master.png">
+<img class="screenshot" alt="Setup Item Master" src="{{docs_base_url}}/assets/img/selling/setup-drop-ship-on-item-master.png">
 
 #### Setup on Sales Order
 If Drop Shipping has set on Item master, it will automatically set **Supplier delivers to Customer** and **Supplier** on Salse Order Item.
 
 You can setup Drop Shipping, on Sales Order Item. Under **Drop Ship** section, set **Supplier delivers to Customer** and select **Supplier** agaist which Purchase Order will get created.
-<img class="screenshot" alt="Setup Drop Shipping on Sales Order Item" src="{{url_prefix}}/assets/img/selling/setup-drop-ship-on-sales-order-item.png">
+<img class="screenshot" alt="Setup Drop Shipping on Sales Order Item" src="{{docs_base_url}}/assets/img/selling/setup-drop-ship-on-sales-order-item.png">
 
 #### Create Purchase Order
 After submitting a Sales Order, create Puchase Order.<br> 
-<img class="screenshot" alt="Setup Drop Shipping on Sales Order Item" src="{{url_prefix}}/assets/img/selling/drop-ship-sales-order.png">
+<img class="screenshot" alt="Setup Drop Shipping on Sales Order Item" src="{{docs_base_url}}/assets/img/selling/drop-ship-sales-order.png">
 
 From Sales Order, all items, having **Supplier delivers to Customer**  checked or **Supplier**(matching with supplier selected on For Supplier popup) mentioned, will get mapped onto Purchase Order. 
 
 It will automatically set Customer, Customer Address and Contact Person.
 
 After submitting Purchase Order, to update delivery status, use **Mark as Delivered** button on Purchase Order. It will update delivery percetage and delivered quantity on Sales Order.
-<img class="screenshot" alt="Purchase Order for Drop Shipping" src="{{url_prefix}}/assets/img/selling/drop-ship-purchase-order.png">
+<img class="screenshot" alt="Purchase Order for Drop Shipping" src="{{docs_base_url}}/assets/img/selling/drop-ship-purchase-order.png">
 
 <span style="color:#18B52D">**_Close_**</span>, is a new feature introduced on **Purchase Order** and **Sales Order**, to close or to mark fulfillment.
-<img class="screenshot" alt="Close Sales Order" src="{{url_prefix}}/assets/img/selling/close-sales-order.png">
+<img class="screenshot" alt="Close Sales Order" src="{{docs_base_url}}/assets/img/selling/close-sales-order.png">
 
 ###Drop Shipping Print Format
 You can notify, Suppliers by sending a email after submitting Purchase Order by attaching Drop Shipping print format.
-<img class="screenshot" alt="Drop Dhip Print Format" src="{{url_prefix}}/assets/img/selling/drop-ship-print-format.png">
\ No newline at end of file
+<img class="screenshot" alt="Drop Dhip Print Format" src="{{docs_base_url}}/assets/img/selling/drop-ship-print-format.png">
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/selling/articles/erpnext-for-services-organization.md b/erpnext/docs/user/manual/en/selling/articles/erpnext-for-services-organization.md
new file mode 100644
index 0000000..2fafa68
--- /dev/null
+++ b/erpnext/docs/user/manual/en/selling/articles/erpnext-for-services-organization.md
@@ -0,0 +1,28 @@
+<h1>ERPNext for Service Organizations</h1>
+
+**Question:** At first look, ERPNext looks primarily designed for the traders and manufacturers. Is ERPNext used by service companies as well?
+
+**Answer:**
+About 30% of ERPNext customers comes from services background. These are companies into software development, certification services, individual consultants and many more. Being into services business ourselves, we use ERPNext to manage our sales, accounting, support and HR operations.
+
+https://conf.erpnext.com/2014/videos/umair-sayyed
+
+###Master Setup
+
+Between the service and trading company, the most differentiating master is an item master. While trading and manufacturing business has stock item, with warehouse and other stock details, service items will have none of these details.
+
+To create a services item, which will be non-stock item, in the Item master, you should set "Is Stock Item" field as "No".
+
+![non-stock item]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-04-01 at 5.32.57 pm.png)
+
+###Hiding Non-required Features
+
+####Feature Setup
+
+In Feature Setup, you can activate specific functionalities, and disable others. Based on this setting, forms and fields not required for your business will be hidden. [More on feature setup here](https://manual.erpnext.com/customize-erpnext/hiding-modules-and-features).
+
+####Permissions
+
+ERPNext is the permission driven system. User will be able to access system based on permissions assigned to him/her. So, if user is not assigned Role related to Stock and Manufacturing module, it will be hidden from user. [More on permission management in ERPNext here](https://manual.erpnext.com/setting-up/users-and-permissions).
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/selling/articles/index.md b/erpnext/docs/user/manual/en/selling/articles/index.md
new file mode 100644
index 0000000..4e1be28
--- /dev/null
+++ b/erpnext/docs/user/manual/en/selling/articles/index.md
@@ -0,0 +1 @@
+{content}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/selling/articles/index.txt b/erpnext/docs/user/manual/en/selling/articles/index.txt
new file mode 100644
index 0000000..70b4ac2
--- /dev/null
+++ b/erpnext/docs/user/manual/en/selling/articles/index.txt
@@ -0,0 +1,6 @@
+applying-discount
+drop-shipping
+erpnext-for-services-organization
+manage-shipping-rule
+managing-sales-persons-in-sales-transactions
+stopping-sales-order
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/selling/articles/manage-shipping-rule.md b/erpnext/docs/user/manual/en/selling/articles/manage-shipping-rule.md
new file mode 100644
index 0000000..c9c4f91
--- /dev/null
+++ b/erpnext/docs/user/manual/en/selling/articles/manage-shipping-rule.md
@@ -0,0 +1,25 @@
+<h1>Manage Shipping Rule</h1>
+
+Shipping Rule master help you define rules based on which shipping charge will be applied on sales transactions.
+
+Most of the companies (mainly retail) have shipping charge applied based on invoice total. If invoice value is above certain range, then shipping charge applied will be lesser. If invoice total is less, then shipping charges applied will be higher. You can setup Shipping Rule to address the requirement of varying shipping charge based on total.
+
+To setup Shipping Rule, go to:
+
+Selling/Accounts >> Setup >> Shipping Rule
+
+Here is an example of Shipping Rule master:
+
+![Shipping Rule Master]({{docs_base_url}}/assets/img/articles/$SGrab_258.png)
+
+Referring above, you will notice that shipping charges are reducing as range of total is increasing. This shipping charge will only be applied if transaction total falls under one of the above range, else not.
+
+If shipping charges are applied based on Shipping Rule, then more values like Shipping Account, Cost Center will be needed as well to add row in the Taxes and Other Charges table of sales transaction. Hence these details are tracked as well in the Shipping Rule itself.
+
+![Shipping Rule Filters]({{docs_base_url}}/assets/img/articles/$SGrab_260.png)
+
+Apart from price range, Shipping Rule will also validate if its territory and company matches with that of Customer's territory and company.
+
+Following is an example of how shipping charges are auto-applied on sales order based on Shipping Rule.
+
+![Shipping Rule Application]({{docs_base_url}}/assets/img/articles/$SGrab_261.png)
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/selling/articles/managing-sales-persons-in-sales-transactions.md b/erpnext/docs/user/manual/en/selling/articles/managing-sales-persons-in-sales-transactions.md
new file mode 100644
index 0000000..ae92e63
--- /dev/null
+++ b/erpnext/docs/user/manual/en/selling/articles/managing-sales-persons-in-sales-transactions.md
@@ -0,0 +1,43 @@
+<h1>Managing Sales Persons In Sales Transactions</h1>
+
+In ERPNext, Sales Person master is maintained in [tree structure](https://erpnext.com/kb/setup/managing-tree-structure-masters). Sales Person table is available in all the Sales transactions, at the bottom of  transactions form.
+
+If you have specific Sales Person attached to Customer, you can mention Sales Person details in the Customer master itself. On selection of Customer in the transactions, you will have Sales Person details auto-fetched in that transaction.
+
+####Sales Person Contribution
+
+If you have more than one sales person working together on an order, then with listing all the sales person for that order, you will also need to define contribution based on their effort. For example, Sales Person Aasif, Harish and Jivan are working on order. While Aasif and Harish followed this order throughout, Jivan got involved just in the end. Accordingly you should define % Contribution in the sales transaction as:
+
+![Sales Person]({{docs_base_url}}/assets/img/articles/Selection_01087d575.png)
+
+Where Sales Order Net Total is 30,000.
+
+<div class=well>Total % Contribution for all Sales Person must be 100%. If only one Sales Person is selected, then enter % Contribution as 100% for him/her.</div>
+
+####Sales Person Transaction Report
+
+You can check Sales Person Transaction Report from 
+
+`Selling > Standard Reports > Sales Person-wise Transaction Summary`
+
+This report will be generated based on Sales Order, Delivery Note and Sales Invoice. This report will give you total amount of sales made by an employee over a period. Based on data provided from this report, you can determine incentives and plan appraisal for an employee.
+
+![SP Report]({{docs_base_url}}/assets/img/articles/Selection_011.png)
+
+####Sales Person wise Commission
+
+ERPNext doesn't calculate commission payable to an Employee, but only provide total amount of sales made by him/her. As a work around, you can add your Sales Person as Sales Partner, as commission calculation feature is readily available in ERPNext. You can check Sales Partner's Commission report from 
+
+`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` 
+
+![Feature Setup]({{docs_base_url}}/assets/img/articles/Selection_01244aec7.png)
+
+After uncheck Sales Extras from Sales and Purchase section, refresh your ERPNext account's tab, so that forms will take effect based on your setting.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/selling/articles/stopping-sales-order.md b/erpnext/docs/user/manual/en/selling/articles/stopping-sales-order.md
new file mode 100644
index 0000000..96a15de
--- /dev/null
+++ b/erpnext/docs/user/manual/en/selling/articles/stopping-sales-order.md
@@ -0,0 +1,17 @@
+<h1>Stopping a Sales Order</h1>
+
+In the submitted Sales Orders, you will find **Stop** option. Stopping Sales Order will restrict user from creating Delivery Note and Sales Invoice against it.
+
+![stop Sales Order]({{docs_base_url}}/assets/img/articles/$SGrab_439.png)
+
+####Scenario
+
+East Wind receives an order for ten laptops. Sales Order is also created for ten units. Due to scarcity of stock, only seven units are delivered to customer. Pending three units are to be delivered soon. Customer inform East Wind need not deliver pending item, as they have purchased it from other vendor.
+
+In this case, after East Wind will create Delivery Note and Sales Invoice only for the seven units of Laptop, and set Sales Order as stopped.
+
+![Sales Order Stopped]({{docs_base_url}}/assets/img/articles/$SGrab_440.png)
+
+Once Sales Order is set as stopped, you will not have pending quantities (three in this case) reflecting in Pending to Deliver and Pending to Invoice reports. To make further transactions against Stopped Sales Order, you should first Unstop it.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/selling/index.md b/erpnext/docs/user/manual/en/selling/index.md
similarity index 100%
rename from erpnext/docs/user/guides/selling/index.md
rename to erpnext/docs/user/manual/en/selling/index.md
diff --git a/erpnext/docs/user/guides/selling/index.txt b/erpnext/docs/user/manual/en/selling/index.txt
similarity index 80%
rename from erpnext/docs/user/guides/selling/index.txt
rename to erpnext/docs/user/manual/en/selling/index.txt
index 17dba4b..14332b7 100644
--- a/erpnext/docs/user/guides/selling/index.txt
+++ b/erpnext/docs/user/manual/en/selling/index.txt
@@ -1,4 +1,5 @@
 quotation
 sales-order
 drop-shipping
-setup
\ No newline at end of file
+setup
+articles
diff --git a/erpnext/docs/user/guides/selling/quotation.md b/erpnext/docs/user/manual/en/selling/quotation.md
similarity index 91%
rename from erpnext/docs/user/guides/selling/quotation.md
rename to erpnext/docs/user/manual/en/selling/quotation.md
index 25590e0..5be1508 100644
--- a/erpnext/docs/user/guides/selling/quotation.md
+++ b/erpnext/docs/user/manual/en/selling/quotation.md
@@ -11,11 +11,11 @@
 
 You can also create a Quotation from an Opportunity.
 
-<img class="screenshot" alt="Make Quotation from Opportunity" src="{{url_prefix}}/assets/img/selling/make-quote-from-opp.png">
+<img class="screenshot" alt="Make Quotation from Opportunity" src="{{docs_base_url}}/assets/img/selling/make-quote-from-opp.png">
 
 Or You can create a new Quotation and pull details from an Opportunity.
 
-<img class="screenshot" alt="Make Quotation from Opportunity" src="{{url_prefix}}/assets/img/selling/make-quotation.gif">
+<img class="screenshot" alt="Make Quotation from Opportunity" src="{{docs_base_url}}/assets/img/selling/make-quotation.gif">
 
 A Quotation contains details about:
 
@@ -35,7 +35,7 @@
 
 The rates you quote may depend on two things.
 
-  * The Price List: If you have multiple Price Lists, you can select a Price List or tag it to the Customer (so that it is auto-selected). Your Item prices will automatically be updated from the Price List.For details refer [Price List]({{url_prefix}}/user/guides/setting-up/price-lists.html)
+  * The Price List: If you have multiple Price Lists, you can select a Price List or tag it to the Customer (so that it is auto-selected). Your Item prices will automatically be updated from the Price List.For details refer [Price List]({{docs_base_url}}/user/guides/setting-up/price-lists.html)
 
   * The Currency: If you are quoting to a Customer in a different currency, you will have to update the conversion rates to enable ERPNext to save the information in your standard Currency. This will help you to analyze the value of your Quotations in standard Currency.
 
@@ -43,7 +43,7 @@
 
 To add taxes to your Quotation, you can either select a tax template, Sales
 Taxes and Charges Template or add the taxes on your own. To understand taxes in
-detail visit [Taxes]({{url_prefix}}/user/guides/setting-up/setting-up-taxes.html)
+detail visit [Taxes]({{docs_base_url}}/user/guides/setting-up/setting-up-taxes.html)
 
 You can add taxes in the same manner as the Sales Taxes and Charges Template.
 
diff --git a/erpnext/docs/user/guides/selling/sales-order.md b/erpnext/docs/user/manual/en/selling/sales-order.md
similarity index 93%
rename from erpnext/docs/user/guides/selling/sales-order.md
rename to erpnext/docs/user/manual/en/selling/sales-order.md
index b1438eb..269473a 100644
--- a/erpnext/docs/user/guides/selling/sales-order.md
+++ b/erpnext/docs/user/manual/en/selling/sales-order.md
@@ -11,7 +11,7 @@
 
 ### Sales Order Flow-Chart
 
-![Sales Order]({{url_prefix}}/assets/old_images/erpnext/sales-order-f.jpg)
+![Sales Order]({{docs_base_url}}/assets/old_images/erpnext/sales-order-f.jpg)
 
 To create a new Sales Order go to:
 
@@ -21,11 +21,11 @@
 
 You can also create a Sales Order from a submitted Quotation.
 
-<img class="screenshot" alt="Make Sales Order from Quotation" src="{{url_prefix}}/assets/img/selling/make-SO-from-quote.png">
+<img class="screenshot" alt="Make Sales Order from Quotation" src="{{docs_base_url}}/assets/img/selling/make-SO-from-quote.png">
 
 Or you can create a new Sales Order and pull details from an Quotation.
 
-<img class="screenshot" alt="Make Sales Order from Quotation" src="{{url_prefix}}/assets/img/selling/make-so.gif">
+<img class="screenshot" alt="Make Sales Order from Quotation" src="{{docs_base_url}}/assets/img/selling/make-so.gif">
 
 Most of the information in your Sales Order is the same as the Quotation.
 There are a few amongst other things that a Sales Order will ask you to
@@ -72,7 +72,7 @@
 
 ERPNext will automatically create new Order and mail a notification to the email IDs you set in the 'Notification Email Address'field.
 
-<img class="screenshot" alt="Reccuring Sales Order" src="{{url_prefix}}/assets/img/selling/recurring-sales-order.png">
+<img class="screenshot" alt="Reccuring Sales Order" src="{{docs_base_url}}/assets/img/selling/recurring-sales-order.png">
 
 ### Next Steps
 
diff --git a/erpnext/docs/user/guides/selling/setup/index.md b/erpnext/docs/user/manual/en/selling/setup/index.md
similarity index 100%
rename from erpnext/docs/user/guides/selling/setup/index.md
rename to erpnext/docs/user/manual/en/selling/setup/index.md
diff --git a/erpnext/docs/user/manual/en/selling/setup/index.txt b/erpnext/docs/user/manual/en/selling/setup/index.txt
new file mode 100644
index 0000000..67a93e5
--- /dev/null
+++ b/erpnext/docs/user/manual/en/selling/setup/index.txt
@@ -0,0 +1,8 @@
+selling-settings
+sales-partner
+shipping-rule
+product-bundle
+item-price.md
+sales-person-target-allocation.md
+item-price.md
+sales-person-target-allocation.md
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/selling/setup/item-price.md b/erpnext/docs/user/manual/en/selling/setup/item-price.md
similarity index 83%
rename from erpnext/docs/user/guides/selling/setup/item-price.md
rename to erpnext/docs/user/manual/en/selling/setup/item-price.md
index a235341..b877e8d 100644
--- a/erpnext/docs/user/guides/selling/setup/item-price.md
+++ b/erpnext/docs/user/manual/en/selling/setup/item-price.md
@@ -14,7 +14,7 @@
 
 You can create multiple Price List in ERPNext to track Selling and Buying Price List of an item separtely. Also if item's selling prices id changing based on territory, or due to other criteria, you can create multiple selling Price List for it.
 
-![Item Price list]({{url_prefix}}/assets/old_images/erpnext/item-price-list.png)
+![Item Price list]({{docs_base_url}}/assets/old_images/erpnext/item-price-list.png)
 
 On selection of Price List, its currency and for selling or buying property will be fetched as well.
 
@@ -24,13 +24,13 @@
 
 Select item for which Item Price record is to be created. On selection of Item Code, Item Name and Description will be fetched as well.
 
-![Item Price Item]({{url_prefix}}/assets/old_images/erpnext/item-price-item.png)
+![Item Price Item]({{docs_base_url}}/assets/old_images/erpnext/item-price-item.png)
 
 Step 3: Enter Rate
 
 Enter selling/buying rate of an item in Price List currency.
 
-![Item Price Rate]({{url_prefix}}/assets/old_images/erpnext/item-price-rate.png)
+![Item Price Rate]({{docs_base_url}}/assets/old_images/erpnext/item-price-rate.png)
 
 Step 4: Save Item Price
 
diff --git a/erpnext/docs/user/guides/selling/setup/product-bundle.md b/erpnext/docs/user/manual/en/selling/setup/product-bundle.md
similarity index 91%
rename from erpnext/docs/user/guides/selling/setup/product-bundle.md
rename to erpnext/docs/user/manual/en/selling/setup/product-bundle.md
index bb11b98..fa7f948 100644
--- a/erpnext/docs/user/guides/selling/setup/product-bundle.md
+++ b/erpnext/docs/user/manual/en/selling/setup/product-bundle.md
@@ -13,7 +13,7 @@
 
 Selling > Setup > Product Bundle > New
 
-<img class="screenshot" alt="Product Bundle" src="{{url_prefix}}/assets/img/selling/product-bundle.png">
+<img class="screenshot" alt="Product Bundle" src="{{docs_base_url}}/assets/img/selling/product-bundle.png">
 
 ###Select Parent Item
 
@@ -33,7 +33,7 @@
 When making Sales transactions like Sales Invoice, Sales Order and Delivery Note, 
 Parent Item will be selected in the main item table.
 
-<img class="screenshot" alt="Product Bundle" src="{{url_prefix}}/assets/img/selling/product-bundle.gif">
+<img class="screenshot" alt="Product Bundle" src="{{docs_base_url}}/assets/img/selling/product-bundle.gif">
 
 On selection on Parent Item in the main item table, its child items will be fetched in Packing List 
 table of the transaction. If child item is the serialized item, you will be able to specify its Serial Mo. 
diff --git a/erpnext/docs/user/guides/selling/setup/sales-partner.md b/erpnext/docs/user/manual/en/selling/setup/sales-partner.md
similarity index 74%
rename from erpnext/docs/user/guides/selling/setup/sales-partner.md
rename to erpnext/docs/user/manual/en/selling/setup/sales-partner.md
index 8710972..1174969 100644
--- a/erpnext/docs/user/guides/selling/setup/sales-partner.md
+++ b/erpnext/docs/user/manual/en/selling/setup/sales-partner.md
@@ -10,7 +10,7 @@
 
 Sales Partners are saved with Sales Partner name provided by user.
 
-<img class="screenshot" alt="Sales Partner" src="{{url_prefix}}/assets/img/selling/sales-partner.png">
+<img class="screenshot" alt="Sales Partner" src="{{docs_base_url}}/assets/img/selling/sales-partner.png">
 
 You can track their address and contact details and also allocate Sales Partner for each Item Group, based on Qty and Amount.
 
@@ -19,16 +19,16 @@
 To include the name of your Partner on your website, check the "Show in
 Website" box. When click on "Show in Website", you will see field where you can attach logo of partner's company and enter brief and introduction of partner.
 
-<img class="screenshot" alt="Sales Partner" src="{{url_prefix}}/assets/img/selling/sales-partner-website.png">
+<img class="screenshot" alt="Sales Partner" src="{{docs_base_url}}/assets/img/selling/sales-partner-website.png">
 
 To see listing of partner, you should go to:
 
 https://example.erpnext.com/partners
 
-![Sales Partner Listing]({{url_prefix}}/assets/old_images/erpnext/sales-partner-listing.png)
+![Sales Partner Listing]({{docs_base_url}}/assets/old_images/erpnext/sales-partner-listing.png)
 
 Following is the complete partners details published on the website.
 
-![Sales Partner Published]({{url_prefix}}/assets/old_images/erpnext/sales-partner-published.png)
+![Sales Partner Published]({{docs_base_url}}/assets/old_images/erpnext/sales-partner-published.png)
 
 {next}
diff --git a/erpnext/docs/user/guides/selling/setup/sales-person-target-allocation.md b/erpnext/docs/user/manual/en/selling/setup/sales-person-target-allocation.md
similarity index 84%
rename from erpnext/docs/user/guides/selling/setup/sales-person-target-allocation.md
rename to erpnext/docs/user/manual/en/selling/setup/sales-person-target-allocation.md
index 812e7ac..134a9b4 100644
--- a/erpnext/docs/user/guides/selling/setup/sales-person-target-allocation.md
+++ b/erpnext/docs/user/manual/en/selling/setup/sales-person-target-allocation.md
@@ -12,7 +12,7 @@
 
 In the Sales Person master, you will find table called Sales Person Target.
 
-![Sales Person Target Item Group]({{url_prefix}}/assets/old_images/erpnext/sales-person-target-item-group.png)
+![Sales Person Target Item Group]({{docs_base_url}}/assets/old_images/erpnext/sales-person-target-item-group.png)
 
 In this table, you should select Item Group, Fiscal Year, Target Qty and Amount. 
 
@@ -22,7 +22,7 @@
 
 If you wish to spread allocated target across months, then you shoult setup Target Distribution master, and select it in the Sales Person master. Considering our example, target for the month of December will be set as 5 qty (10% of total allocation).
 
-![Sales Person Target Distribution]({{url_prefix}}/assets/old_images/erpnext/sales-person-target-distribution.png)
+![Sales Person Target Distribution]({{docs_base_url}}/assets/old_images/erpnext/sales-person-target-distribution.png)
 
 ####Report - Sales Person Target Variance Item Groupwise
 
@@ -32,7 +32,7 @@
 
 This report will provide you variance between target and actual performance of Sales Person. This report is based on Sales Order report.
 
-![Sales Person Item Group Report]({{url_prefix}}/assets/old_images/erpnext/sales-person-item-group-report.png)
+![Sales Person Item Group Report]({{docs_base_url}}/assets/old_images/erpnext/sales-person-item-group-report.png)
 
 As per the report, allocated target to Sales Person for the month of December was 5 qty. However, Sales Order was made for this employee and Item Group for only 3 qty. Hence, variance of 2 qty is shown in the report.
 
@@ -48,7 +48,7 @@
 
 In the Territory master, you will find field to select Territory Manager. This field is linked to "Sales Person" master.
 
-![Sales Person Territory Manager]({{url_prefix}}/assets/old_images/erpnext/sales-person-territory-manager.png)
+![Sales Person Territory Manager]({{docs_base_url}}/assets/old_images/erpnext/sales-person-territory-manager.png)
 
 ####2.2 Allocating Target
 
@@ -62,7 +62,7 @@
 
 This report will provide you variance between target and actual performance of Sales in particular territory. This report is based on Sales Order report. Though Sales Person is defined in the Territory master, its details are not pulled in the report.
 
-![Sales Person Territory Report]({{url_prefix}}/assets/old_images/erpnext/sales-person-territory-report.png)
+![Sales Person Territory Report]({{docs_base_url}}/assets/old_images/erpnext/sales-person-territory-report.png)
 
 ---
 
@@ -74,7 +74,7 @@
 
 `Accounts > Setup > Budget Distributon`
 
-![Target Distribution]({{url_prefix}}/assets/old_images/erpnext/target-distribution.png)
+![Target Distribution]({{docs_base_url}}/assets/old_images/erpnext/target-distribution.png)
 
 You can link target distribution while allocation targets in Sales Person as well as in Territory master.
 
diff --git a/erpnext/docs/user/guides/selling/setup/selling-settings.md b/erpnext/docs/user/manual/en/selling/setup/selling-settings.md
similarity index 96%
rename from erpnext/docs/user/guides/selling/setup/selling-settings.md
rename to erpnext/docs/user/manual/en/selling/setup/selling-settings.md
index 4bf6782..d5d7117 100644
--- a/erpnext/docs/user/guides/selling/setup/selling-settings.md
+++ b/erpnext/docs/user/manual/en/selling/setup/selling-settings.md
@@ -1,7 +1,7 @@
 Selling Setting is where you can define propertiese which will be applied in your selling transactions. 
 Let's check into each property one by one.
 
-<img class="screenshot" alt="Selling Settings" src="{{url_prefix}}/assets/img/selling/selling-settings.png">
+<img class="screenshot" alt="Selling Settings" src="{{docs_base_url}}/assets/img/selling/selling-settings.png">
 
 ####1. Customer Naming By
 
diff --git a/erpnext/docs/user/guides/selling/setup/shipping-rule.md b/erpnext/docs/user/manual/en/selling/setup/shipping-rule.md
similarity index 63%
rename from erpnext/docs/user/guides/selling/setup/shipping-rule.md
rename to erpnext/docs/user/manual/en/selling/setup/shipping-rule.md
index 7fc24f1..c4369cb 100644
--- a/erpnext/docs/user/guides/selling/setup/shipping-rule.md
+++ b/erpnext/docs/user/manual/en/selling/setup/shipping-rule.md
@@ -1,6 +1,6 @@
 Using Shipping Rule you can define the cost for delivering the product to the customer.
 You can define different shipping rules for the same item across different territories.
 
-<img class="screenshot" alt="Shipping Rule" src="{{url_prefix}}/assets/img/selling/shipping-rule.png">
+<img class="screenshot" alt="Shipping Rule" src="{{docs_base_url}}/assets/img/selling/shipping-rule.png">
 
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/change-password.md b/erpnext/docs/user/manual/en/setting-up/articles/change-password.md
new file mode 100644
index 0000000..c65cc8b
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/change-password.md
@@ -0,0 +1,17 @@
+<h1>Change Password</h1>
+
+Each ERPNext user can customize password for his/her ERPNext account. Also user with System Manager role will be able to reset password for himself as well as for other users. Following are the steps to go about changing your password.
+
+
+####Step 1: Go to My Setting.
+
+![Image]({{docs_base_url}}/assets/img/articles/SGrab_250.png)
+
+####Step 2: Set New Password.
+
+![NEW]({{docs_base_url}}/assets/img/articles/Selection_014dd1559.png)
+
+Enter the new password and save the form to save changes. 
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/delete-a-company-and-all-related-transactions.md b/erpnext/docs/user/manual/en/setting-up/articles/delete-a-company-and-all-related-transactions.md
new file mode 100644
index 0000000..04e5203
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/delete-a-company-and-all-related-transactions.md
@@ -0,0 +1,20 @@
+<h1>Delete All Related Transactions for a Company</h1>
+
+Often, users setup all the master data and then create a few dummy records. Then they want to delete the dummy records and the company and start over again, keeping the other master data like Customers, Items, BOMs intact.
+
+Version 5 onwards, you can now delete all dummy transactions related to a company.
+
+To do that, open the company record.
+ 
+`Setup > Accounts > Company` or  `Accounts > Setup > Company`
+
+In Company master, click on the **Delete Company Transactions** button right at the bottom of the form. Then you must re-type the company name to confirm if you are sure you want to continue with this.
+
+This action will wipe out all the data related to that company like Quotation, Invoices, Purchase Orders etc. So be careful
+
+![Delete Company]({{docs_base_url}}/assets/img/articles/delete-company.png)
+
+
+**Note:** If you want to delete the company record itself, the use the normal "Delete" button from Menu options. It will also delete Chart of Accounts, Chart of Cost Centers and Warehouse records for that company.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/edit-submitted-document.html b/erpnext/docs/user/manual/en/setting-up/articles/edit-submitted-document.html
new file mode 100644
index 0000000..366d8a3
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/edit-submitted-document.html
@@ -0,0 +1,28 @@
+<h1>Edit Submitted Document</h1>
+
+&nbsp;To edit submitted document, you need to cancel it first. Followings are steps to edit submitted document.
+<br>
+<br><b>Step 1: Cancel Submitted Document</b><br>
+<br>You will find Cancel button on upper right corner of submitted document.
+<br>
+<br>
+<img src="{{docs_base_path}}/assets/img/articles/Selection_001.png">
+<br>
+<br><b>Step 2: Amend the document</b><br>
+<br>On cancellation of submitted document, <b>Amend</b> button will be became visible.
+<br>
+<br>
+<img src="{{docs_base_path}}/assets/img/articles/Selection_00256341a.png">
+<br>
+<br><b>Step 3: Save and Submit the document</b><br>
+<br>On clicking Amend button, same document will become editable again. After Making required changes, save and submit the document.
+<br>
+<br>
+<img src="{{docs_base_path}}/assets/img/articles/Selection_0036e00ef.png">
+<br>
+<br><div class="well">Note: If your document linked with other documents, then you will need to cancel last document you made on top of this document. Example:<br><br>If you have created Delivery Note and Sales Invoice against Sales Order, which you need to amend, then you should first Cancel Delivery Note and Sales Invoice made for that Sales Order. Then amend Sales Order, re-save and re-submit it.<br>
+</div><br>
+<br>
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/index.md b/erpnext/docs/user/manual/en/setting-up/articles/index.md
new file mode 100644
index 0000000..4e1be28
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/index.md
@@ -0,0 +1 @@
+{content}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/index.txt b/erpnext/docs/user/manual/en/setting-up/articles/index.txt
new file mode 100644
index 0000000..6f99f89
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/index.txt
@@ -0,0 +1,13 @@
+change-password
+delete-a-company-and-all-related-transactions
+edit-submitted-document
+integrating-erpnext-with-other-application
+manage-header-and-footer
+managing-multiple-companies
+managing-perm-level
+managing-tree-structure-masters
+naming-series-current-value
+overwriting-data-from-data-import-tool
+rename-user
+setting-up-dropbox-backups
+using-custom-domain-on-erpnext
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/integrating-erpnext-with-other-application.md b/erpnext/docs/user/manual/en/setting-up/articles/integrating-erpnext-with-other-application.md
new file mode 100644
index 0000000..1b7adf4
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/integrating-erpnext-with-other-application.md
@@ -0,0 +1,14 @@
+<h1>Integrating ERPNext with other Applications</h1>
+
+For now, ERPNext doesn't have out-of-the-box integration available for the third party applications. However, Frappe has REST API using which you can get ERPNext integrated with any other solution.
+
+Learn more about Frappe API here.
+
+[https://frappe.io/help/rest_api](https://frappe.io/help/rest_api)
+
+For experts services on integration, you can connect with our service providers from community portal.
+
+[https://frappe.io/community/service-providers](https://frappe.io/community/service-providers)
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/manage-header-and-footer.html b/erpnext/docs/user/manual/en/setting-up/articles/manage-header-and-footer.html
new file mode 100644
index 0000000..eee9618
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/manage-header-and-footer.html
@@ -0,0 +1,4 @@
+<h1>Manage Header And Footer</h1>
+
+<h1>Manage Header And Footer</h1>
+
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/managing-multiple-companies.md b/erpnext/docs/user/manual/en/setting-up/articles/managing-multiple-companies.md
new file mode 100644
index 0000000..dc9f667
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/managing-multiple-companies.md
@@ -0,0 +1,42 @@
+<h1>Managing Multiple Companies</h1>
+
+<h1>Managing Multiple Companies</h1>
+
+ERPNext allows you to create multiple companies in the same/common ERPNext account.
+
+With this, you will find option to select Company in your transactions. While most of the transactions will be separated based on Company, there are few masters like Item, Item Group, Customer Group, Territory etc. which can be used across all the companies.
+
+If you have separate teams working on each company, you can also restrict the access of user to the data of specific company. Click [here](https://manual.erpnext.com/search?txt=user%20permission) to know more about how to set permission to achieve the same.
+
+Following are the steps to create companies in your ERPNext account.
+
+####Go to Setup Module
+
+`Setup &gt; Masters &gt; Company &gt; New`
+
+####Enter Company Details
+
+Company master will be saved with Company Name provided at the time of its creation. 
+
+![New Company]({{docs_base_url}}/assets/img/articles/SGrab_343.png)
+
+Also, you can define other properties for new company like:
+
+* Country
+* Currency
+* Default Cash and Bank Account
+* Income/Expense Account
+* Company Registration Details
+
+Value will be auto-filled in most of these field to define company-wise defaults. You can edit/customize it as per your requirement. 
+
+![New Company]({{docs_base_url}}/assets/img/articles/SGrab_344.png)
+
+####Chart of Account for New Company
+
+A separate Chart of Account master will be set for each company in the ERPNext. This allows you managing Accounts/Ledger master separately for each company. Also it allows you avail financial statement and reports like Balance Sheet and Profit and Loss Statement separately for each company.
+
+![Company]({{docs_base_url}}/assets/img/articles/SGrab_342.png)
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/managing-perm-level.md b/erpnext/docs/user/manual/en/setting-up/articles/managing-perm-level.md
new file mode 100644
index 0000000..c44d1ea
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/managing-perm-level.md
@@ -0,0 +1,27 @@
+<h1>Managing Perm Level in Permission Manager</h1>
+
+<h1>Managing Perm Level in Permission Manager</h1>
+
+In each document, you can group fields by "levels". Each group of field is denoted by a unique number (0, 1, 2, 3 etc.). A separate set of permission rules can be applied to each field group. By default all fields are of level 0.
+
+Perm Level for a field can be defined in the [Customize Form](https://erpnext.com/user-guide/customize-erpnext/customize-form).
+
+![Customize Form]({{docs_base_url}}/assets/img/articles/$SGrab_256.png)
+
+If you need to assign different permission of particular field to different users, you can achieve it via Perm Level. Let's consider an example for better understanding.
+
+Delivery Note is accessible to Stock Manager as well as Stock User. You don't wish Stock User to access Amount related field in Delivery Note, but other field should be visible just like it is visible Stock Manager.
+
+For the amount related fields, you should set Perm Level as (say) 2.
+
+For Stock Manager, they will have permission on fields on Delivery Note as Perm Level 2 whereas a Stock User will not have any permission on Perm Level 2 for Delivery Note.
+
+![Perm Level Manager]({{docs_base_url}}/assets/img/articles/$SGrab_253.png)
+
+Considering the same scenario, if you want a Stock User to access a field at Perm Level 2, but not edit it, the Stock User will be assigned permission on Perm Level 2, but only for read, and not for write/edit.
+
+![Perm Level User]({{docs_base_url}}/assets/img/articles/$SGrab_254.png)
+
+Perm Level (1, 2, 3) not need be in order. Perm Level is primarily for grouping number of fields together, and then assigning permission to Roles for that group. Hence, you can set any perm level for an item, and then do permission setting for it.
+
+<!-- markdown -->
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/managing-tree-structure-masters.md b/erpnext/docs/user/manual/en/setting-up/articles/managing-tree-structure-masters.md
new file mode 100644
index 0000000..0de7869
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/managing-tree-structure-masters.md
@@ -0,0 +1,58 @@
+<h1>Managing Tree Structure Masters</h1>
+
+<h1>Managing Tree Structure Masters</h1>
+
+Some of the masters in ERPNext are maintained in tree structure. Tree structured masters allow you to set Parent masters, and Child masters under those Parents. Setting up this structure allows you creating intelligent report, and track growth at each level in the hierarchy. 
+
+Following is the partial list of masters which are maintained in the tree structure.
+
+* Chart of Accounts
+
+* Chart of Cost Centers
+
+* Customer Group
+
+* Territory
+
+* Sales Person
+
+* Item Group
+
+Following are the steps to manage and create record in the tree structured master. Let's consider Territory master to understand managing tree masters.
+
+####Step 1 : Go to Master
+
+`Selling > Setup > Territory`
+
+Also you can type master name in Awesome Bar to go to the related master.
+
+Tree master allows you to set Parent Territories, and Child Territories Groups under those Parents.
+
+####Step 2 : New Parent Territory
+
+![Territory Group]({{docs_base_url}}/assets/img/articles/Sselection_013.png)
+
+When click on Parent Territory, you will see option to add child territory under it. All default Territory groups will be listed under parent group called "All Territories". You can add further parent or child Territory Groups under it.
+
+####Step 3: Name The Territory Group
+
+When click on Add Child, a dialog box will provide two fields.
+
+**Territory Group Name**
+
+Territory will be saved with Territory Name provided here.
+
+**Group Node**
+
+If Group Node selected as Yes, then this Territory will be created as Parent, which means you can further create sub-territories under it. If select No, then it will become child Territory which you will be able to select in another masters.
+
+<div class="well">Only child Territory Groups are selectable in another masters and transactions.</div>
+![Child Territory]({{docs_base_url}}/assets/img/articles/Selection_0124080f1.png)
+
+Following is how Child Territories will be listed under a Parent Territory.
+
+![Territory Tree]({{docs_base_url}}/assets/img/articles/Selection_014.png)
+
+Following this steps, you can manage other tree masters in ERPNext.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/naming-series-current-value.md b/erpnext/docs/user/manual/en/setting-up/articles/naming-series-current-value.md
new file mode 100644
index 0000000..47cf1a4
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/naming-series-current-value.md
@@ -0,0 +1,63 @@
+<h1>Setting the Current Value for Naming Series</h1>
+
+<h1>Setting the Current Value for Naming Series</h1>
+
+Naming Series feature allows you to define prefix for number series of documents. For example, if a Sales Order has prefix "SO", then the series will be generated as SO00001, SO00002... and so on. Click [here](https://erpnext.com/user-guide/setting-up/document-naming-series) to learn how you can customize Number Series for a transaction/master in ERPNext.
+
+### 1. Setting the Current Value
+
+Naming Series feature also offers a tool where you can set Current Value for specific prefix. This is generally required if you have recently started using ERPNext, and have old transactions in the previous system, and you want the numbering series to start in from where it ended in the old system. Let's consider a scenario to learn this better.
+
+For example, you have 322 Sales Orders created in your old system with SO00322 as highest Sales Order Id. In ERPNext, you need the first Sales Order to pick up #323 when it is saved. To enable this, you should set Current Value for SO series in following steps.
+
+#### Go to Naming Series Tool
+
+`Setup > System > Naming Series`
+
+#### Update Series Section
+
+![Update Series Section]({{docs_base_url}}/assets/img/articles/$SGrab_420.png)
+
+#### Select Prefix
+
+Considering our scenario, prefix for Sales Order will be "SO".
+
+![Series Prefix]({{docs_base_url}}/assets/img/articles/$SGrab_418.png)
+
+#### Current Value
+
+If you have currently 12 Sales Orders created in your account, then current value updated will be 12. You can edit Current Value to 322, and then click on Update Series Number.
+
+![Series Current Value]({{docs_base_url}}/assets/img/articles/$SGrab_419.png)
+
+With this setting, you will have numbering for the New Sales Orders starting with #323.
+
+### 2. Error Due Series Number
+
+If you receive a Duplicate Name error while saving a transaction, for example, while saving Item Price, you receive an error saying:
+
+`Duplicate name Item Price RFD/00016`
+
+This error message indicates that when you are saving Item Price, system is trying to allocate "RFD/00016" to that Item Price record. But it is finding that Item Price with this ID is already existing in your system.
+
+This error could arise because Current Value for Series/Prefix of Item Price is disturbed and not in sync with actual Current Value. While actual Current Value for Item Price could be 20 (or any number more than 16), someone has set Current Value for this series as 15. 
+
+To confirm actual Current Value for particular Series, you should check report for document in question (Item Price in this case), and check for the Item Price ID with highest value. 
+
+Let's assume we find that actual Current Value for Item price is 22, then you go Naming Series, and set Current Value for the Prefix/Series of Item Price to 22, and Update Series Number.
+
+These instructions is applicable for all the documents in ERPNext for which user can customize Series and its Current Value.
+
+Let's consider another scenario to learn this better. On assigning a document to another user, error message says:
+
+`Duplicate name ToDo TDI00014286`
+
+This indicate the Current Value for Series/Prefix of ToDo (TDI) has been disturbed. You should follow these steps to correct value for Current Value for TDI prefix.
+
+1. Check ToDo report for the highest ToDo id value.
+1. Setup >> Settings >> Naming Series
+1. Check section B of Update Series
+1. Select Prefix for ToDo "TDI"
+1. Ensure that highest number for ToDo is updated as Current Value in Naming Series. If not, correct Current Value, and click on "Update Series Numbering".
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/overwriting-data-from-data-import-tool.html b/erpnext/docs/user/manual/en/setting-up/articles/overwriting-data-from-data-import-tool.html
new file mode 100644
index 0000000..1ae6cb5
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/overwriting-data-from-data-import-tool.html
@@ -0,0 +1,11 @@
+<h1>Overwriting Data from Data Import Tool</h1>
+
+<h1>Overwriting Data from Data Import Tool</h1>
+
+Data Import Tool allows importing documents (like customers, Suppliers, Orders, Invoices etc.) from spreadsheet file into ERPNext. The very same tool can also be used for overwrite values in the existing documents.
+<br>
+<br><div class="well">Over-writing data from Data Import Tool works only for Saved transactions, and not for Submitted ones.</div>
+Let's assume there are no. of items for which we need to overwrite Item Group.
+Following are the steps to go about overwriting Item Groups for existing Items.<br><br><h4>Step 1: Download Template</h4><br>Template Used for overwriting data will be same as one used for importing new items. Hence, you should first download template from.<br><br>Setup &gt;&gt; Data &gt;&gt; Import/Export Data<br><br>Since items to be over-written will be already available in the system, while downloading template, "Download with data" field should be checked. With this, we will have all the existing items being downloaded with the template.<br><br><img src="{{docs_base_path}}/assets/img/articles/$SGrab_285.png"><br><br><h4>Step 2: Prepare Data</h4><br>In the download template, We will only keep rows of the items to be worked on and delete the rest. Then we will enter new value in the Item Group column for an item. Since Item Group is a master in itself, we should ensure that Item Group entered in the excel file is already available in the Item Group master as well.<br><br><img src="{{docs_base_path}}/assets/img/articles/$SGrab_287.png"><br><br>Since we are overwriting only Item Group, only following columns will be mandatory.<br><br><ol><li>Column A (since it has main values of template)<br></li><li>Name (Column B)<br></li><li>Item Group<br></li></ol>Columns of other field which won't have any impact of overwriting can be
+ removed, even if they are mandatory. This is applicable only for 
+overwriting, and not when importing new records.<br><br><h4>Step 3: Import Data</h4><br>Once excel file is ready for importing, come back to Data Import Tool in ERPNext. We should first browser and select the File/template which has data to be overwritten. "Overwrite" field should be checked since we are overwriting Item Group in the existing items.<br><br><img src="{{docs_base_path}}/assets/img/articles/$SGrab_288.png"><br><br><h4>Step 4: Upload</h4><br>On clicking Upload and Import, if values as provided in the spreadsheet file is validated, it will be successfully updated in the item master.<br><br><img src="{{docs_base_path}}/assets/img/articles/$SGrab_289.png"><br><br>If validation of values fails, then it will indicate row no. of spreadsheet for which validation failed and needs correction. In that case, you should corrected value in that row, and then try importing/uploading file again. If validation fails for even one row, none of the records are imported/updated.<br>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/rename-user.md b/erpnext/docs/user/manual/en/setting-up/articles/rename-user.md
new file mode 100644
index 0000000..51fb637
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/rename-user.md
@@ -0,0 +1,31 @@
+<h1>Rename User</h1>
+
+<h1>Rename User</h1>
+
+Renaming functionality allows you to edit id of specific record. User is saved with person's email id. Only User with System Manager's role will be able to rename User IDs.
+
+Following are the steps to rename user id.
+
+#### Step 1: Go to User List
+
+Setup &gt; Users &gt; User
+
+Click to open user id you want to rename.
+
+#### Step 2: Go to Menu and click on Rename option. 
+
+When will you click on Rename option, pop up will open on same form. 
+
+<img src="{{docs_base_url}}/assets/img/articles/Selection_019811b13.png">
+
+
+#### Step 3: Enter new user ID and Press Rename Button.
+
+
+<img src="{{docs_base_url}}/assets/img/articles/Selection_021ac61a5.png"> 
+
+After successful renaming user can login to their ERPNext account with new ID.
+
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/setting-up-dropbox-backups.html b/erpnext/docs/user/manual/en/setting-up/articles/setting-up-dropbox-backups.html
new file mode 100644
index 0000000..1b7e4f7
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/setting-up-dropbox-backups.html
@@ -0,0 +1,74 @@
+<h1>Setting Up Dropbox Backups</h1>
+
+<h1>Setting Up Dropbox Backups</h1>
+
+<p style="font-family: 'Noto Sans', sans-serif; line-height: 23.7999992370605px;">If you wish to store your backups on a periodic basis,on Dropbox, you can do it directly through ERPNext.</p>
+<blockquote style="font-family: 'Noto Sans', sans-serif; line-height: 23.7999992370605px; background-color: rgb(247, 247, 247);">
+    <p>Setup &gt; Manage 3rd Party Backups</p>
+</blockquote>
+<p style="font-family: 'Noto Sans', sans-serif; line-height: 23.7999992370605px;"><strong>Step 1:</strong>&nbsp;Click on Integrations &gt; Backup Manager
+    <br>
+</p>
+<br>
+<div>
+    <p style="font-family: 'Noto Sans', sans-serif; line-height: 23.7999992370605px;">In the Backup Manager page, enter the email addresses of those people whom you wish to notify about the upload status. Under the topic 'Sync with Dropbox', select whether you wish to upload Daily, Weekly or Never.</p>
+    <p style="font-family: 'Noto Sans', sans-serif; line-height: 23.7999992370605px;"><strong>Step 2</strong> Click on&nbsp;<strong>Allow Dropbox Access</strong>.</p>
+    <blockquote style="font-family: 'Noto Sans', sans-serif; line-height: 23.7999992370605px; background-color: rgb(247, 247, 247);">
+        <p>Tip: In future, if you wish to discontinue uploading backups to dropbox, then select the Never option.</p>
+    </blockquote>
+    <img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2015-09-23 at 1.02.52 pm.png">
+</div>
+<div>&nbsp;
+    <br>
+</div>
+<div><b>
+    Step 3</b>
+    <br>
+</div>
+<div>
+    <p style="font-family: 'Noto Sans', sans-serif; line-height: 23.7999992370605px;">You need to login to your dropbox account, with your user id and password.</p>
+</div>
+<div>
+    <img src="{{docs_base_path}}/assets/img/articles/dropbox-access.png" style="line-height: 1.42857143;">&nbsp;
+    <br>
+</div>
+<div>
+    <br>
+    <hr>
+</div>
+<div>
+     <h3 style="font-family: 'Noto Sans', Helvetica, Arial, sans-serif; color: rgb(51, 51, 51);">Open Source Users</h3>
+
+</div>
+<div>
+    <br>
+</div>
+<div><b>Step 1: </b>Go to&nbsp;<a href="https://www.dropbox.com/developers/apps" target="_blank" style="line-height: 1.42857143;">https://www.dropbox.com/developers/apps</a>
+
+</div>
+<div><b>Step 2:</b> Create a new app</div>
+<div>
+    <img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2014-11-11 at 11.22.38 pm.png">
+    <br>
+</div>
+<div><b>Step 3: </b>Fill in details for the app.</div>
+<div>
+    <img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2014-11-11 at 11.23.32 pm.png">
+    <br>
+</div>
+<div>
+    <br>
+</div>
+<div><b>Step 4: </b>After the app is created, note the app key and app secret and enter in `sites/{sitename}/site_config.json` as follows,</div>
+<div>
+    <br>
+</div>
+<div><pre><code>{ 
+ "db_name": "demo", 
+ "db_password": "DZ1Idd55xJ9qvkHvUH", 
+ "dropbox_access_key": "ACCESSKEY", 
+ "dropbox_secret_key": "SECRECTKEY" 
+} </code></pre>
+    <br>
+</div>
+<div><b>Step 5: </b>Setup dropbox backups from the backup manager as shown in previous section.</div>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/articles/using-custom-domain-on-erpnext.md b/erpnext/docs/user/manual/en/setting-up/articles/using-custom-domain-on-erpnext.md
new file mode 100644
index 0000000..ff631b1
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/articles/using-custom-domain-on-erpnext.md
@@ -0,0 +1,13 @@
+<!-- markdown -->
+
+If you have subscribed to any of the plans at [ERPNext](https://erpnext.com), you can have us serve your site on your custom domain (for example at http://example.com). This enables your website to be served on a custom domain.
+
+To enable this feature, you will first have to edit DNS settings of your domain as follows.
+
+- Make a CNAME record for a subdomain (www in most cases) to {youraccountname}.erpnext.com
+- If you want serve the website on a naked domain (ie. http://example.com), set a URL redirect to http://www.example.com and not a CNAME record. Making a CNAME record in this case can have unexpected consequences including you not being able to receive emails anymore.
+
+After you've setup the DNS records, you will have to raise a support ticket by sending an email to support@erpnext.com and we'll take it from there.
+
+**Note**: We do not support HTTPS on custom domains. HTTPS enables end to end encryption (from your browser to our server). Although not critical for the website but we strongly recommend against using the ERPNext app over an unencrypted protocol. To be safe always use the ERP at your erpext.com address.
+
diff --git a/erpnext/docs/user/guides/setting-up/authorization-rule.md b/erpnext/docs/user/manual/en/setting-up/authorization-rule.md
similarity index 94%
rename from erpnext/docs/user/guides/setting-up/authorization-rule.md
rename to erpnext/docs/user/manual/en/setting-up/authorization-rule.md
index 3afdd79..6b79b6d 100644
--- a/erpnext/docs/user/guides/setting-up/authorization-rule.md
+++ b/erpnext/docs/user/manual/en/setting-up/authorization-rule.md
@@ -34,7 +34,7 @@
 
 Set Above Value. Given the exmaple, Above Value will be set as 10000.
 
-<img class="screenshot" alt="Authorization Rule" src="{{url_prefix}}/assets/img/setup/auth-rule.png">
+<img class="screenshot" alt="Authorization Rule" src="{{docs_base_url}}/assets/img/setup/auth-rule.png">
 
 If Sales User tries submitting Sales Order of value higher than 10000, then he will get error message.
 
diff --git a/erpnext/docs/user/guides/setting-up/bar-code.md b/erpnext/docs/user/manual/en/setting-up/bar-code.md
similarity index 90%
rename from erpnext/docs/user/guides/setting-up/bar-code.md
rename to erpnext/docs/user/manual/en/setting-up/bar-code.md
index 0f54d97..2077842 100644
--- a/erpnext/docs/user/guides/setting-up/bar-code.md
+++ b/erpnext/docs/user/manual/en/setting-up/bar-code.md
@@ -18,7 +18,7 @@
 
 #### Figure 1: Check the box 'Item Barcode'
 
-<img class="screenshot" alt="Barcode" src="{{url_prefix}}/assets/img/setup/barcode-1.png">
+<img class="screenshot" alt="Barcode" src="{{docs_base_url}}/assets/img/setup/barcode-1.png">
 
 
 To start scanning with a bar-code, go to  
@@ -39,7 +39,7 @@
   
 #### Figure 2: Check the box 'Is POS'
 
-<img class="screenshot" alt="Barcode" src="{{url_prefix}}/assets/img/setup/barcode-2.png">
+<img class="screenshot" alt="Barcode" src="{{docs_base_url}}/assets/img/setup/barcode-2.png">
 
 
 Go to Item and click on Add new row.  
diff --git a/erpnext/docs/user/guides/setting-up/calculate-incentive-for-sales-team.md b/erpnext/docs/user/manual/en/setting-up/calculate-incentive-for-sales-team.md
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/calculate-incentive-for-sales-team.md
rename to erpnext/docs/user/manual/en/setting-up/calculate-incentive-for-sales-team.md
diff --git a/erpnext/docs/user/guides/setting-up/company-setup.md b/erpnext/docs/user/manual/en/setting-up/company-setup.md
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/company-setup.md
rename to erpnext/docs/user/manual/en/setting-up/company-setup.md
diff --git a/erpnext/docs/user/guides/setting-up/data/bulk-rename.md b/erpnext/docs/user/manual/en/setting-up/data/bulk-rename.md
similarity index 82%
rename from erpnext/docs/user/guides/setting-up/data/bulk-rename.md
rename to erpnext/docs/user/manual/en/setting-up/data/bulk-rename.md
index 2aec08b..499ee32 100644
--- a/erpnext/docs/user/guides/setting-up/data/bulk-rename.md
+++ b/erpnext/docs/user/manual/en/setting-up/data/bulk-rename.md
@@ -12,6 +12,6 @@
 
 To rename multiple records, upload a **.csv** file with the old name in the first column and the new name in the second column and click on **Upload**.
 
-<img class="screenshot" alt="Bulk Rename" src="{{url_prefix}}/assets/img/setup/data/rename.png">
+<img class="screenshot" alt="Bulk Rename" src="{{docs_base_url}}/assets/img/setup/data/rename.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/data/data-import-tool.md b/erpnext/docs/user/manual/en/setting-up/data/data-import-tool.md
similarity index 88%
rename from erpnext/docs/user/guides/setting-up/data/data-import-tool.md
rename to erpnext/docs/user/manual/en/setting-up/data/data-import-tool.md
index 2a7eff1..e59ed21 100644
--- a/erpnext/docs/user/guides/setting-up/data/data-import-tool.md
+++ b/erpnext/docs/user/manual/en/setting-up/data/data-import-tool.md
@@ -4,7 +4,7 @@
 To Open the data import tool, you either go to Setup or go to the Transaction
 you want to Import. If Data Import is allowed, you will see an Import Button:
 
-<img alt="Start Import" class="screenshot" src="{{url_prefix}}/assets/img/setup/data-import/data-import-1.png">
+<img alt="Start Import" class="screenshot" src="{{docs_base_url}}/assets/img/setup/data-import/data-import-1.png">
 
 The tool has two sections, one to download a template and the second to upload
 the data.
@@ -20,7 +20,7 @@
 implemented where there are multiple values for any property. For example an
 Item can have multiple prices, An Invoice has multiple Items and so on.
 
-<img alt="Download Template" class="screenshot" src="{{url_prefix}}/assets/img/setup/data-import/data-import-2.png">
+<img alt="Download Template" class="screenshot" src="{{docs_base_url}}/assets/img/setup/data-import/data-import-2.png">
 
   * Click on the table you want to download or "All Tables"
   * For bulk editing, you can click on "Download With Data"
@@ -30,19 +30,19 @@
 After downloading the template, open it in a spreadsheet application and fill
 in the data below the column headings.
 
-![Spreadsheet]({{url_prefix}}/assets/old_images/erpnext/import-3.png)
+![Spreadsheet]({{docs_base_url}}/assets/old_images/erpnext/import-3.png)
 
 Then export your template or save it as a **Comma Separated Values** (CSV)
 file.
 
-![Spreadsheet]({{url_prefix}}/assets/old_images/erpnext/import-4.png)
+![Spreadsheet]({{docs_base_url}}/assets/old_images/erpnext/import-4.png)
 
 ### 3\. Upload the .csv File
 
 Finally attach the .csv file in the section. Click on the "Upload and Import"
 button.
 
-<img alt="Upload" class="screenshot" src="{{url_prefix}}/assets/img/setup/data-import/data-import-3.png">
+<img alt="Upload" class="screenshot" src="{{docs_base_url}}/assets/img/setup/data-import/data-import-3.png">
 
 #### Notes:
 
diff --git a/erpnext/docs/user/guides/setting-up/data/index.md b/erpnext/docs/user/manual/en/setting-up/data/index.md
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/data/index.md
rename to erpnext/docs/user/manual/en/setting-up/data/index.md
diff --git a/erpnext/docs/user/guides/setting-up/data/index.txt b/erpnext/docs/user/manual/en/setting-up/data/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/data/index.txt
rename to erpnext/docs/user/manual/en/setting-up/data/index.txt
diff --git a/erpnext/docs/user/guides/setting-up/email/setting-up-email.md b/erpnext/docs/user/manual/en/setting-up/email/.md
similarity index 91%
rename from erpnext/docs/user/guides/setting-up/email/setting-up-email.md
rename to erpnext/docs/user/manual/en/setting-up/email/.md
index 0fb4658..feb724f 100644
--- a/erpnext/docs/user/guides/setting-up/email/setting-up-email.md
+++ b/erpnext/docs/user/manual/en/setting-up/email/.md
@@ -24,7 +24,7 @@
 
 #### Figure 1: Set up outgoing mail server.
 
-![Email Settings]({{url_prefix}}/assets/old_images/erpnext/email-settings1.png)
+![Email Settings]({{docs_base_url}}/assets/old_images/erpnext/email-settings1.png)
 
 Set your outgoing mail server settings here. These are the same settings you
 would use in your Outlook, Thunderbird, Apple Mail or other such email
@@ -51,7 +51,7 @@
 
 #### Figure 2: Setup support Integration
 
-![Email Settings]({{url_prefix}}/assets/old_images/erpnext/email-settings2.png)
+![Email Settings]({{docs_base_url}}/assets/old_images/erpnext/email-settings2.png)
 
 To make ERPNext pull emails from your mail box, enter the POP3 settings. (POP3
 is a way of extracting emails from your mailbox. It should be fairly easy to
@@ -69,7 +69,7 @@
 
 #### Figure 3: Set Auto Notification
 
-![Auto Notification]({{url_prefix}}/assets/old_images/erpnext/auto-notification.png)
+![Auto Notification]({{docs_base_url}}/assets/old_images/erpnext/auto-notification.png)
 
 Check on the transactions you want to send via email directly on Submission
 and add a custom message if you want on these documents.
@@ -91,5 +91,5 @@
 
 #### Figure 4: Set up Email Digest
 
-![Email Digest]({{url_prefix}}/assets/old_images/erpnext/email-digest.png)
+![Email Digest]({{docs_base_url}}/assets/old_images/erpnext/email-digest.png)
 
diff --git a/erpnext/docs/user/guides/setting-up/email/email-account.md b/erpnext/docs/user/manual/en/setting-up/email/email-account.md
similarity index 82%
rename from erpnext/docs/user/guides/setting-up/email/email-account.md
rename to erpnext/docs/user/manual/en/setting-up/email/email-account.md
index 37ceddb..4392bf4 100644
--- a/erpnext/docs/user/guides/setting-up/email/email-account.md
+++ b/erpnext/docs/user/manual/en/setting-up/email/email-account.md
@@ -10,7 +10,7 @@
 
 There are 2 types of email accounts, outgoing and incoming. Outgoing email accounts use an SMTP service to send emails and emails are retrived from your inbox using a POP service. Most email providers such as GMail, Outlook or Yahoo provide these services.
 
-<img class="screenshot" alt="Defining Criteria" src="{{url_prefix}}/assets/img/setup/email/email-account-list.png">
+<img class="screenshot" alt="Defining Criteria" src="{{docs_base_url}}/assets/img/setup/email/email-account-list.png">
 
 ### Outgoing Email Accounts
 
@@ -18,13 +18,13 @@
 
 To setup an outgoing Email Account, check on **Enable Outgoing** and set your SMTP server settings, if you are using a popular email service, these will be preset for you.
 
-<img class="screenshot" alt="Outgoing EMail" src="{{url_prefix}}/assets/img/setup/email/email-account-sending.png">
+<img class="screenshot" alt="Outgoing EMail" src="{{docs_base_url}}/assets/img/setup/email/email-account-sending.png">
 
 ### Incoming Email Accounts
 
 To setup an incoming Email Account, check on **Enable Incoming** and set your POP3 settings, if you are using a popular email service, these will be preset for you.
 
-<img class="screenshot" alt="Incoming EMail" src="{{url_prefix}}/assets/img/setup/email/email-account-incoming.png">
+<img class="screenshot" alt="Incoming EMail" src="{{docs_base_url}}/assets/img/setup/email/email-account-incoming.png">
 
 ### How ERPNext handles replies
 
@@ -34,6 +34,6 @@
 
 If you would like ERPNext to notify you if an email is unreplied for a certain amount of time, then you can set **Notify if Unreplied**. Here you can set the number of minutes to wait before notifications are sent and whom the notifications must go to.
 
-<img class="screenshot" alt="Incoming EMail" src="{{url_prefix}}/assets/img/setup/email/email-account-unreplied.png">
+<img class="screenshot" alt="Incoming EMail" src="{{docs_base_url}}/assets/img/setup/email/email-account-unreplied.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/email/email-alerts.md b/erpnext/docs/user/manual/en/setting-up/email/email-alerts.md
similarity index 85%
rename from erpnext/docs/user/guides/setting-up/email/email-alerts.md
rename to erpnext/docs/user/manual/en/setting-up/email/email-alerts.md
index 4b1dad6..f4cccd3 100644
--- a/erpnext/docs/user/guides/setting-up/email/email-alerts.md
+++ b/erpnext/docs/user/manual/en/setting-up/email/email-alerts.md
@@ -33,9 +33,9 @@
 ### Example
 
 1. Defining the Criteria
-    <img class="screenshot" alt="Defining Criteria" src="{{url_prefix}}/assets/img/setup/email/email-alert-1.png">
+    <img class="screenshot" alt="Defining Criteria" src="{{docs_base_url}}/assets/img/setup/email/email-alert-1.png">
 
 1. Setting the Recipients and Message
-    <img class="screenshot" alt="Set Message" src="{{url_prefix}}/assets/img/setup/email/email-alert-2.png">
+    <img class="screenshot" alt="Set Message" src="{{docs_base_url}}/assets/img/setup/email/email-alert-2.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/email/email-digest.md b/erpnext/docs/user/manual/en/setting-up/email/email-digest.md
similarity index 82%
rename from erpnext/docs/user/guides/setting-up/email/email-digest.md
rename to erpnext/docs/user/manual/en/setting-up/email/email-digest.md
index 390c566..5fa836e 100644
--- a/erpnext/docs/user/guides/setting-up/email/email-digest.md
+++ b/erpnext/docs/user/manual/en/setting-up/email/email-digest.md
@@ -12,6 +12,6 @@
 
 Set your frequency, check all the items you want to receive in your weekly update and select the user ids whom you want to send the Digest to.
 
-<img class="screenshot" alt="Email Digest" src="{{url_prefix}}/assets/img/setup/email/email-digest.png">
+<img class="screenshot" alt="Email Digest" src="{{docs_base_url}}/assets/img/setup/email/email-digest.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/email/index.md b/erpnext/docs/user/manual/en/setting-up/email/index.md
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/email/index.md
rename to erpnext/docs/user/manual/en/setting-up/email/index.md
diff --git a/erpnext/docs/user/manual/en/setting-up/email/index.txt b/erpnext/docs/user/manual/en/setting-up/email/index.txt
new file mode 100644
index 0000000..b25c0d5
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/email/index.txt
@@ -0,0 +1,6 @@
+email-account
+email-alerts
+email-digest
+sending-email
+setting-up-email.md
+setting-up-email.md
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/setting-up/email/sending-email.md b/erpnext/docs/user/manual/en/setting-up/email/sending-email.md
new file mode 100644
index 0000000..cabcff5
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/email/sending-email.md
@@ -0,0 +1,9 @@
+# Sending Email from any Document
+
+In ERPNext you can send any document as email (with a PDF attachment) by clicking on `Menu > Email` from any open document.
+
+<img class="screenshot" alt="Send Email" src="{{docs_base_url}}/assets/img/setup/email/send-email.gif">
+
+**Note:** You must have outgoing [email accounts]({{docs_base_url}}/user/guides/setting-up/email/email-account.html) setup for this.
+
+{next}
diff --git a/erpnext/docs/user/guides/setting-up/index.md b/erpnext/docs/user/manual/en/setting-up/index.md
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/index.md
rename to erpnext/docs/user/manual/en/setting-up/index.md
diff --git a/erpnext/docs/user/guides/setting-up/index.txt b/erpnext/docs/user/manual/en/setting-up/index.txt
similarity index 84%
rename from erpnext/docs/user/guides/setting-up/index.txt
rename to erpnext/docs/user/manual/en/setting-up/index.txt
index cbd14e5..9237825 100644
--- a/erpnext/docs/user/guides/setting-up/index.txt
+++ b/erpnext/docs/user/manual/en/setting-up/index.txt
@@ -15,3 +15,5 @@
 workflows
 bar-code
 company-setup
+calculate-incentive-for-sales-team
+articles
diff --git a/erpnext/docs/user/guides/setting-up/pos-setting.md b/erpnext/docs/user/manual/en/setting-up/pos-setting.md
similarity index 81%
rename from erpnext/docs/user/guides/setting-up/pos-setting.md
rename to erpnext/docs/user/manual/en/setting-up/pos-setting.md
index 8380877..d04580c 100644
--- a/erpnext/docs/user/guides/setting-up/pos-setting.md
+++ b/erpnext/docs/user/manual/en/setting-up/pos-setting.md
@@ -14,10 +14,10 @@
 
 Set default values as defined.
 
-<img class="screenshot" alt="POS Setting" src="{{url_prefix}}/assets/img/pos-setting/pos-setting.png">
+<img class="screenshot" alt="POS Setting" src="{{docs_base_url}}/assets/img/pos-setting/pos-setting.png">
 
 > Important : If you specify a particular User, the POS setting will be
 applied only to that User. If the User option is left blank, the setting will
-be set for all users. To understand POS in detail visit [Point of Sale]({{url_prefix}}/user/guides/accounts/point-of-sale-pos-invoice.html)
+be set for all users. To understand POS in detail visit [Point of Sale]({{docs_base_url}}/user/guides/accounts/point-of-sale-pos-invoice.html)
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/price-lists.md b/erpnext/docs/user/manual/en/setting-up/price-lists.md
similarity index 91%
rename from erpnext/docs/user/guides/setting-up/price-lists.md
rename to erpnext/docs/user/manual/en/setting-up/price-lists.md
index 2acd83d..156e66d 100644
--- a/erpnext/docs/user/guides/setting-up/price-lists.md
+++ b/erpnext/docs/user/manual/en/setting-up/price-lists.md
@@ -8,7 +8,7 @@
 
 > Selling/Buying/Stock  > Setup > Price List >> New
 
-<img class="screenshot" alt="Price List" src="{{url_prefix}}/assets/img/price-list/price-list.png">
+<img class="screenshot" alt="Price List" src="{{docs_base_url}}/assets/img/price-list/price-list.png">
 
 * These Price List will be used when creating Item Price record to track selling or buying price of an item. Click here to learn more about Item Price.
 
diff --git a/erpnext/docs/user/guides/setting-up/print/address-template.md b/erpnext/docs/user/manual/en/setting-up/print/address-template.md
similarity index 90%
rename from erpnext/docs/user/guides/setting-up/print/address-template.md
rename to erpnext/docs/user/manual/en/setting-up/print/address-template.md
index 70682b2..c2b9bb7 100644
--- a/erpnext/docs/user/guides/setting-up/print/address-template.md
+++ b/erpnext/docs/user/manual/en/setting-up/print/address-template.md
@@ -26,6 +26,6 @@
 
 ### Example
 
-<img class="screenshot" alt="Print Heading" src="{{url_prefix}}/assets/img/setup/print/address-format.png">
+<img class="screenshot" alt="Print Heading" src="{{docs_base_url}}/assets/img/setup/print/address-format.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/print/index.md b/erpnext/docs/user/manual/en/setting-up/print/index.md
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/print/index.md
rename to erpnext/docs/user/manual/en/setting-up/print/index.md
diff --git a/erpnext/docs/user/guides/setting-up/print/index.txt b/erpnext/docs/user/manual/en/setting-up/print/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/print/index.txt
rename to erpnext/docs/user/manual/en/setting-up/print/index.txt
diff --git a/erpnext/docs/user/guides/setting-up/print/letter-head.md b/erpnext/docs/user/manual/en/setting-up/print/letter-head.md
similarity index 75%
rename from erpnext/docs/user/guides/setting-up/print/letter-head.md
rename to erpnext/docs/user/manual/en/setting-up/print/letter-head.md
index 1e69540..d3c24f2 100644
--- a/erpnext/docs/user/guides/setting-up/print/letter-head.md
+++ b/erpnext/docs/user/manual/en/setting-up/print/letter-head.md
@@ -14,10 +14,10 @@
 
 ### Example
 
-<img class="screenshot" alt="Print Heading" src="{{url_prefix}}/assets/img/setup/print/letter-head.png">
+<img class="screenshot" alt="Print Heading" src="{{docs_base_url}}/assets/img/setup/print/letter-head.png">
 
 This is how the letter head looks in a document print:
 
-<img class="screenshot" alt="Print Heading" src="{{url_prefix}}/assets/img/setup/print/letter-head-1.png">
+<img class="screenshot" alt="Print Heading" src="{{docs_base_url}}/assets/img/setup/print/letter-head-1.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/print/print-format-builder.md b/erpnext/docs/user/manual/en/setting-up/print/print-format-builder.md
similarity index 70%
rename from erpnext/docs/user/guides/setting-up/print/print-format-builder.md
rename to erpnext/docs/user/manual/en/setting-up/print/print-format-builder.md
index 3af05f5..f979927 100644
--- a/erpnext/docs/user/guides/setting-up/print/print-format-builder.md
+++ b/erpnext/docs/user/manual/en/setting-up/print/print-format-builder.md
@@ -10,19 +10,19 @@
 
 ### Step 1: Make a new Format
 
-<img class="screenshot" alt="Send Email" src="{{url_prefix}}/assets/img/setup/print/print-format-builder-1.gif">
+<img class="screenshot" alt="Send Email" src="{{docs_base_url}}/assets/img/setup/print/print-format-builder-1.gif">
 
 ### Step 2: Add a new Field
 
 To add a field, just drag it from the left sidebar and add it in your layout. You can edit the layout by clicking on the settings <i class="octicon octicon-gear"></i> icon.
 
-<img class="screenshot" alt="Send Email" src="{{url_prefix}}/assets/img/setup/print/print-format-builder-2.gif">
+<img class="screenshot" alt="Send Email" src="{{docs_base_url}}/assets/img/setup/print/print-format-builder-2.gif">
 
 ### Step 3
 
 To remove a field, just drag it back into the fields sidebar.
 
-<img class="screenshot" alt="Send Email" src="{{url_prefix}}/assets/img/setup/print/print-format-builder-3.gif">
+<img class="screenshot" alt="Send Email" src="{{docs_base_url}}/assets/img/setup/print/print-format-builder-3.gif">
 
 ### Step 4
 
@@ -30,7 +30,7 @@
 
 Then click on **Edit HTML** to edit your content.
 
-<img class="screenshot" alt="Send Email" src="{{url_prefix}}/assets/img/setup/print/print-format-builder-4.gif">
+<img class="screenshot" alt="Send Email" src="{{docs_base_url}}/assets/img/setup/print/print-format-builder-4.gif">
 
 To save your format, just click on the **Save** button on the top.
 
diff --git a/erpnext/docs/user/guides/setting-up/print/print-headings.md b/erpnext/docs/user/manual/en/setting-up/print/print-headings.md
similarity index 61%
rename from erpnext/docs/user/guides/setting-up/print/print-headings.md
rename to erpnext/docs/user/manual/en/setting-up/print/print-headings.md
index 4c492e0..98fbf53 100644
--- a/erpnext/docs/user/guides/setting-up/print/print-headings.md
+++ b/erpnext/docs/user/manual/en/setting-up/print/print-headings.md
@@ -8,10 +8,10 @@
 
 #### Figure 1: Save Print Heading
 
-<img class="screenshot" alt="Print Heading" src="{{url_prefix}}/assets/img/setup/print/print-heading.png">
+<img class="screenshot" alt="Print Heading" src="{{docs_base_url}}/assets/img/setup/print/print-heading.png">
 
 Example of a change in print heading is shown below:
 
-<img class="screenshot" alt="Print Heading" src="{{url_prefix}}/assets/img/setup/print/print-heading-1.png">
+<img class="screenshot" alt="Print Heading" src="{{docs_base_url}}/assets/img/setup/print/print-heading-1.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/print/print-settings.md b/erpnext/docs/user/manual/en/setting-up/print/print-settings.md
similarity index 69%
rename from erpnext/docs/user/guides/setting-up/print/print-settings.md
rename to erpnext/docs/user/manual/en/setting-up/print/print-settings.md
index a4788df..cdf3c54 100644
--- a/erpnext/docs/user/guides/setting-up/print/print-settings.md
+++ b/erpnext/docs/user/manual/en/setting-up/print/print-settings.md
@@ -6,6 +6,6 @@
 
 > Setup > Printing and Branding > Print Settings
 
-<img class="screenshot" alt="Print Settings" src="{{url_prefix}}/assets/img/setup/print/print-settings.png">
+<img class="screenshot" alt="Print Settings" src="{{docs_base_url}}/assets/img/setup/print/print-settings.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/print/terms-and-conditions.md b/erpnext/docs/user/manual/en/setting-up/print/terms-and-conditions.md
similarity index 84%
rename from erpnext/docs/user/guides/setting-up/print/terms-and-conditions.md
rename to erpnext/docs/user/manual/en/setting-up/print/terms-and-conditions.md
index 383ca48..8c939d0 100644
--- a/erpnext/docs/user/guides/setting-up/print/terms-and-conditions.md
+++ b/erpnext/docs/user/manual/en/setting-up/print/terms-and-conditions.md
@@ -6,13 +6,13 @@
 
 `Selling > Terms and Condition > New`
 
-<img class="screenshot" alt="Terms and Conditions" src="{{url_prefix}}/assets/img/setup/print/terms-1.png">
+<img class="screenshot" alt="Terms and Conditions" src="{{docs_base_url}}/assets/img/setup/print/terms-1.png">
 
 ### 2. Editing in HTML
 
 Content of Terms and Condition can be formatted as per your preference, and also insert images where needed. If you have expertise in HTML, you will also find option to edit the content of Terms and Condition in HTML.
 
-<img class="screenshot" alt="Terms and Conditions, Edit HTML" src="{{url_prefix}}/assets/img/setup/print/terms-2.png">
+<img class="screenshot" alt="Terms and Conditions, Edit HTML" src="{{docs_base_url}}/assets/img/setup/print/terms-2.png">
 
 This also allows you to use Terms and Condition master for footer, which otherwise is not availale in ERPNext as dedicated functionality. Since contents of Terms and Condition is always the last to appear in the print format, details of footer should be inserted at the end of the content, so that it actually appears as footer in the print format.
 
@@ -20,6 +20,6 @@
 
 In transactions, you will find section of Terms and Condition where you will be able to search and fetched required Terms and Condition master.
 
-<img class="screenshot" alt="Terms and Conditions, Select in document" src="{{url_prefix}}/assets/img/setup/print/terms-3.png">
+<img class="screenshot" alt="Terms and Conditions, Select in document" src="{{docs_base_url}}/assets/img/setup/print/terms-3.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/setting-up-taxes.md b/erpnext/docs/user/manual/en/setting-up/setting-up-taxes.md
similarity index 93%
rename from erpnext/docs/user/guides/setting-up/setting-up-taxes.md
rename to erpnext/docs/user/manual/en/setting-up/setting-up-taxes.md
index 0c42819..a3c11ab 100644
--- a/erpnext/docs/user/guides/setting-up/setting-up-taxes.md
+++ b/erpnext/docs/user/manual/en/setting-up/setting-up-taxes.md
@@ -22,11 +22,11 @@
 
 Item Tax table can be found as a section within the Item Master document.
 
-<img class="screenshot" alt="Item Tax" src="{{url_prefix}}/assets/img/taxes/item-tax.png">
+<img class="screenshot" alt="Item Tax" src="{{docs_base_url}}/assets/img/taxes/item-tax.png">
 
   * **Inclusive and Exclusive Tax**: ERPNext allows you to enter Item rates which are tax inclusive.
 
-<img class="screenshot" alt="Inclusive Tax" src="{{url_prefix}}/assets/img/taxes/inclusive-tax.png">
+<img class="screenshot" alt="Inclusive Tax" src="{{docs_base_url}}/assets/img/taxes/inclusive-tax.png">
 
   * **Exception to the rule**: Item tax settings are required only if a particular Item has a different tax rate than the rate defined in the standard tax Account
   * **Item tax is overwrite-able**: You can overwrite or change the item tax rate by going to the Item master in the Item tax table.
@@ -49,7 +49,7 @@
 
 > Setup > Accounts > Sales Taxes and Charge Master
 
-<img class="screenshot" alt="Sales Tax Master" src="{{url_prefix}}/assets/img/taxes/sales-tax-master.png">
+<img class="screenshot" alt="Sales Tax Master" src="{{docs_base_url}}/assets/img/taxes/sales-tax-master.png">
 
 When you create a new master, you will have to add a row for each tax type.
 
diff --git a/erpnext/docs/user/guides/setting-up/settings/global-defaults.md b/erpnext/docs/user/manual/en/setting-up/settings/global-defaults.md
similarity index 63%
rename from erpnext/docs/user/guides/setting-up/settings/global-defaults.md
rename to erpnext/docs/user/manual/en/setting-up/settings/global-defaults.md
index fd3868c..412572a 100644
--- a/erpnext/docs/user/guides/setting-up/settings/global-defaults.md
+++ b/erpnext/docs/user/manual/en/setting-up/settings/global-defaults.md
@@ -6,6 +6,6 @@
 
 Whenever a new document is created, these values will be set as default.
 
-<img class="screenshot" alt="Global Defaults" src="{{url_prefix}}/assets/img/setup/settings/global-defaults.png">
+<img class="screenshot" alt="Global Defaults" src="{{docs_base_url}}/assets/img/setup/settings/global-defaults.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/settings/index.md b/erpnext/docs/user/manual/en/setting-up/settings/index.md
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/settings/index.md
rename to erpnext/docs/user/manual/en/setting-up/settings/index.md
diff --git a/erpnext/docs/user/guides/setting-up/settings/index.txt b/erpnext/docs/user/manual/en/setting-up/settings/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/settings/index.txt
rename to erpnext/docs/user/manual/en/setting-up/settings/index.txt
diff --git a/erpnext/docs/user/guides/setting-up/settings/module-settings.md b/erpnext/docs/user/manual/en/setting-up/settings/module-settings.md
similarity index 73%
rename from erpnext/docs/user/guides/setting-up/settings/module-settings.md
rename to erpnext/docs/user/manual/en/setting-up/settings/module-settings.md
index db54494..ecfb282 100644
--- a/erpnext/docs/user/guides/setting-up/settings/module-settings.md
+++ b/erpnext/docs/user/manual/en/setting-up/settings/module-settings.md
@@ -10,6 +10,6 @@
 
 Check / uncheck the items to show / hide.
 
-<img class="screenshot" alt="Module Settings" src="{{url_prefix}}/assets/img/setup/settings/show-hide-modules.png">
+<img class="screenshot" alt="Module Settings" src="{{docs_base_url}}/assets/img/setup/settings/show-hide-modules.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/settings/naming-series.md b/erpnext/docs/user/manual/en/setting-up/settings/naming-series.md
similarity index 93%
rename from erpnext/docs/user/guides/setting-up/settings/naming-series.md
rename to erpnext/docs/user/manual/en/setting-up/settings/naming-series.md
index 4c3f2c1..df7de6d 100644
--- a/erpnext/docs/user/guides/setting-up/settings/naming-series.md
+++ b/erpnext/docs/user/manual/en/setting-up/settings/naming-series.md
@@ -42,7 +42,7 @@
 
 See how to set the naming series
 
-<img class="screenshot" alt="Naming Series" src="{{url_prefix}}/assets/img/setup/settings/naming-series.gif">
+<img class="screenshot" alt="Naming Series" src="{{docs_base_url}}/assets/img/setup/settings/naming-series.gif">
 
 {next}
 
diff --git a/erpnext/docs/user/guides/setting-up/settings/system-settings.md b/erpnext/docs/user/manual/en/setting-up/settings/system-settings.md
similarity index 67%
rename from erpnext/docs/user/guides/setting-up/settings/system-settings.md
rename to erpnext/docs/user/manual/en/setting-up/settings/system-settings.md
index a529171..053b4f1 100644
--- a/erpnext/docs/user/guides/setting-up/settings/system-settings.md
+++ b/erpnext/docs/user/manual/en/setting-up/settings/system-settings.md
@@ -6,6 +6,6 @@
 
 > Setup > Settings > System Settings
 
-<img class="screenshot" alt="System Settings" src="{{url_prefix}}/assets/img/setup/settings/system-settings.png">
+<img class="screenshot" alt="System Settings" src="{{docs_base_url}}/assets/img/setup/settings/system-settings.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/setup-wizard/index.md b/erpnext/docs/user/manual/en/setting-up/setup-wizard/index.md
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/setup-wizard/index.md
rename to erpnext/docs/user/manual/en/setting-up/setup-wizard/index.md
diff --git a/erpnext/docs/user/guides/setting-up/setup-wizard/index.txt b/erpnext/docs/user/manual/en/setting-up/setup-wizard/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/setup-wizard/index.txt
rename to erpnext/docs/user/manual/en/setting-up/setup-wizard/index.txt
diff --git a/erpnext/docs/user/guides/setting-up/setup-wizard/step-1-language.md b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-1-language.md
similarity index 72%
rename from erpnext/docs/user/guides/setting-up/setup-wizard/step-1-language.md
rename to erpnext/docs/user/manual/en/setting-up/setup-wizard/step-1-language.md
index 4e2ffe8..00219fd 100644
--- a/erpnext/docs/user/guides/setting-up/setup-wizard/step-1-language.md
+++ b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-1-language.md
@@ -2,7 +2,7 @@
 
 Select your language. ERPNext is available in more than 20 languages.
 
-<img alt="Language" class="screenshot" src="{{url_prefix}}/assets/img/setup-wizard/step-1.png">
+<img alt="Language" class="screenshot" src="{{docs_base_url}}/assets/img/setup-wizard/step-1.png">
 
 ---
 
diff --git a/erpnext/docs/user/guides/setting-up/setup-wizard/step-10-item.md b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-10-item.md
similarity index 85%
rename from erpnext/docs/user/guides/setting-up/setup-wizard/step-10-item.md
rename to erpnext/docs/user/manual/en/setting-up/setup-wizard/step-10-item.md
index 61e3c49..bc71b98 100644
--- a/erpnext/docs/user/guides/setting-up/setup-wizard/step-10-item.md
+++ b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-10-item.md
@@ -3,7 +3,7 @@
 In this final step, please enter the names of the Items you buy or sell.
 
 <img alt="Add Items" class="screenshot"
-src="{{url_prefix}}/assets/img/setup-wizard/step-10.png">
+src="{{docs_base_url}}/assets/img/setup-wizard/step-10.png">
 
 Please set the group of the item (Product / Service) and unit of measure. Don't worry you will be able to edit all of this later.
 
diff --git a/erpnext/docs/user/guides/setting-up/setup-wizard/step-2-currency-and-timezone.md b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-2-currency-and-timezone.md
similarity index 65%
rename from erpnext/docs/user/guides/setting-up/setup-wizard/step-2-currency-and-timezone.md
rename to erpnext/docs/user/manual/en/setting-up/setup-wizard/step-2-currency-and-timezone.md
index 17a3821..5dc1648 100644
--- a/erpnext/docs/user/guides/setting-up/setup-wizard/step-2-currency-and-timezone.md
+++ b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-2-currency-and-timezone.md
@@ -2,7 +2,7 @@
 
 Set your country name, currency and timezone.
 
-<img alt="Currency" class="screenshot" src="{{url_prefix}}/assets/img/setup-wizard/step-2.png">
+<img alt="Currency" class="screenshot" src="{{docs_base_url}}/assets/img/setup-wizard/step-2.png">
 
 ---
 
diff --git a/erpnext/docs/user/guides/setting-up/setup-wizard/step-3-user-details.md b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-3-user-details.md
similarity index 76%
rename from erpnext/docs/user/guides/setting-up/setup-wizard/step-3-user-details.md
rename to erpnext/docs/user/manual/en/setting-up/setup-wizard/step-3-user-details.md
index 9b20dd0..b9eff18 100644
--- a/erpnext/docs/user/guides/setting-up/setup-wizard/step-3-user-details.md
+++ b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-3-user-details.md
@@ -3,7 +3,7 @@
 Enter Users Profile Details like Name, User ID and preferred password.
 
 <img alt="User" class="screenshot"
-src="{{url_prefix}}/assets/img/setup-wizard/step-3.png">
+src="{{docs_base_url}}/assets/img/setup-wizard/step-3.png">
 
 ---
 
diff --git a/erpnext/docs/user/guides/setting-up/setup-wizard/step-4-company-details.md b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-4-company-details.md
similarity index 92%
rename from erpnext/docs/user/guides/setting-up/setup-wizard/step-4-company-details.md
rename to erpnext/docs/user/manual/en/setting-up/setup-wizard/step-4-company-details.md
index cb5947b..f88d31c 100644
--- a/erpnext/docs/user/guides/setting-up/setup-wizard/step-4-company-details.md
+++ b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-4-company-details.md
@@ -3,7 +3,7 @@
 Enter Company Details like Name, Abbreviation and Financial Year Details.
 
 <img alt="Company Details" class="screenshot"
-src="{{url_prefix}}/assets/img/setup-wizard/step-4.png">
+src="{{docs_base_url}}/assets/img/setup-wizard/step-4.png">
 
 ---
 
diff --git a/erpnext/docs/user/guides/setting-up/setup-wizard/step-5-letterhead-and-logo.md b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-5-letterhead-and-logo.md
similarity index 85%
rename from erpnext/docs/user/guides/setting-up/setup-wizard/step-5-letterhead-and-logo.md
rename to erpnext/docs/user/manual/en/setting-up/setup-wizard/step-5-letterhead-and-logo.md
index ad91d24..7cc258b 100644
--- a/erpnext/docs/user/guides/setting-up/setup-wizard/step-5-letterhead-and-logo.md
+++ b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-5-letterhead-and-logo.md
@@ -3,7 +3,7 @@
 Attach Company Letterhead and Company Logo.
 
 <img alt="Company Logo and Letterhead" class="screenshot"
-src="{{url_prefix}}/assets/img/setup-wizard/step-5.png">
+src="{{docs_base_url}}/assets/img/setup-wizard/step-5.png">
 
 ---
 
@@ -15,7 +15,7 @@
 
 You may choose to skip this step if your letterhead is not ready.
 
-To select letterhead later through the setup module, read [Letter-head]({{url_prefix}}/user/guides/setting-up/print/letter-head.html)
+To select letterhead later through the setup module, read [Letter-head]({{docs_base_url}}/user/guides/setting-up/print/letter-head.html)
 
 #### To "attach as web-link"
 
diff --git a/erpnext/docs/user/guides/setting-up/setup-wizard/step-6-add-users.md b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-6-add-users.md
similarity index 70%
rename from erpnext/docs/user/guides/setting-up/setup-wizard/step-6-add-users.md
rename to erpnext/docs/user/manual/en/setting-up/setup-wizard/step-6-add-users.md
index 06cc778..7e8f083 100644
--- a/erpnext/docs/user/guides/setting-up/setup-wizard/step-6-add-users.md
+++ b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-6-add-users.md
@@ -3,6 +3,6 @@
 Add other users and assign them roles based on their job responsibilities.
 
 <img alt="Users" class="screenshot"
-src="{{url_prefix}}/assets/img/setup-wizard/step-6.png">
+src="{{docs_base_url}}/assets/img/setup-wizard/step-6.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/setup-wizard/step-7-tax-details.md b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-7-tax-details.md
similarity index 89%
rename from erpnext/docs/user/guides/setting-up/setup-wizard/step-7-tax-details.md
rename to erpnext/docs/user/manual/en/setting-up/setup-wizard/step-7-tax-details.md
index 0214867..ead3fc9 100644
--- a/erpnext/docs/user/guides/setting-up/setup-wizard/step-7-tax-details.md
+++ b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-7-tax-details.md
@@ -3,7 +3,7 @@
 Enter any three types of taxes which you regularly pay. This wizard will create a tax master which will calculate the taxes as per the tax-type.
 
 <img alt="Tax Details" class="screenshot"
-src="{{url_prefix}}/assets/img/setup-wizard/step-7.png">
+src="{{docs_base_url}}/assets/img/setup-wizard/step-7.png">
 
 Just set the tax name and the standard percentage levied.
 
@@ -17,6 +17,6 @@
 
 The purpose of VAT is to generate tax revenues to the government similar to the corporate income tax or the personal income tax. For Example: When you shop at a departmental store and avail discount on the products, the store charges you 5% extra on the total bill as the VAT.
 
-To setup VAT in the setup wizard , simply enter the percentage amount levied by your government. To setup VAT at a later stage read [setting-up-taxes]({{url_prefix}}/user/guides/setting-up/setting-up-taxes.html)
+To setup VAT in the setup wizard , simply enter the percentage amount levied by your government. To setup VAT at a later stage read [setting-up-taxes]({{docs_base_url}}/user/guides/setting-up/setting-up-taxes.html)
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/setup-wizard/step-8-customer-names.md b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-8-customer-names.md
similarity index 76%
rename from erpnext/docs/user/guides/setting-up/setup-wizard/step-8-customer-names.md
rename to erpnext/docs/user/manual/en/setting-up/setup-wizard/step-8-customer-names.md
index 04ac27c..b82202c 100644
--- a/erpnext/docs/user/guides/setting-up/setup-wizard/step-8-customer-names.md
+++ b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-8-customer-names.md
@@ -4,7 +4,7 @@
 
 
 <img alt="Customers" class="screenshot"
-src="{{url_prefix}}/assets/img/setup-wizard/step-8.png">
+src="{{docs_base_url}}/assets/img/setup-wizard/step-8.png">
 
 ---
 
@@ -18,6 +18,6 @@
 
 Contact Name:  Shiv Agarwal
 
-To understand Customer in detail visit [Customer Details]({{url_prefix}}/user/guides/CRM/customer.html)
+To understand Customer in detail visit [Customer Details]({{docs_base_url}}/user/guides/CRM/customer.html)
 
 {next}
diff --git a/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-9-suppliers.md b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-9-suppliers.md
new file mode 100644
index 0000000..5d2f381
--- /dev/null
+++ b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-9-suppliers.md
@@ -0,0 +1,12 @@
+# Step 8: Suppliers
+
+Enter a few of your Suppliers' names.
+
+<img alt="Suppliers" class="screenshot"
+src="{{docs_base_url}}/assets/img/setup-wizard/step-9.png">
+
+---
+
+To understand Suppliers in detail visit [Supplier Master]({{docs_base_url}}/user/guides/buying/supplier-master.html)
+
+{next}
diff --git a/erpnext/docs/user/guides/setting-up/sms-setting.md b/erpnext/docs/user/manual/en/setting-up/sms-setting.md
similarity index 88%
rename from erpnext/docs/user/guides/setting-up/sms-setting.md
rename to erpnext/docs/user/manual/en/setting-up/sms-setting.md
index f2e21aa..4871ed1 100644
--- a/erpnext/docs/user/guides/setting-up/sms-setting.md
+++ b/erpnext/docs/user/manual/en/setting-up/sms-setting.md
@@ -17,7 +17,7 @@
     http://instant.smses.com/web2sms.php?username=<USERNAME>&password;=<PASSWORD>&to;=<MOBILENUMBER>&sender;=<SENDERID>&message;=<MESSAGE>
     
 
-![SMS Settings]({{url_prefix}}/assets/old_images/erpnext/sms-setting2.jpg)
+![SMS Settings]({{docs_base_url}}/assets/old_images/erpnext/sms-setting2.jpg)
 
 > Note: the string up to the "?" is the SMS Gateway URL
 
@@ -35,6 +35,6 @@
 from your SMS Provider like username, password etc. These static values should
 be entered in the Static Parameters table.
 
-![SMS Setting]({{url_prefix}}/assets/old_images/erpnext/sms-settings1.png)
+![SMS Setting]({{docs_base_url}}/assets/old_images/erpnext/sms-settings1.png)
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/stock-reconciliation-for-non-serialized-item.md b/erpnext/docs/user/manual/en/setting-up/stock-reconciliation-for-non-serialized-item.md
similarity index 92%
rename from erpnext/docs/user/guides/setting-up/stock-reconciliation-for-non-serialized-item.md
rename to erpnext/docs/user/manual/en/setting-up/stock-reconciliation-for-non-serialized-item.md
index 955c83d..bd46bf1 100644
--- a/erpnext/docs/user/guides/setting-up/stock-reconciliation-for-non-serialized-item.md
+++ b/erpnext/docs/user/manual/en/setting-up/stock-reconciliation-for-non-serialized-item.md
@@ -27,17 +27,17 @@
 
 A predefined template of an spreadsheet file should be followed for importing item's stock levels and valuations. Open new Stock Reconciliation form to see download option.
 
-<img class="screenshot" alt="Stock Reconciliation" src="{{url_prefix}}/assets/img/setup/stock-recon-1.png">
+<img class="screenshot" alt="Stock Reconciliation" src="{{docs_base_url}}/assets/img/setup/stock-recon-1.png">
 
 #### Step 2: Enter Data in csv file.
 
-![Stock Reco Data]({{url_prefix}}/assets/old_images/erpnext/stock-reco-data.png)
+![Stock Reco Data]({{docs_base_url}}/assets/old_images/erpnext/stock-reco-data.png)
 
 The csv format is case-sensitive. Do not edit the headers which are preset in the template. In the Item Code and Warehouse column, enter exact Item Code and Warehouse as created in your ERPNext account. For quatity, enter stock level you wish to set for that item, in a specific warehouse.
 
 #### **Step 3: Upload file and Enter Values in Stock Reconciliation Form
 
-<img class="screenshot" alt="Stock Reconciliation" src="{{url_prefix}}/assets/img/setup/stock-recon-2.png">
+<img class="screenshot" alt="Stock Reconciliation" src="{{docs_base_url}}/assets/img/setup/stock-recon-2.png">
 
 **Posting Date**
 
@@ -59,11 +59,11 @@
 
 #### Step 4: Review the reconciliation data
 
-![Stock Reco Review]({{url_prefix}}/assets/old_images/erpnext/stock-reco-upload.png)
+![Stock Reco Review]({{docs_base_url}}/assets/old_images/erpnext/stock-reco-upload.png)
 
 ### Stock Ledger Report
 
-![Stock Reco Ledger]({{url_prefix}}/assets/old_images/erpnext/stock-reco-ledger.png)
+![Stock Reco Ledger]({{docs_base_url}}/assets/old_images/erpnext/stock-reco-ledger.png)
 
 **How Stock Reconciliation Works**
 
diff --git a/erpnext/docs/user/guides/setting-up/territory.md b/erpnext/docs/user/manual/en/setting-up/territory.md
similarity index 80%
rename from erpnext/docs/user/guides/setting-up/territory.md
rename to erpnext/docs/user/manual/en/setting-up/territory.md
index 89f1d14..3a1abfd 100644
--- a/erpnext/docs/user/guides/setting-up/territory.md
+++ b/erpnext/docs/user/manual/en/setting-up/territory.md
@@ -5,6 +5,6 @@
 territory v/s what you had planned.
 You can also set different pricing for the same product sold across different territories.
 
-<img class="screenshot" alt="Territory Tree" src="{{url_prefix}}/assets/img/crm/territory-tree.png">
+<img class="screenshot" alt="Territory Tree" src="{{docs_base_url}}/assets/img/crm/territory-tree.png">
 
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/setting-up/third-party-backups.md b/erpnext/docs/user/manual/en/setting-up/third-party-backups.md
similarity index 84%
rename from erpnext/docs/user/guides/setting-up/third-party-backups.md
rename to erpnext/docs/user/manual/en/setting-up/third-party-backups.md
index a65c533..c4e74ca 100644
--- a/erpnext/docs/user/guides/setting-up/third-party-backups.md
+++ b/erpnext/docs/user/manual/en/setting-up/third-party-backups.md
@@ -9,7 +9,7 @@
 
 #### Figure 1: Manage Third Party Backup
 
-![Third Party Backups]({{url_prefix}}/assets/old_images/erpnext/third-party-backups.png)
+![Third Party Backups]({{docs_base_url}}/assets/old_images/erpnext/third-party-backups.png)
 
 On the Backup Manager page, enter the email addresses of those people whom you
 wish to notify about the upload status. Under the topic 'Sync with Dropbox',
@@ -22,11 +22,11 @@
 
 #### Figure 2: Allow Dropbox Access
 
-![Backup Manager]({{url_prefix}}/assets/old_images/erpnext/backup-manager.png)
+![Backup Manager]({{docs_base_url}}/assets/old_images/erpnext/backup-manager.png)
 
 You need to login to your dropbox account, with your user id and password.
 
-![Dropbox Access]({{url_prefix}}/assets/old_images/erpnext/dropbox-access.png)
+![Dropbox Access]({{docs_base_url}}/assets/old_images/erpnext/dropbox-access.png)
 
 ## Open Source Users
 
diff --git a/erpnext/docs/user/guides/setting-up/users-and-permissions/adding-users.md b/erpnext/docs/user/manual/en/setting-up/users-and-permissions/adding-users.md
similarity index 77%
rename from erpnext/docs/user/guides/setting-up/users-and-permissions/adding-users.md
rename to erpnext/docs/user/manual/en/setting-up/users-and-permissions/adding-users.md
index b7f9101..dfd9ea0 100644
--- a/erpnext/docs/user/guides/setting-up/users-and-permissions/adding-users.md
+++ b/erpnext/docs/user/manual/en/setting-up/users-and-permissions/adding-users.md
@@ -11,7 +11,7 @@
 
 ### 1. List of Users
 
-<img class="screenshot" src="{{url_prefix}}/assets/img/setup/users/user-1.png" alt="User List">
+<img class="screenshot" src="{{docs_base_url}}/assets/img/setup/users/user-1.png" alt="User List">
 
 
 To add a new user, click on "New"
@@ -30,19 +30,19 @@
 the user to have and save the document. To click on what permissions translate into roles, click on the role
 name.
 
-<img class="screenshot" src="{{url_prefix}}/assets/img/setup/users/user-2.png" alt="User Roles">
+<img class="screenshot" src="{{docs_base_url}}/assets/img/setup/users/user-2.png" alt="User Roles">
 
 ### 4. Setting Module Access
 
 Users will have access to all modules for which they have role based access. If you want to block certain modules for certain users, un-check the module from the list.
 
-<img class="screenshot" src="{{url_prefix}}/assets/img/setup/users/user-3.png" alt="User Block Module">
+<img class="screenshot" src="{{docs_base_url}}/assets/img/setup/users/user-3.png" alt="User Block Module">
 
 ### 5. Security Settings
 
 If you wish to give the user access to the system only between office hours,
 or during weekends, mention it under security settings.
 
-<img class="screenshot" src="{{url_prefix}}/assets/img/setup/users/user-4.png" alt="User Security">
+<img class="screenshot" src="{{docs_base_url}}/assets/img/setup/users/user-4.png" alt="User Security">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/users-and-permissions/index.md b/erpnext/docs/user/manual/en/setting-up/users-and-permissions/index.md
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/users-and-permissions/index.md
rename to erpnext/docs/user/manual/en/setting-up/users-and-permissions/index.md
diff --git a/erpnext/docs/user/guides/setting-up/users-and-permissions/index.txt b/erpnext/docs/user/manual/en/setting-up/users-and-permissions/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/setting-up/users-and-permissions/index.txt
rename to erpnext/docs/user/manual/en/setting-up/users-and-permissions/index.txt
diff --git a/erpnext/docs/user/guides/setting-up/users-and-permissions/role-based-permissions.md b/erpnext/docs/user/manual/en/setting-up/users-and-permissions/role-based-permissions.md
similarity index 80%
rename from erpnext/docs/user/guides/setting-up/users-and-permissions/role-based-permissions.md
rename to erpnext/docs/user/manual/en/setting-up/users-and-permissions/role-based-permissions.md
index 8714488..9a96b17 100644
--- a/erpnext/docs/user/guides/setting-up/users-and-permissions/role-based-permissions.md
+++ b/erpnext/docs/user/manual/en/setting-up/users-and-permissions/role-based-permissions.md
@@ -5,7 +5,7 @@
 To start with, go to:
 > Setup > Permissions > Role Permissions Manager
 
-<img alt="Manage Read, Write, Create, Submit, Amend access using the Role Permissions Manager" class="screenshot" src="{{url_prefix}}/assets/img/users-and-permissions/setting-up-permissions-leave-application.png">
+<img alt="Manage Read, Write, Create, Submit, Amend access using the Role Permissions Manager" class="screenshot" src="{{docs_base_url}}/assets/img/users-and-permissions/setting-up-permissions-leave-application.png">
 
 Permissions are applied on a combination of:
 
@@ -28,7 +28,7 @@
 	If enabled, a user with that role will be able to access only specific Documents for that Document Type. Such specific Document access is defined in the list of User Permissions. Additionally, User Permissions defined for other Document Types also get applied if they are related to the current Document Type through Link Fields.
 
 	To set, User Permissions go to:
-    > Setup > Permissions > [User Permissions Manager]({{url_prefix}}/user/guides/setting-up/users-and-permissions/user-permissions.html)
+    > Setup > Permissions > [User Permissions Manager]({{docs_base_url}}/user/guides/setting-up/users-and-permissions/user-permissions.html)
 
 ---
 
@@ -38,37 +38,37 @@
 
 Leave Application is a good **example** that encompasses all areas of Permission System.
 
-<img class="screenshot" alt="Leave Application Form should be created by an Employee, and approved by Leave Approver or HR User" src="{{url_prefix}}/assets/img/users-and-permissions/setting-up-permissions-leave-application-form.png">
+<img class="screenshot" alt="Leave Application Form should be created by an Employee, and approved by Leave Approver or HR User" src="{{docs_base_url}}/assets/img/users-and-permissions/setting-up-permissions-leave-application-form.png">
 
    1. **It should be created by an Employee.**
      For this, Employee Role should be given Read, Write, Create permissions.
 
-<img class="screenshot" alt="Giving Read, Write and Create Permissions to Employee for Leave Application"  src="{{url_prefix}}/assets/img/users-and-permissions/setting-up-permissions-employee-role.png">
+<img class="screenshot" alt="Giving Read, Write and Create Permissions to Employee for Leave Application"  src="{{docs_base_url}}/assets/img/users-and-permissions/setting-up-permissions-employee-role.png">
 
    1. **An Employee should only be able to access his/her Leave Application.**
      Hence, Apply User Permissions should be enabled for Employee Role, and a User Permission record should be created for each User Employee combination. (This effort is reduced for Employee Document Type, by programmatically creating User Permission records.)
 
-<img class="screenshot" alt="Limiting access to Leave Applications for a user with Employee Role via User Permissions Manager" src="{{url_prefix}}/assets/old_images/erpnext/setting-up-permissions-employee-user-permissions.png">
+<img class="screenshot" alt="Limiting access to Leave Applications for a user with Employee Role via User Permissions Manager" src="{{docs_base_url}}/assets/old_images/erpnext/setting-up-permissions-employee-user-permissions.png">
 
    1. **HR Manager should be able to see all Leave Applications.**
      Create a Permission Rule for HR Manager at Level 0, with Read permissions. Apply User Permissions should be disabled.
 
-<img class="screenshot" alt="Giving Submit and Cancel permissions to HR Manager for Leave Applications. 'Apply User Permissions' is unchecked to give full access." src="{{url_prefix}}/assets/img/users-and-permissions/setting-up-permissions-hr-manager-role.png">
+<img class="screenshot" alt="Giving Submit and Cancel permissions to HR Manager for Leave Applications. 'Apply User Permissions' is unchecked to give full access." src="{{docs_base_url}}/assets/img/users-and-permissions/setting-up-permissions-hr-manager-role.png">
 
    2. **Leave Approver should be able to see and update Leave Applications applicable to him/her.**
      Leave Approver is given Read and Write access at Level 0, with Apply User Permissions enabled. Relevant Employee Documents should be enlisted in the User Permissions of Leave Approvers. (This effort is reduced for Leave Approvers mentioned in Employee Documents, by programmatically creating User Permission records.)
 
-<img class="screenshot" alt="Giving Read, Write and Submit permissions to Leave Approver for Leave Applications.'Apply User Permissions' is checked to limit access based on Employee." src="{{url_prefix}}/assets/img/users-and-permissions/setting-up-permissions-leave-approver-role.png">
+<img class="screenshot" alt="Giving Read, Write and Submit permissions to Leave Approver for Leave Applications.'Apply User Permissions' is checked to limit access based on Employee." src="{{docs_base_url}}/assets/img/users-and-permissions/setting-up-permissions-leave-approver-role.png">
 
    3. **It should be Approved / Rejected only by HR User or Leave Approver.**
      The Status field of Leave Application is set at Level 1. HR User and Leave Approver are given Read and Write permissions for Level 1, while everyone else (All) are given Read permission for Level 1.
 
-<img class="screenshot" alt="Limiting read access for a set of fields to certain Roles" src="{{url_prefix}}/assets/old_images/erpnext/setting-up-permissions-level-1.png">
+<img class="screenshot" alt="Limiting read access for a set of fields to certain Roles" src="{{docs_base_url}}/assets/old_images/erpnext/setting-up-permissions-level-1.png">
 
 
    4. **HR User should be able to delegate Leave Applications to his/her subordinates**
      HR User is given the right to Set User Permissions. A User with HR User role would be able to defined User Permissions on Leave Application for other users.
 
-<img class="screenshot" alt="Let HR User delegate access to Leave Applications by checking 'Set User Permissions'. This will allow HR User to access User Permissions Manager for 'Leave Application'" src="{{url_prefix}}/assets/img/users-and-permissions/setting-up-permissions-hr-user-role.png">
+<img class="screenshot" alt="Let HR User delegate access to Leave Applications by checking 'Set User Permissions'. This will allow HR User to access User Permissions Manager for 'Leave Application'" src="{{docs_base_url}}/assets/img/users-and-permissions/setting-up-permissions-hr-user-role.png">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/users-and-permissions/sharing.md b/erpnext/docs/user/manual/en/setting-up/users-and-permissions/sharing.md
similarity index 74%
rename from erpnext/docs/user/guides/setting-up/users-and-permissions/sharing.md
rename to erpnext/docs/user/manual/en/setting-up/users-and-permissions/sharing.md
index 471efc1..a939e65 100644
--- a/erpnext/docs/user/guides/setting-up/users-and-permissions/sharing.md
+++ b/erpnext/docs/user/manual/en/setting-up/users-and-permissions/sharing.md
@@ -4,6 +4,6 @@
 
 To share a document, open the document, click on the "+" icon under sharing and select the user
 
-<img class="screenshot" src="{{url_prefix}}/assets/img/setup/users/share.gif">
+<img class="screenshot" src="{{docs_base_url}}/assets/img/setup/users/share.gif">
 
 {next}
diff --git a/erpnext/docs/user/guides/setting-up/users-and-permissions/user-permissions.md b/erpnext/docs/user/manual/en/setting-up/users-and-permissions/user-permissions.md
similarity index 80%
rename from erpnext/docs/user/guides/setting-up/users-and-permissions/user-permissions.md
rename to erpnext/docs/user/manual/en/setting-up/users-and-permissions/user-permissions.md
index 2e2220a..c1cefc6 100644
--- a/erpnext/docs/user/guides/setting-up/users-and-permissions/user-permissions.md
+++ b/erpnext/docs/user/manual/en/setting-up/users-and-permissions/user-permissions.md
@@ -8,7 +8,7 @@
 > Setup > Permissions > User Permissions Manager
 
 <figure>
-	<img src="{{url_prefix}}/assets/img/users-and-permissions/user-permissions-company.png"
+	<img src="{{docs_base_url}}/assets/img/users-and-permissions/user-permissions-company.png"
 		class="img-responsive" alt="User Permissions Manager">
 	<figcaption>User Permissions Manager displaying how users can access only a specific Company.</figcaption>
 </figure>
@@ -19,21 +19,21 @@
 
   1. We add a User Permissions row for Company.
 	<figure>
-		<img src="{{url_prefix}}/assets/img/users-and-permissions/user-permission-user-limited-by-company.png"
+		<img src="{{docs_base_url}}/assets/img/users-and-permissions/user-permission-user-limited-by-company.png"
 			class="img-responsive" alt="User Permissions For Company">
 		<figcaption>Add User Permissions row for a combination of User 'aromn@example.com' and Company 'Wind Power LLC'.</figcaption>
 	</figure>
 
   1. Also Role "All" has only Read permission for Company, with 'Apply User Permissions' checked.
 	<figure>
-		<img src="{{url_prefix}}/assets/img/users-and-permissions/user-permissions-company-role-all.png"
+		<img src="{{docs_base_url}}/assets/img/users-and-permissions/user-permissions-company-role-all.png"
 			class="img-responsive" alt="Role Permissions for All on Company">
 		<figcaption>Read Permission with Apply User Permissions checked for DocType Company.</figcaption>
 	</figure>
 
   1. The combined effect of the above two rules lead to User 'aromn@example.com' having only Read access to Company 'Wind Power LLC'.
 	<figure>
-		<img src="{{url_prefix}}/assets/img/users-and-permissions/user-permissions-company-wind-power-llc.png"
+		<img src="{{docs_base_url}}/assets/img/users-and-permissions/user-permissions-company-wind-power-llc.png"
 			class="img-responsive" alt="Effect of Role and User Permissions on Company">
 		<figcaption>Access is limited to Company 'Wind Power LLC'.</figcaption>
 	</figure>
@@ -41,29 +41,29 @@
   1. We want this User Permission on Company to get applied on other documents like Quotation, Sales Order, etc.
 These forms have a **Link Field based on Company**. As a result, User Permissions on Company also get applied on these documents, which leads to User 'aromn@example.com' to acces these documents having Company 'Wind Power LLC'.
 	<figure>
-		<img src="{{url_prefix}}/assets/img/users-and-permissions/user-permissions-quotation-sales-user.png"
+		<img src="{{docs_base_url}}/assets/img/users-and-permissions/user-permissions-quotation-sales-user.png"
 			class="img-responsive" alt="Sales User Role Permissions for Quotation">
 		<figcaption>Users with Sales User Role can Read, Write, Create, Submit and Cancel Quotations based on their User Permissions, since 'Apply User Permissions' is checked.</figcaption>
 	</figure>
 	<figure>
-		<img src="{{url_prefix}}/assets/old_images/erpnext/user-permissions-quotation-list.png"
+		<img src="{{docs_base_url}}/assets/old_images/erpnext/user-permissions-quotation-list.png"
 			class="img-responsive" alt="Quotation List limited to results for Company 'Wind Power LLC'">
 		<figcaption>Quotation List is limited to results for Company 'Wind Power LLC' for User 'aromn@example.com'.</figcaption>
 	</figure>
 
   1. User Permissions get applied automatically based on Link Fields, just like how it worked for Quotation. But, Lead Form has 4 Link fields: Territory, Company, Lead Owner and Next Contact By. Say, you want Leads to limit access to Users based only on Territory, even though you have defined User Permissions for DocTypes User, Territory and Company. You can do this by setting 'Ignore User Permissions' for Link fields: Company, Lead Owner and Next Contact By.
 	<figure>
-		<img src="{{url_prefix}}/assets/img/users-and-permissions/user-permissions-lead-role-permissions.png"
+		<img src="{{docs_base_url}}/assets/img/users-and-permissions/user-permissions-lead-role-permissions.png"
 			class="img-responsive" alt="Role Permissions on Lead for Sales User Role">
 		<figcaption>Sales User can Read, Write and Create Leads limited by User Permissions.</figcaption>
 	</figure>
 	<figure>
-		<img src="{{url_prefix}}/assets/img/users-and-permissions/user-permissions-ignore-user-permissions.png"
+		<img src="{{docs_base_url}}/assets/img/users-and-permissions/user-permissions-ignore-user-permissions.png"
 			class="img-responsive" alt="Set Ingore User Permissions from Setup > Customize > Customize Form">
 		<figcaption>Check 'Ingore User Permissions' for Company, Lead Owner and Next Contact By fields using Setup > Customize > Customize Form for Lead.</figcaption>
 	</figure>
 	<figure>
-		<img src="{{url_prefix}}/assets/old_images/erpnext/user-permissions-lead-based-on-territory.png"
+		<img src="{{docs_base_url}}/assets/old_images/erpnext/user-permissions-lead-based-on-territory.png"
 			class="img-responsive" alt="Lead List is limited to records with Territory 'United States'">
 		<figcaption>Due to the effect of the above combination, User 'aromn@example.com' can only access Leads with Territory 'United States'.</figcaption>
 	</figure>
diff --git a/erpnext/docs/user/guides/setting-up/workflows.md b/erpnext/docs/user/manual/en/setting-up/workflows.md
similarity index 79%
rename from erpnext/docs/user/guides/setting-up/workflows.md
rename to erpnext/docs/user/manual/en/setting-up/workflows.md
index 2608097..a4ddc38 100644
--- a/erpnext/docs/user/guides/setting-up/workflows.md
+++ b/erpnext/docs/user/manual/en/setting-up/workflows.md
@@ -11,7 +11,7 @@
 Manager, who is the approving authority, will either Approve or Reject this
 request. Accordingly,the user will get his Approved or Rejected status.
 
-![Workflow]({{url_prefix}}/assets/old_images/erpnext/workflow-leave-fl.jpg)
+![Workflow]({{docs_base_url}}/assets/old_images/erpnext/workflow-leave-fl.jpg)
 
 To make this Workflow and transition rules go to :
 
@@ -19,11 +19,11 @@
 
 #### Step 1: Enter the different states of Leave Approval Process.
 
-<img class="screenshot" alt="Workflow" src="{{url_prefix}}/assets/img/setup/workflow-1.png">
+<img class="screenshot" alt="Workflow" src="{{docs_base_url}}/assets/img/setup/workflow-1.png">
 
 #### Step 2: Enter Transition Rules.
 
-<img class="screenshot" alt="Workflow" src="{{url_prefix}}/assets/img/setup/workflow-2.png">
+<img class="screenshot" alt="Workflow" src="{{docs_base_url}}/assets/img/setup/workflow-2.png">
 
 #### Notes:
 
@@ -50,17 +50,17 @@
 When a Leave Application is submitted, the status on the right hand corner of
 the page shows as "Applied"
 
-![Workflow Employee LA]({{url_prefix}}/assets/old_images/erpnext/workflow-employee-la.png)
+![Workflow Employee LA]({{docs_base_url}}/assets/old_images/erpnext/workflow-employee-la.png)
 
 When the HR User logs in, he can either Approve or Reject. If approved the
 status on the right hand corner of the page shows as Approved. However, a blue
 band of information is displayed saying approval is pending by leave approver.
 
-![Leave Approver]({{url_prefix}}/assets/old_images/erpnext/workflow-hr-user-la.png)
+![Leave Approver]({{docs_base_url}}/assets/old_images/erpnext/workflow-hr-user-la.png)
 
 When the leave approver opens the Leave Application page, he should select the
 status and convert to Approved or Rejected.
 
-![Workflow Leave Approver]({{url_prefix}}/assets/old_images/erpnext/workflow-leave-approver-la.png)
+![Workflow Leave Approver]({{docs_base_url}}/assets/old_images/erpnext/workflow-leave-approver-la.png)
 
 {next}
diff --git a/erpnext/docs/user/guides/stock/accounting-of-inventory-stock/index.md b/erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/index.md
similarity index 92%
rename from erpnext/docs/user/guides/stock/accounting-of-inventory-stock/index.md
rename to erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/index.md
index 4907186..f98f511 100644
--- a/erpnext/docs/user/guides/stock/accounting-of-inventory-stock/index.md
+++ b/erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/index.md
@@ -19,7 +19,7 @@
 statement.
 
 To check accounting entries for a particular stock transaction, please check
-[examples]({{url_prefix}}/user/guides/stock/accounting-of-inventory-stock/perpetual-inventory.html)
+[examples]({{docs_base_url}}/user/guides/stock/accounting-of-inventory-stock/perpetual-inventory.html)
 
 #### **Advantages**
 
@@ -64,6 +64,6 @@
 
 If you are an existing user using Periodic Inventory and want to use Perpetual
 Inventory, you have to follow some steps to migrate. For details, check
-[Migration From Periodic Inventory]({{url_prefix}}/user/guides/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.html).
+[Migration From Periodic Inventory]({{docs_base_url}}/user/guides/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.html).
 
 {next}
diff --git a/erpnext/docs/user/guides/stock/accounting-of-inventory-stock/index.txt b/erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/stock/accounting-of-inventory-stock/index.txt
rename to erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/index.txt
diff --git a/erpnext/docs/user/guides/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md b/erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md
similarity index 95%
rename from erpnext/docs/user/guides/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md
rename to erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md
index c3d10ed..ffc5f40 100644
--- a/erpnext/docs/user/guides/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md
+++ b/erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md
@@ -20,7 +20,7 @@
 
 > Setup > Accounts Settings > Make Accounting Entry For Every Stock Movement
 
-![Activation]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-1.png)  
+![Activation]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-1.png)  
   
 
   * Create Stock Entry (Material Transfer) to transfer available stock from existing warehouse to new warehouse. As stock will be available in the new warehouse, you should select the new warehouse for all the future transactions.
diff --git a/erpnext/docs/user/guides/stock/accounting-of-inventory-stock/perpetual-inventory.md b/erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/perpetual-inventory.md
similarity index 86%
rename from erpnext/docs/user/guides/stock/accounting-of-inventory-stock/perpetual-inventory.md
rename to erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/perpetual-inventory.md
index ee62942..fbe880f 100644
--- a/erpnext/docs/user/guides/stock/accounting-of-inventory-stock/perpetual-inventory.md
+++ b/erpnext/docs/user/manual/en/stock/accounting-of-inventory-stock/perpetual-inventory.md
@@ -143,11 +143,11 @@
 <p><strong>Stock Ledger</strong>
 </p>
 
-![pr<em>stock</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-2.png)
+![pr<em>stock</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-2.png)
 
 **General Ledger**
 
-![pr<em>general</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-3.png)
+![pr<em>general</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-3.png)
 
 As stock balance increases through Purchase Receipt, "Store" and "Fixed Asset
 Warehouse" accounts are debited and a temporary account "Stock Receipt But Not
@@ -162,7 +162,7 @@
 
 **General Ledger**
 
-![pi<em>general</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-4.png)
+![pi<em>general</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-4.png)
 
 Here "Stock Received But Not Billed" account is debited and nullified the
 effect of Purchase Receipt.
@@ -220,11 +220,11 @@
 
 **Stock Ledger**
 
-![dn<em>stock</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-5.png)
+![dn<em>stock</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-5.png)
 
 **General Ledger**
 
-![dn<em>general</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-6.png)
+![dn<em>general</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-6.png)
 
 As item is delivered from "Stores" warehouse, "Stores" account is credited and
 equal amount is debited to the expense account "Cost of Goods Sold". The
@@ -254,11 +254,11 @@
 
 **Stock Ledger**
 
-![si<em>stock</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-7.png)
+![si<em>stock</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-7.png)
 
 **General Ledger**
 
-![si<em>general</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-8.png)
+![si<em>general</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-8.png)
 
 Here, apart from normal account entries for invoice, "Stores" and "Cost of
 Goods Sold" accounts are also affected based on the valuation amount.
@@ -292,11 +292,11 @@
 
 **Stock Ledger**
 
-![mr<em>stock</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-9.png)
+![mr<em>stock</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-9.png)
 
 **General Ledger**
 
-![mr<em>stock</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-10.png)
+![mr<em>stock</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-10.png)
 
 * * *
 
@@ -327,11 +327,11 @@
 
 **Stock Ledger**
 
-![mi<em>stock</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-11.png)
+![mi<em>stock</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-11.png)
 
 **General Ledger**
 
-![mi<em>stock</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-12.png)
+![mi<em>stock</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-12.png)
 
 * * *
 
@@ -364,8 +364,8 @@
 
 **Stock Ledger**
 
-![mtn<em>stock</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-13.png)
+![mtn<em>stock</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-13.png)
 
 **General Ledger**
 
-![mtn<em>general</em>ledger]({{url_prefix}}/assets/old_images/erpnext/accounting-for-stock-14.png)
\ No newline at end of file
+![mtn<em>general</em>ledger]({{docs_base_url}}/assets/old_images/erpnext/accounting-for-stock-14.png)
\ No newline at end of file
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
new file mode 100644
index 0000000..bfee143
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/allow-over-delivery-billing-against-sales-order-upto-certain-limit.md
@@ -0,0 +1,15 @@
+<h1>Allow over delivery / billing against Sales Order upto certain limit</h1>
+
+<h1>Allow over delivery / billing against Sales Order upto certain limit</h1>
+
+To setup over delivery / receipt / billing against a Sales / Purchase Order upto certain limit:
+
+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)
+
+
+<!-- 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
new file mode 100644
index 0000000..e95b113
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/auto-creation-of-material-request.md
@@ -0,0 +1,25 @@
+<h1>Auto Creation of Material Request</h1>
+
+<h1>Auto Creation of Material Request</h1>
+
+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.
+
+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)
+
+You can have Material Request automatically created for items whose stock level reaches re-order level. You can enable this feature from:
+
+`Stock > Setup > Stock Settings`
+
+![Item Reorder Stock Setting]({{docs_base_url}}/assets/img/articles/$SGrab_392.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.
+
+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:
+
+**An error occurred for certain Items while creating Material Requests based on Re-order level.
+Date 01-04-2015 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.
+<!-- 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
new file mode 100644
index 0000000..6115ed5
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/creating-depreciation-for-item.html
@@ -0,0 +1,27 @@
+<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/index.md b/erpnext/docs/user/manual/en/stock/articles/index.md
new file mode 100644
index 0000000..4e1be28
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/index.md
@@ -0,0 +1 @@
+{content}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/stock/articles/index.txt b/erpnext/docs/user/manual/en/stock/articles/index.txt
new file mode 100644
index 0000000..fc039b1
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/index.txt
@@ -0,0 +1,15 @@
+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
+manage-rejected-finished-goods-items
+managing-assets
+managing-batch-wise-inventory
+managing-fractions-in-uom
+opening-stock-balance-entry-for-the-serialized-and-batch-item
+repack-entry
+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
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/is-stock-item-field-frozen-in-item-master.md
new file mode 100644
index 0000000..a012827
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/is-stock-item-field-frozen-in-item-master.md
@@ -0,0 +1,19 @@
+<h1>Is Stock Item field Frozen in the Item master</h1>
+
+<h1>Is Stock Item field Frozen in the Item master</h1>
+
+In the item master, you might witness values in the following fields be frozen.
+
+1. Is Stock Item
+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)
+
+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.
+
+For the serialized item, since its stock level is calculated based on count of available Serial Nos., setting Item as non-serialized mid-way will break the sync, and item's stock level shown in the report will not be accurate, hence Has Serial No. field is froze.
+
+To make these fields editable once again, you should delete all the stock transactions made for this item. For the Serialized and Batch Item, you should also delete Serial No. and Batch No. record for this item.
+
+<!-- markdown -->
\ No newline at end of file
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
new file mode 100644
index 0000000..9bb0103
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/manage-rejected-finished-goods-items.md
@@ -0,0 +1,32 @@
+<h1>Manage Rejected Finished Goods Items</h1>
+
+<h1>Manage Rejected Finished Goods Items</h1>
+
+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.
+
+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
+
+`Stock > Stock Entry > New`
+
+####Entry Purpose
+
+Purpose = Material Transfer
+
+####Warehouse
+
+Source Warehouse = Finished Goods warehouse
+Target Warehouse = Rejected items warehouse
+
+####Items
+
+Select item which failed quality test, and enter total rejected items as Qty.
+
+####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
new file mode 100644
index 0000000..5032dcd
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/managing-assets.md
@@ -0,0 +1,24 @@
+<h1>Managing Assets</h1>
+
+<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 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.
+
+####Fixed Asset Master
+
+While creating Item Code for the fixed asset item, you should updated field "Is Fixed Asset" as "Yes".
+
+![Fixed Asset Item]({{docs_base_url}}/assets/img/articles/$SGrab_383.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.
+
+####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.
+
+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.
+<!-- 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
new file mode 100644
index 0000000..23cd46d
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/managing-batch-wise-inventory.html
@@ -0,0 +1,5 @@
+<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-fractions-in-uom.md b/erpnext/docs/user/manual/en/stock/articles/managing-fractions-in-uom.md
new file mode 100644
index 0000000..75acd38
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/managing-fractions-in-uom.md
@@ -0,0 +1,34 @@
+<h1>Managing Fractions in UoM</h1>
+
+<h1>Managing Fractions in UoM</h1>
+
+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.
+
+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.
+
+####UoM List
+
+For UoM list, go to:
+
+`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.
+
+####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.
+
+![UoM Whole No]({{docs_base_url}}/assets/img/articles/$SGrab_390.png)
+
+####While Creating Entry
+
+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:
+
+`Quantity cannot be a fraction at row #`
+
+![UoM Fraction Error]({{docs_base_url}}/assets/img/articles/$SGrab_389.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
new file mode 100644
index 0000000..5251a8e
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/opening-stock-balance-entry-for-the-serialized-and-batch-item.md
@@ -0,0 +1,63 @@
+<h1>Opening Stock Balance Entry for the Serialized and Batch Item</h1>
+
+<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 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).
+
+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 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.
+
+Let's check steps for create opening stock balance entry for the Serialized and Batch item.
+
+#### Step 1: New Stock Entry
+
+`Stock > Stock Entry > New`
+
+#### Step 2: Select Purpose
+
+Stock Entry Purpose should be updated as `Material Receipt`.
+
+#### Step 3: Update Posting Date
+
+Posting Date should be date on which you wish to update opening balance for an item.
+
+#### Step 4: Update Target Warehouse
+
+Target Warehouse will be one in which opening balance of an item will be updated.
+
+#### Step 5: Select Items
+
+Select Items in the Stock Entry table.
+
+#### 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.
+
+![Item Serial No. Prefix]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-19 at 5.13.50 pm.png)
+
+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:
+
+`Stock > Setup > Batch > New`
+
+[Click here to learn how Batchwise inventory is managed in ERPNext](https://erpnext.com/user-guide/stock/batchwise-inventory).
+
+#### 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.
+
+#### 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).
+
+![Difference Account]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-19 at 5.20.52 pm.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.
+
+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
new file mode 100644
index 0000000..59bf983
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/repack-entry.md
@@ -0,0 +1,35 @@
+<h1>Repack Entry</h1>
+
+<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. 
+
+Notes:
+1. Separate purchase and repacked Items must be made.
+2. Repack entry can be made with or without BOM (Bill of Material).
+
+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:
+
+#### 1. New Stock Entry
+
+`Stock > Documents > Stock Entry > New Stock Entry`
+
+#### 2. Enter Items
+
+Select Purpose as 'Repack Entry'.
+
+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.
+
+![New STE]({{docs_base_url}}/assets/img/articles/Selection_071.png)
+
+#### 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.
+
+![New STE]({{docs_base_url}}/assets/img/articles/Selection_072.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
new file mode 100644
index 0000000..c4e8774
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/serial-no-naming.md
@@ -0,0 +1,41 @@
+<h1>Serial No. Naming</h1>
+
+<h1>Serial No. Naming</h1>
+
+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".
+
+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 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)
+
+Generated Serial numbers will be updated for each item.
+
+![Serial Nos]({{docs_base_url}}/assets/img/articles/Selection_062.png)
+
+###2. Serializing Manufacturing Item
+
+To Serialize Manufacturing Item, you can define Series for Serial No. Generation in the Item master itself. Following that series, system will create Serial Nos. for Item when its Production entry is made.
+
+####2.1 Serial No. Series
+
+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)
+
+####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)
+
+<!-- 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
new file mode 100644
index 0000000..26b6346
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/stock-entry-purpose.md
@@ -0,0 +1,53 @@
+<h1>Stock Entry Purpose</h1>
+
+<h1>Stock Entry Purpose</h1>
+
+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
+
+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]({{docs_base_url}}/assets/img/articles/Selection_440.png)
+
+#### 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]({{docs_base_url}}/assets/img/articles/Selection_442.png)
+
+#### 3.Purpose = Material Transfer
+
+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.
+
+![Material Transfer]({{docs_base_url}}/assets/img/articles/Selection_443.png)
+ 
+#### 4.Purpose = 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)
+
+![Manufacture]({{docs_base_url}}/assets/img/articles/Selection_444.png) 
+
+#### 5.Purpose = Repack
+
+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)
+
+#### 6.Purpose = Subcontract
+
+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)
+
+![Subcontract]({{docs_base_url}}/assets/img/articles/Selection_445.png)
+
+#### 6.Purpose = Sales Return
+
+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)
+
+![Sales Return]({{docs_base_url}}/assets/img/articles/Selection_446.png)
+
+#### 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
new file mode 100644
index 0000000..fa92612
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/stock-level-report.md
@@ -0,0 +1,41 @@
+<h1>Stock Level Report</h1>
+
+<h1>Stock Level Report</h1>
+
+Stock Level report list stock item's quantity available in a particular warehouse.
+
+There are multiple reports available you can check for item's stock level.
+
+####Stock Projected Quantity Report
+
+You can access this report from `Stock > Main Report > Stock Projected Quantity`
+
+This report list item wise - warehouse wise stock level of an item considering all the stock transactions. With Actual Quantity of an item, it also provide other details like:
+
+1. Actual Qty: Quantity available in the warehouse.
+2. Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.
+3. Requested Qty: Quantity requested for purchase, but not ordered.
+4. Ordered Qty: Quantity ordered for purchase, but not received.
+5. Reserved Qty: Quantity ordered for sale, but not delivered.
+6. Project Qty: Project Quantity is calculated as
+
+<div class="well">Projected Qty = Actual Qty + Planned Qty + Requested Qty + Ordered Qty - Reserved Qty</div>
+
+The projected inventory is used by the planning system to monitor the reorder point and to determine the reorder quantity. The projected Quantity is used by the planning engine to monitor the safety stock levels. These levels are maintained to serve unexpected demands.
+
+Having a tight control of the projected inventory is crucial to determine shortages and to calculate the right order quantity.
+
+####Stock Balance Report
+
+Stock Ledger report helps you check stock balance of an item on a given date. 
+
+You can access this report from
+
+`Stock > Main Report > Stock Balance`
+
+This allows you to go back in time, and check what was stock level of an item in a particular warehouse in the near past. 
+
+With item's stock levels, you will also get their valuation details in this report.
+
+Based on the date filters, this report provides item's Opening Stock on From Date, and Closing Stock on To From. It will also list the In Quantity and Out Quantity for an item between the date range.
+<!-- 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
new file mode 100644
index 0000000..5b0d99a
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/track-items-using-barcode.md
@@ -0,0 +1,20 @@
+<h1>Track items using Barcode</h1>
+
+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.
+
+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)
+
+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".
+
+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)
+
+
+Once you have updated barcode field in item master, you can fetch items using barcode in Delivery Note, Sales Invoice and Purchase Receipt document.
+
+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)
+
+
+<!-- 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
new file mode 100644
index 0000000..eeb5cdf
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/articles/using-batch-feature-in-stock-entry.md
@@ -0,0 +1,13 @@
+<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/guides/stock/batch.md b/erpnext/docs/user/manual/en/stock/batch.md
similarity index 93%
rename from erpnext/docs/user/guides/stock/batch.md
rename to erpnext/docs/user/manual/en/stock/batch.md
index 4cb7f06..e6a1253 100644
--- a/erpnext/docs/user/guides/stock/batch.md
+++ b/erpnext/docs/user/manual/en/stock/batch.md
@@ -16,7 +16,7 @@
 Hence eveytime there is Purchase Receipt or Production entry being made for a batch item, 
 you will first create its Batch No, and then select it in Purcase order or Production Entry.
 
-<img class="screenshot" alt="batch" src="{{url_prefix}}/assets/img/stock/batch.png">
+<img class="screenshot" alt="batch" src="{{docs_base_url}}/assets/img/stock/batch.png">
 
 > Note: In stock transactions, Batch IDs will be filtered based on Item Code, Warehouse, 
 Batch Expiry Date (compared with Posting date of a transaction) and Actual Qty in Warehouse. 
diff --git a/erpnext/docs/user/guides/stock/delivery-note.md b/erpnext/docs/user/manual/en/stock/delivery-note.md
similarity index 88%
rename from erpnext/docs/user/guides/stock/delivery-note.md
rename to erpnext/docs/user/manual/en/stock/delivery-note.md
index 1cdf41f..f7e7f1e 100644
--- a/erpnext/docs/user/guides/stock/delivery-note.md
+++ b/erpnext/docs/user/manual/en/stock/delivery-note.md
@@ -13,7 +13,7 @@
 or from a “Submitted” Sales Order (that is not already shipped) by clicking on
 “Make Delivery Note”.
 
-<img class="screenshot" alt="Delivery Note" src="{{url_prefix}}/assets/img/stock/delivery-note.png">
+<img class="screenshot" alt="Delivery Note" src="{{docs_base_url}}/assets/img/stock/delivery-note.png">
 
 You can also “fetch” the details from an unshipped Sales Order.
 
@@ -22,7 +22,7 @@
 
 ### Shipping Packets or Items with Product Bundle
 
-If you are shipping Items that have a [Product Bundle]({{url_prefix}}/user/guides/selling/setup/sales-bom.html), ERPNext will automatically
+If you are shipping Items that have a [Product Bundle]({{docs_base_url}}/user/guides/selling/setup/sales-bom.html), ERPNext will automatically
 create a “Packing List” table for you based on the sub-Items in that Item.
 
 If your Items are serialized, then for Product Bundle type of Items, you will have
diff --git a/erpnext/docs/user/guides/stock/index.md b/erpnext/docs/user/manual/en/stock/index.md
similarity index 100%
rename from erpnext/docs/user/guides/stock/index.md
rename to erpnext/docs/user/manual/en/stock/index.md
diff --git a/erpnext/docs/user/guides/stock/index.txt b/erpnext/docs/user/manual/en/stock/index.txt
similarity index 69%
rename from erpnext/docs/user/guides/stock/index.txt
rename to erpnext/docs/user/manual/en/stock/index.txt
index 75e9cbf..cd36ac6 100644
--- a/erpnext/docs/user/guides/stock/index.txt
+++ b/erpnext/docs/user/manual/en/stock/index.txt
@@ -12,4 +12,9 @@
 tools
 setup
 sales-return
-purchase-return
\ No newline at end of file
+purchase-return
+articles
+item-price
+item-valuation-fifo-and-moving-average
+opening-stock
+stock-how-to
diff --git a/erpnext/docs/user/manual/en/stock/installation-note.md b/erpnext/docs/user/manual/en/stock/installation-note.md
new file mode 100644
index 0000000..0519652
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/installation-note.md
@@ -0,0 +1,5 @@
+You can use installation note to record the instalation of a product having a serial number.
+
+<img class="screenshot" alt="Installation Note" src="{{docs_base_url}}/assets/img/stock/installation-note.png">
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/selling/setup/item-price.md b/erpnext/docs/user/manual/en/stock/item-price.md
similarity index 83%
copy from erpnext/docs/user/guides/selling/setup/item-price.md
copy to erpnext/docs/user/manual/en/stock/item-price.md
index a235341..b877e8d 100644
--- a/erpnext/docs/user/guides/selling/setup/item-price.md
+++ b/erpnext/docs/user/manual/en/stock/item-price.md
@@ -14,7 +14,7 @@
 
 You can create multiple Price List in ERPNext to track Selling and Buying Price List of an item separtely. Also if item's selling prices id changing based on territory, or due to other criteria, you can create multiple selling Price List for it.
 
-![Item Price list]({{url_prefix}}/assets/old_images/erpnext/item-price-list.png)
+![Item Price list]({{docs_base_url}}/assets/old_images/erpnext/item-price-list.png)
 
 On selection of Price List, its currency and for selling or buying property will be fetched as well.
 
@@ -24,13 +24,13 @@
 
 Select item for which Item Price record is to be created. On selection of Item Code, Item Name and Description will be fetched as well.
 
-![Item Price Item]({{url_prefix}}/assets/old_images/erpnext/item-price-item.png)
+![Item Price Item]({{docs_base_url}}/assets/old_images/erpnext/item-price-item.png)
 
 Step 3: Enter Rate
 
 Enter selling/buying rate of an item in Price List currency.
 
-![Item Price Rate]({{url_prefix}}/assets/old_images/erpnext/item-price-rate.png)
+![Item Price Rate]({{docs_base_url}}/assets/old_images/erpnext/item-price-rate.png)
 
 Step 4: Save Item Price
 
diff --git a/erpnext/docs/user/guides/stock/item-valuation-fifo-and-moving-average.md b/erpnext/docs/user/manual/en/stock/item-valuation-fifo-and-moving-average.md
similarity index 95%
rename from erpnext/docs/user/guides/stock/item-valuation-fifo-and-moving-average.md
rename to erpnext/docs/user/manual/en/stock/item-valuation-fifo-and-moving-average.md
index 3cabe35..9344870 100644
--- a/erpnext/docs/user/guides/stock/item-valuation-fifo-and-moving-average.md
+++ b/erpnext/docs/user/manual/en/stock/item-valuation-fifo-and-moving-average.md
@@ -19,7 +19,7 @@
 
   * **FIFO (First In First Out):** In this system, ERPNext assumes that you will consume / sell those Items first which you bought first. For example, if you buy an Item at price X and then after a few days at price Y, whenever you sell your Item, ERPNext will reduce the quantity of the Item priced at X first and then Y.
 
-![FIFO]({{url_prefix}}/assets/old_images/erpnext/fifo.png)
+![FIFO]({{docs_base_url}}/assets/old_images/erpnext/fifo.png)
 
   * **Moving Average:** In this method, ERPNext assumes that the value of the item at any point is the average price of the units of that Item in stock. For example, if the value of an Item is X in a Warehouse with quantity Y and another quantity Y1 is added to the Warehouse at cost X1, the new value X2 would be:
 
diff --git a/erpnext/docs/user/guides/stock/item/index.md b/erpnext/docs/user/manual/en/stock/item/index.md
similarity index 84%
rename from erpnext/docs/user/guides/stock/item/index.md
rename to erpnext/docs/user/manual/en/stock/item/index.md
index 89ec5e5..4fe0aad 100644
--- a/erpnext/docs/user/guides/stock/item/index.md
+++ b/erpnext/docs/user/manual/en/stock/item/index.md
@@ -5,11 +5,11 @@
 ## Item Properties
 
   * **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]({{url_prefix}}/user/guides/stock/item/item-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]({{url_prefix}}/user/guides/stock/setup/item-group.html)
+  * **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_base_url}}/user/guides/stock/item/item-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]({{docs_base_url}}/user/guides/stock/setup/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.
-  * **Variant:** A Item Variant is a different version of a Item.To learn more about managing varaints see [Item Variants]({{url_prefix}}/user/guides/stock/item/item-variants.html)
+  * **Variant:** A Item Variant is a different version of a Item.To learn more about managing varaints see [Item Variants]({{docs_base_url}}/user/guides/stock/item/item-variants.html)
   
 ### Upload an Image
 
@@ -34,7 +34,7 @@
 
 > Important: Once you mark an item as serialized or batched or neither, you cannot change it after you have made any stock entry.
 
-  * [Discussion on Serialized Inventory]({{url_prefix}}/user/guides/setting-up/stock-reconciliation-for-non-serialized-item.html)  
+  * [Discussion on Serialized Inventory]({{docs_base_url}}/user/guides/setting-up/stock-reconciliation-for-non-serialized-item.html)  
 
 ### Re Ordering
 
@@ -50,7 +50,7 @@
 select “VAT 10%” in the first column, and set “0” as the tax rate in the
 second column.
 
-Go to [Setting Up Taxes]({{url_prefix}}/user/guides/setting-up/setting-up-taxes.html) to understand this topic in detail.
+Go to [Setting Up Taxes]({{docs_base_url}}/user/guides/setting-up/setting-up-taxes.html) to understand this topic in detail.
 
 ### Inspection
 
@@ -66,7 +66,7 @@
 
 ### Purchase Details
 
-![Purchase Details]({{url_prefix}}/assets/old_images/erpnext/item-purchase.png)
+![Purchase Details]({{docs_base_url}}/assets/old_images/erpnext/item-purchase.png)
 
 **Lead time days:** Lead time days are the number of days required for the Item to reach the warehouse.
 
@@ -76,7 +76,7 @@
 
 ### Sales Details
 
-![Sales Details]({{url_prefix}}/assets/old_images/erpnext/item-sales.png)
+![Sales Details]({{docs_base_url}}/assets/old_images/erpnext/item-sales.png)
 
 **Default Income Account:** Income account selected here will be fetched automatically in sales invoice for this item.
 
@@ -84,8 +84,8 @@
 
 ### Manufacturing And Website
 
-![Manufacturing]({{url_prefix}}/assets/old_images/erpnext/item-manufacturing-website.png)
+![Manufacturing]({{docs_base_url}}/assets/old_images/erpnext/item-manufacturing-website.png)
 
-Visit [Manufacturing]({{url_prefix}}/user/guides/manufacturing.html) and [Website ]({{url_prefix}}/user/guides/website.html)to understand these topics in detail.
+Visit [Manufacturing]({{docs_base_url}}/user/guides/manufacturing.html) and [Website ]({{docs_base_url}}/user/guides/website.html)to understand these topics in detail.
 
 {next}
diff --git a/erpnext/docs/user/manual/en/stock/item/index.txt b/erpnext/docs/user/manual/en/stock/item/index.txt
new file mode 100644
index 0000000..eadae6c
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/item/index.txt
@@ -0,0 +1,6 @@
+item-codification
+item-variants
+purchase-details.md
+reorder.md
+purchase-details.md
+reorder.md
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/stock/item/item-codification.md b/erpnext/docs/user/manual/en/stock/item/item-codification.md
similarity index 100%
rename from erpnext/docs/user/guides/stock/item/item-codification.md
rename to erpnext/docs/user/manual/en/stock/item/item-codification.md
diff --git a/erpnext/docs/user/guides/stock/item/item-variants.md b/erpnext/docs/user/manual/en/stock/item/item-variants.md
similarity index 63%
rename from erpnext/docs/user/guides/stock/item/item-variants.md
rename to erpnext/docs/user/manual/en/stock/item/item-variants.md
index 256a37e..c10addb 100644
--- a/erpnext/docs/user/guides/stock/item/item-variants.md
+++ b/erpnext/docs/user/manual/en/stock/item/item-variants.md
@@ -6,19 +6,19 @@
 
 * The Item shall then be referred as a 'Template'
 
-<img class="screenshot" alt="Has Variants" src="{{url_prefix}}/assets/img/stock/item-has-variants.png">
+<img class="screenshot" alt="Has Variants" src="{{docs_base_url}}/assets/img/stock/item-has-variants.png">
 
 On selecting 'Has Variants' a table shall appear. Specify the variant attributes for the Item in the table.
 In case the attribute has Numeric Values, you can specify the range and increment values here. 
 
-<img class="screenshot" alt="Valid Attributes" src="{{url_prefix}}/assets/img/stock/item-attributes.png">
+<img class="screenshot" alt="Valid Attributes" src="{{docs_base_url}}/assets/img/stock/item-attributes.png">
 
 > Note: You cannot make Transactions against a 'Template'
 
 To create 'Item Variants' against a 'Template' select 'Make Variants'
 
-<img class="screenshot" alt="Make Variants" src="{{url_prefix}}/assets/img/stock/make-variant.png">
+<img class="screenshot" alt="Make Variants" src="{{docs_base_url}}/assets/img/stock/make-variant.png">
 
-<img class="screenshot" alt="Make Variants" src="{{url_prefix}}/assets/img/stock/make-variant-1.png">
+<img class="screenshot" alt="Make Variants" src="{{docs_base_url}}/assets/img/stock/make-variant-1.png">
 
-To learn more about setting Attributes Master check [Item Attributes]({{url_prefix}}/user/guides/stock/setup/item-attribute.html)
+To learn more about setting Attributes Master check [Item Attributes]({{docs_base_url}}/user/guides/stock/setup/item-attribute.html)
diff --git a/erpnext/docs/user/guides/stock/item/purchase-details.md b/erpnext/docs/user/manual/en/stock/item/purchase-details.md
similarity index 89%
rename from erpnext/docs/user/guides/stock/item/purchase-details.md
rename to erpnext/docs/user/manual/en/stock/item/purchase-details.md
index 47f724c..5749178 100644
--- a/erpnext/docs/user/guides/stock/item/purchase-details.md
+++ b/erpnext/docs/user/manual/en/stock/item/purchase-details.md
@@ -7,7 +7,7 @@
 
 A warranty means a guarantee or a promise which provides assurance by one party to the other party which allows for a legal remedy if that promise is not true or followed. A warranty period is a time period in which a purchased product may be returned or exchanged.
 
-![Warranty]({{url_prefix}}/assets/old_images/erpnext/faq-warranty.png)
+![Warranty]({{docs_base_url}}/assets/old_images/erpnext/faq-warranty.png)
 
 # How To Name A Manufacturer Part Number?
 
@@ -17,6 +17,6 @@
 
 A manufacturer part number is a series of numbers and /or letters that has been given to a part by the manufacturer. The manufacturer part number belongs to the manufacturer and helps distinguish the part from other manufacturers. If two parts come from different manufacturers, they will have different MPNs. This allows businesses to identify which company made the part.
 
-![Part No]({{url_prefix}}/assets/old_images/erpnext/faq-manufacturer-part-no.png)
+![Part No]({{docs_base_url}}/assets/old_images/erpnext/faq-manufacturer-part-no.png)
 
 __For Example:__ A refrigerator will have different parts which will have manufacturer part number. Thus, when any part fails and you want to replace it, you can simply order that part based on its part number.
diff --git a/erpnext/docs/user/guides/stock/item/reorder.md b/erpnext/docs/user/manual/en/stock/item/reorder.md
similarity index 88%
rename from erpnext/docs/user/guides/stock/item/reorder.md
rename to erpnext/docs/user/manual/en/stock/item/reorder.md
index 34a079f..4537d95 100644
--- a/erpnext/docs/user/guides/stock/item/reorder.md
+++ b/erpnext/docs/user/manual/en/stock/item/reorder.md
@@ -8,7 +8,7 @@
 
 The Re-order level is the point at which stock on a particular item has diminished to a point where it needs to be replenished. To order based on Re-order level can avoid shortages. Re-order level can be determined based on the lead time and the average daily consumption.
 
-![Reorder Level]({{url_prefix}}/assets/old_images/erpnext/faq-reorder-level.png)
+![Reorder Level]({{docs_base_url}}/assets/old_images/erpnext/faq-reorder-level.png)
 
 __For example:__ You can set your reorder level of bath towels at 10. When there are only 10 towels remaining in stock, the system will either send a mail or take action depending upon what you have selected in global settings.
 
@@ -20,7 +20,7 @@
 
 Re-order quantity is the quantity to order, so that the sum of ordering cost and holding cost is at its minimum.The re-order quantity is based on the minimum order quantity specified by the supplier and many other factors.
 
-![Reorder Quantity]({{url_prefix}}/assets/old_images/erpnext/faq-reorder-qty.png)
+![Reorder Quantity]({{docs_base_url}}/assets/old_images/erpnext/faq-reorder-qty.png)
 
 __For example:__ If reorder level is 100 items, your reorder quantity may not necessarily be 100 items. The Reorder quantity can be greater than or equal to reorder level. It may depend upon lead time, discount, transportation and average daily consumption.
 
diff --git a/erpnext/docs/user/guides/stock/material-request.md b/erpnext/docs/user/manual/en/stock/material-request.md
similarity index 77%
rename from erpnext/docs/user/guides/stock/material-request.md
rename to erpnext/docs/user/manual/en/stock/material-request.md
index 69ce0ea..784778d 100644
--- a/erpnext/docs/user/guides/stock/material-request.md
+++ b/erpnext/docs/user/manual/en/stock/material-request.md
@@ -1,7 +1,7 @@
 A Material Request is a simple document identifying a requirement of a set of
 Items (products or services) for a particular reason.
 
-![Workflow]({{url_prefix}}/assets/old_images/erpnext/material-request-workflow.jpg)
+![Workflow]({{docs_base_url}}/assets/old_images/erpnext/material-request-workflow.jpg)
 
 To generate a Material Request manually go to:
 
@@ -9,14 +9,14 @@
 
 #### Creating Material Request 
 
-<img class="screenshot" alt="Material Request" src="{{url_prefix}}/assets/img/buying/material-request.png">
+<img class="screenshot" alt="Material Request" src="{{docs_base_url}}/assets/img/buying/material-request.png">
 
 A Material Request can be generated:
 
   * Automatically from a Sales Order.
   * Automatically when the Projected Quantity of an Item in stores reaches a particular level.
   * Automatically from your Bill of Materials if you use Production Plan to plan your manufacturing activities.
-  * If your Items are inventory items, you must also mention the Warehouse where you expect these Items to be delivered. This helps to keep track of the [Projected Quantity]({{url_prefix}}/user/guides/stock/projected-quantity.html) for this Item.
+  * If your Items are inventory items, you must also mention the Warehouse where you expect these Items to be delivered. This helps to keep track of the [Projected Quantity]({{docs_base_url}}/user/guides/stock/projected-quantity.html) for this Item.
 
 A Material Request can be of type:
 
diff --git a/erpnext/docs/user/guides/stock/opening-stock.md b/erpnext/docs/user/manual/en/stock/opening-stock.md
similarity index 91%
rename from erpnext/docs/user/guides/stock/opening-stock.md
rename to erpnext/docs/user/manual/en/stock/opening-stock.md
index ef285d2..463eef4 100644
--- a/erpnext/docs/user/guides/stock/opening-stock.md
+++ b/erpnext/docs/user/manual/en/stock/opening-stock.md
@@ -10,6 +10,6 @@
 
 If you are not making opening Stock Entry, you can select "Stock Adjustment" account in Difference/Expense Account field which is an expense account.
 
-To understand Opening Stock for serialzed Items visit [Stock Reconciliation]({{url_prefix}}/user/guides/setting-up/stock-reconciliation-for-non-serialized-item.html)
+To understand Opening Stock for serialzed Items visit [Stock Reconciliation]({{docs_base_url}}/user/guides/setting-up/stock-reconciliation-for-non-serialized-item.html)
 
 {next}
diff --git a/erpnext/docs/user/guides/stock/projected-quantity.md b/erpnext/docs/user/manual/en/stock/projected-quantity.md
similarity index 90%
rename from erpnext/docs/user/guides/stock/projected-quantity.md
rename to erpnext/docs/user/manual/en/stock/projected-quantity.md
index 796d427..9251a1b 100644
--- a/erpnext/docs/user/guides/stock/projected-quantity.md
+++ b/erpnext/docs/user/manual/en/stock/projected-quantity.md
@@ -11,7 +11,7 @@
 Having a tight control of the projected inventory is crucial to determine
 shortages and to calculate the right order quantity.
 
-![Projected Quantity Stock Report]({{url_prefix}}/assets/old_images/erpnext/projected-quantity-stock-report.png)
+![Projected Quantity Stock Report]({{docs_base_url}}/assets/old_images/erpnext/projected-quantity-stock-report.png)
 
 
 > Projected Qty = Actual Qty + Planned Qty + Requested Qty + Ordered Qty -
diff --git a/erpnext/docs/user/guides/stock/purchase-receipt.md b/erpnext/docs/user/manual/en/stock/purchase-receipt.md
similarity index 96%
rename from erpnext/docs/user/guides/stock/purchase-receipt.md
rename to erpnext/docs/user/manual/en/stock/purchase-receipt.md
index 68f29d4..0f43b58 100644
--- a/erpnext/docs/user/guides/stock/purchase-receipt.md
+++ b/erpnext/docs/user/manual/en/stock/purchase-receipt.md
@@ -10,7 +10,7 @@
 
 or from a “Submitted” Purchase Order, by clicking on “Make Purchase Receipt”.
 
-<img class="screenshot" alt="Purchase Receipt" src="{{url_prefix}}/assets/img/stock/purchase-receipt.png">
+<img class="screenshot" alt="Purchase Receipt" src="{{docs_base_url}}/assets/img/stock/purchase-receipt.png">
 
 ### Rejections
 
diff --git a/erpnext/docs/user/guides/stock/purchase-return.md b/erpnext/docs/user/manual/en/stock/purchase-return.md
similarity index 67%
rename from erpnext/docs/user/guides/stock/purchase-return.md
rename to erpnext/docs/user/manual/en/stock/purchase-return.md
index 5a924a2..328ed08 100644
--- a/erpnext/docs/user/guides/stock/purchase-return.md
+++ b/erpnext/docs/user/manual/en/stock/purchase-return.md
@@ -6,16 +6,16 @@
 
 First open the original Purchase Receipt, against which supplier delivered the items.
 
-<img class="screenshot" alt="Original Purchase Receipt" src="{{url_prefix}}/assets/img/stock/purchase-return-original-purchase-receipt.png">
+<img class="screenshot" alt="Original Purchase Receipt" src="{{docs_base_url}}/assets/img/stock/purchase-return-original-purchase-receipt.png">
 
 Then click on "Make Purchase Return", it will open a new Purchase Receipt with "Is Return" checked, items and taxes with negative amount.
 
-<img class="screenshot" alt="Return Against Purchase Receipt" src="{{url_prefix}}/assets/img/stock/purchase-return-against-purchase-receipt.png">
+<img class="screenshot" alt="Return Against Purchase Receipt" src="{{docs_base_url}}/assets/img/stock/purchase-return-against-purchase-receipt.png">
 
 On submission of Return Purchase Return, system will decrease item qty from the mentioned warehouse. To maintain correct stock valuation, stock balance will also go up according to the original purchase rate of the returned items.
 
-<img class="screenshot" alt="Return Stock Ledger" src="{{url_prefix}}/assets/img/stock/purchase-return-stock-ledger.png">
+<img class="screenshot" alt="Return Stock Ledger" src="{{docs_base_url}}/assets/img/stock/purchase-return-stock-ledger.png">
 
 If Perpetual Inventory enabled, system will also post accounting entry against warehouse account to sync warehouse account balance with stock balance as per Stock Ledger.
 
-<img class="screenshot" alt="Return Stock Ledger" src="{{url_prefix}}/assets/img/stock/purchase-return-general-ledger.png">
\ No newline at end of file
+<img class="screenshot" alt="Return Stock Ledger" src="{{docs_base_url}}/assets/img/stock/purchase-return-general-ledger.png">
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/stock/sales-return.md b/erpnext/docs/user/manual/en/stock/sales-return.md
similarity index 71%
rename from erpnext/docs/user/guides/stock/sales-return.md
rename to erpnext/docs/user/manual/en/stock/sales-return.md
index 15b8b11..1ce922d 100644
--- a/erpnext/docs/user/guides/stock/sales-return.md
+++ b/erpnext/docs/user/manual/en/stock/sales-return.md
@@ -6,22 +6,22 @@
 
 First open the original Delivery Note / Sales Invoice, against which customer returned the items.
 
-<img class="screenshot" alt="Original Delivery Note" src="{{url_prefix}}/assets/img/stock/sales-return-original-delivery-note.png">
+<img class="screenshot" alt="Original Delivery Note" src="{{docs_base_url}}/assets/img/stock/sales-return-original-delivery-note.png">
 
 Then click on "Make Sales Return", it will open a new Delivery Note with "Is Return" checked, items and taxes with negative amount.
 
-<img class="screenshot" alt="Return Against Delivery Note" src="{{url_prefix}}/assets/img/stock/sales-return-against-delivery-note.png">
+<img class="screenshot" alt="Return Against Delivery Note" src="{{docs_base_url}}/assets/img/stock/sales-return-against-delivery-note.png">
 
 You can also create the return entry against original Sales Invoice, to return stock along with credit note, check "Update Stock" option in Return Sales Invoice.
 
-<img class="screenshot" alt="Return Against Sales Invoice" src="{{url_prefix}}/assets/img/stock/sales-return-against-sales-invoice.png">
+<img class="screenshot" alt="Return Against Sales Invoice" src="{{docs_base_url}}/assets/img/stock/sales-return-against-sales-invoice.png">
 
 On submission of Return Delivery Note / Sales Invoice, system will increase stock balance in the mentioned warehouse. To maintain correct stock valuation, stock balance will go up according to the original purchase rate of the returned items.
 
-<img class="screenshot" alt="Return Stock Ledger" src="{{url_prefix}}/assets/img/stock/sales-return-stock-ledger.png">
+<img class="screenshot" alt="Return Stock Ledger" src="{{docs_base_url}}/assets/img/stock/sales-return-stock-ledger.png">
 
 In case of Return Sales Invoice, Customer account will be credited and associated income and tax account will be debited.
 
 If Perpetual Inventory enabled, system will also post accounting entry against warehouse account to sync warehouse account balance with stock balance as per Stock Ledger.
 
-<img class="screenshot" alt="Return Stock Ledger" src="{{url_prefix}}/assets/img/stock/sales-return-general-ledger.png">
\ No newline at end of file
+<img class="screenshot" alt="Return Stock Ledger" src="{{docs_base_url}}/assets/img/stock/sales-return-general-ledger.png">
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/stock/serial-no.md b/erpnext/docs/user/manual/en/stock/serial-no.md
similarity index 94%
rename from erpnext/docs/user/guides/stock/serial-no.md
rename to erpnext/docs/user/manual/en/stock/serial-no.md
index 678bd4d..fbbfb1a 100644
--- a/erpnext/docs/user/guides/stock/serial-no.md
+++ b/erpnext/docs/user/manual/en/stock/serial-no.md
@@ -20,7 +20,7 @@
 Invoice). When a new Serial No is created directly, its warehouse cannot be
 set.
 
-<img class="screenshot" alt="Serial Number" src="{{url_prefix}}/assets/img/stock/serial-no.png">
+<img class="screenshot" alt="Serial Number" src="{{docs_base_url}}/assets/img/stock/serial-no.png">
 
 * The Status is set based on Stock Entry.
 
diff --git a/erpnext/docs/user/guides/stock/setup/index.md b/erpnext/docs/user/manual/en/stock/setup/index.md
similarity index 100%
rename from erpnext/docs/user/guides/stock/setup/index.md
rename to erpnext/docs/user/manual/en/stock/setup/index.md
diff --git a/erpnext/docs/user/guides/stock/setup/index.txt b/erpnext/docs/user/manual/en/stock/setup/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/stock/setup/index.txt
rename to erpnext/docs/user/manual/en/stock/setup/index.txt
diff --git a/erpnext/docs/user/manual/en/stock/setup/item-attribute.md b/erpnext/docs/user/manual/en/stock/setup/item-attribute.md
new file mode 100644
index 0000000..0b2ab74
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/setup/item-attribute.md
@@ -0,0 +1,16 @@
+You can define Attributes and attribute values for your Item Variants here.
+
+<img class="screenshot" alt="Attribute Master" src="{{docs_base_url}}/assets/img/stock/item-attribute.png">
+
+#### Non Numeric Attributes
+
+* For Non Numeric Attributes, specify attributes values along with its abbreviation in the Attribute Value Table.
+
+<img class="screenshot" alt="Attribute Master" src="{{docs_base_url}}/assets/img/stock/item-attribute-non-numeric.png">
+
+#### Numeric Attributes
+
+* If your attribute is Numeric, select Numeric Values
+* Specify the Range and the Increment Value
+
+<img class="screenshot" alt="Attribute Master" src="{{docs_base_url}}/assets/img/stock/item-attribute-numeric.png">
diff --git a/erpnext/docs/user/guides/stock/setup/item-group.md b/erpnext/docs/user/manual/en/stock/setup/item-group.md
similarity index 64%
rename from erpnext/docs/user/guides/stock/setup/item-group.md
rename to erpnext/docs/user/manual/en/stock/setup/item-group.md
index 1d2343d..cf6a75a 100644
--- a/erpnext/docs/user/guides/stock/setup/item-group.md
+++ b/erpnext/docs/user/manual/en/stock/setup/item-group.md
@@ -5,7 +5,7 @@
 category. In case, your product is used only in trading, you can categorise it
 under Trading.
 
-<img class="screenshot" alt="Item Group Tree" src="{{url_prefix}}/assets/img/stock/item-group-tree.png">
+<img class="screenshot" alt="Item Group Tree" src="{{docs_base_url}}/assets/img/stock/item-group-tree.png">
 
 ### Create a Item Group
 
@@ -13,7 +13,7 @@
 
 * Select 'Add Child'
 
-<img class="screenshot" alt="Add Item Group" src="{{url_prefix}}/assets/img/stock/item-group-new.gif">
+<img class="screenshot" alt="Add Item Group" src="{{docs_base_url}}/assets/img/stock/item-group-new.gif">
 
 ### Delete an Item Group
 
@@ -21,6 +21,6 @@
 
 * Select 'delete'
 
-<img class="screenshot" alt="Add Item Group" src="{{url_prefix}}/assets/img/stock/item-group-del.gif">
+<img class="screenshot" alt="Add Item Group" src="{{docs_base_url}}/assets/img/stock/item-group-del.gif">
 
 {next}
diff --git a/erpnext/docs/user/manual/en/stock/setup/stock-settings.md b/erpnext/docs/user/manual/en/stock/setup/stock-settings.md
new file mode 100644
index 0000000..f8cb9ea
--- /dev/null
+++ b/erpnext/docs/user/manual/en/stock/setup/stock-settings.md
@@ -0,0 +1,5 @@
+You can set default settings for your stock related transactions here.
+
+<img class="screenshot" alt="Stock Settings" src="{{docs_base_url}}/assets/img/stock/stock-settings.png">
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/stock/stock-entry.md b/erpnext/docs/user/manual/en/stock/stock-entry.md
similarity index 86%
rename from erpnext/docs/user/guides/stock/stock-entry.md
rename to erpnext/docs/user/manual/en/stock/stock-entry.md
index ab8bf12..b7e0860 100644
--- a/erpnext/docs/user/guides/stock/stock-entry.md
+++ b/erpnext/docs/user/manual/en/stock/stock-entry.md
@@ -5,7 +5,7 @@
 
 > Stock > Stock Entry > New
 
-<img class="screenshot" alt="Stock Entry" src="{{url_prefix}}/assets/img/stock/stock-entry.png">
+<img class="screenshot" alt="Stock Entry" src="{{docs_base_url}}/assets/img/stock/stock-entry.png">
 
 Stock Entries can be made for the following purposes:
 
@@ -27,15 +27,15 @@
 
 To add additional costs, enter the description and amount of the cost in the Additional Costs table.
 
-<img class="screenshot" alt="Stock Entry Additional Costs" src="{{url_prefix}}/assets/img/stock/additional-costs-table.png">
+<img class="screenshot" alt="Stock Entry Additional Costs" src="{{docs_base_url}}/assets/img/stock/additional-costs-table.png">
 
 The added additional costs will be distributed among the receiving items (where the target warehouse mentioned) proportionately based on Basic Amount of the items. And the distributed additional cost will be added to the basic rate of the item, to calculate valuation rate.
 
-<img class="screenshot" alt="Stock Entry Item Valuation Rate" src="{{url_prefix}}/assets/img/stock/stock-entry-item-valuation-rate.png">
+<img class="screenshot" alt="Stock Entry Item Valuation Rate" src="{{docs_base_url}}/assets/img/stock/stock-entry-item-valuation-rate.png">
 
 If perpetual inventory system is enabled, additional costs will be booked in "Expense Included In Valuation" account.
 
-<img class="screenshot" alt="Additional Costs General Ledger" src="{{url_prefix}}/assets/img/stock/additional-costs-general-ledger.png">
+<img class="screenshot" alt="Additional Costs General Ledger" src="{{docs_base_url}}/assets/img/stock/additional-costs-general-ledger.png">
 
 
 > **Note:** To update Stock from a spreadsheet, see Stock Reconciliation.
diff --git a/erpnext/docs/user/guides/stock/stock-how-to.md b/erpnext/docs/user/manual/en/stock/stock-how-to.md
similarity index 100%
rename from erpnext/docs/user/guides/stock/stock-how-to.md
rename to erpnext/docs/user/manual/en/stock/stock-how-to.md
diff --git a/erpnext/docs/user/guides/stock/tools/index.md b/erpnext/docs/user/manual/en/stock/tools/index.md
similarity index 100%
rename from erpnext/docs/user/guides/stock/tools/index.md
rename to erpnext/docs/user/manual/en/stock/tools/index.md
diff --git a/erpnext/docs/user/guides/stock/tools/index.txt b/erpnext/docs/user/manual/en/stock/tools/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/stock/tools/index.txt
rename to erpnext/docs/user/manual/en/stock/tools/index.txt
diff --git a/erpnext/docs/user/guides/stock/tools/landed-cost-voucher.md b/erpnext/docs/user/manual/en/stock/tools/landed-cost-voucher.md
similarity index 97%
rename from erpnext/docs/user/guides/stock/tools/landed-cost-voucher.md
rename to erpnext/docs/user/manual/en/stock/tools/landed-cost-voucher.md
index aa146b4..1209aff 100644
--- a/erpnext/docs/user/guides/stock/tools/landed-cost-voucher.md
+++ b/erpnext/docs/user/manual/en/stock/tools/landed-cost-voucher.md
@@ -20,7 +20,7 @@
 
 In the document, you can select multiple Purchase Receipts and fetch all items from those Purchase Receipts. Then you should add applicable charges in “Taxes and Charges” table. You can easily delete an item if the added charges is not applicable to that item. The added charges are proportionately distributed among all the items based their amount.
 
-<img class="screenshot" alt="Landed Cost Vouher" src="{{url_prefix}}/assets/img/stock/landed-cost.png">
+<img class="screenshot" alt="Landed Cost Vouher" src="{{docs_base_url}}/assets/img/stock/landed-cost.png">
 
 ### What happend on submission?
 
diff --git a/erpnext/docs/user/guides/stock/tools/packing-slip.md b/erpnext/docs/user/manual/en/stock/tools/packing-slip.md
similarity index 69%
rename from erpnext/docs/user/guides/stock/tools/packing-slip.md
rename to erpnext/docs/user/manual/en/stock/tools/packing-slip.md
index 2c133bd..0820959 100644
--- a/erpnext/docs/user/guides/stock/tools/packing-slip.md
+++ b/erpnext/docs/user/manual/en/stock/tools/packing-slip.md
@@ -2,6 +2,6 @@
 While Shipping a product 'Draft' for Delivery Notes are created.
 You can make a Packing Slip from these Delivery Notes (Draft)
 
-<img class="screenshot" alt="Packing Slip" src="{{url_prefix}}/assets/img/stock/packing-slip.png">
+<img class="screenshot" alt="Packing Slip" src="{{docs_base_url}}/assets/img/stock/packing-slip.png">
 
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/stock/tools/quality-inspection.md b/erpnext/docs/user/manual/en/stock/tools/quality-inspection.md
similarity index 61%
rename from erpnext/docs/user/guides/stock/tools/quality-inspection.md
rename to erpnext/docs/user/manual/en/stock/tools/quality-inspection.md
index 175fa23..34bea40 100644
--- a/erpnext/docs/user/guides/stock/tools/quality-inspection.md
+++ b/erpnext/docs/user/manual/en/stock/tools/quality-inspection.md
@@ -3,6 +3,6 @@
 
 > Stock > Quality Inspection > New
 
-<img class="screenshot" alt="Quality Inspection" src="{{url_prefix}}/assets/img/stock/quality-inspection.png">
+<img class="screenshot" alt="Quality Inspection" src="{{docs_base_url}}/assets/img/stock/quality-inspection.png">
 
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/stock/warehouse.md b/erpnext/docs/user/manual/en/stock/warehouse.md
similarity index 94%
rename from erpnext/docs/user/guides/stock/warehouse.md
rename to erpnext/docs/user/manual/en/stock/warehouse.md
index 60dd30c..d86f401 100644
--- a/erpnext/docs/user/guides/stock/warehouse.md
+++ b/erpnext/docs/user/manual/en/stock/warehouse.md
@@ -9,7 +9,7 @@
 
 > Stock > Warehouse > New Warehouse
 
-<img class="screenshot" alt="Warehouse" src="{{url_prefix}}/assets/img/stock/warehouse.png">
+<img class="screenshot" alt="Warehouse" src="{{docs_base_url}}/assets/img/stock/warehouse.png">
 
 In ERPNext, every Warehouse must belong to a specific company, to maintain
 company wise stock balance. The Warehouses are saved with their respective
diff --git a/erpnext/docs/user/guides/support/index.md b/erpnext/docs/user/manual/en/support/index.md
similarity index 100%
rename from erpnext/docs/user/guides/support/index.md
rename to erpnext/docs/user/manual/en/support/index.md
diff --git a/erpnext/docs/user/guides/support/index.txt b/erpnext/docs/user/manual/en/support/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/support/index.txt
rename to erpnext/docs/user/manual/en/support/index.txt
diff --git a/erpnext/docs/user/guides/support/issue.md b/erpnext/docs/user/manual/en/support/issue.md
similarity index 94%
rename from erpnext/docs/user/guides/support/issue.md
rename to erpnext/docs/user/manual/en/support/issue.md
index 984a00b..246af8d 100644
--- a/erpnext/docs/user/guides/support/issue.md
+++ b/erpnext/docs/user/manual/en/support/issue.md
@@ -11,7 +11,7 @@
 
 > Support > Issue > New Issue
 
-<img class="screenshot" alt="Issue" src="{{url_prefix}}/assets/img/support/issue.png">
+<img class="screenshot" alt="Issue" src="{{docs_base_url}}/assets/img/support/issue.png">
 
 #### Discussion Thread
 
diff --git a/erpnext/docs/user/guides/support/maintenance-schedule.md b/erpnext/docs/user/manual/en/support/maintenance-schedule.md
similarity index 90%
rename from erpnext/docs/user/guides/support/maintenance-schedule.md
rename to erpnext/docs/user/manual/en/support/maintenance-schedule.md
index 1ae3a30..e211562 100644
--- a/erpnext/docs/user/guides/support/maintenance-schedule.md
+++ b/erpnext/docs/user/manual/en/support/maintenance-schedule.md
@@ -10,7 +10,7 @@
 
 > Support > Maintenance Schedule > New Maintenance Schedule
 
-<img class="screenshot" alt="Maintenance Schedule" src="{{url_prefix}}/assets/img/support/maintenance-schedule.png">
+<img class="screenshot" alt="Maintenance Schedule" src="{{docs_base_url}}/assets/img/support/maintenance-schedule.png">
 
 In the Maintenance Schedule, there are two sections:
 
diff --git a/erpnext/docs/user/guides/support/maintenance-visit.md b/erpnext/docs/user/manual/en/support/maintenance-visit.md
similarity index 80%
rename from erpnext/docs/user/guides/support/maintenance-visit.md
rename to erpnext/docs/user/manual/en/support/maintenance-visit.md
index 4f2bdbf..e93260d 100644
--- a/erpnext/docs/user/guides/support/maintenance-visit.md
+++ b/erpnext/docs/user/manual/en/support/maintenance-visit.md
@@ -4,7 +4,7 @@
 
 > Support > Maintenance Visit > New Maintenance Visit
 
-<img class="screenshot" alt="Maintenance Visit" src="{{url_prefix}}/assets/img/support/maintenance-visit.png">
+<img class="screenshot" alt="Maintenance Visit" src="{{docs_base_url}}/assets/img/support/maintenance-visit.png">
 
 The Maintenance Visit contains information about the:
 
diff --git a/erpnext/docs/user/guides/support/warranty-claim.md b/erpnext/docs/user/manual/en/support/warranty-claim.md
similarity index 91%
rename from erpnext/docs/user/guides/support/warranty-claim.md
rename to erpnext/docs/user/manual/en/support/warranty-claim.md
index a9d1b8b..0a58e18 100644
--- a/erpnext/docs/user/guides/support/warranty-claim.md
+++ b/erpnext/docs/user/manual/en/support/warranty-claim.md
@@ -15,7 +15,7 @@
 
 > Support > Warranty Claim > New Warranty Claim
 
-![Warranty Claim]({{url_prefix}}/assets/img/support/warranty-claim.png)
+![Warranty Claim]({{docs_base_url}}/assets/img/support/warranty-claim.png)
 
 If a Customer visit is required to address the issue, you can create a new
 Maintenance Visit record from this.
diff --git a/erpnext/docs/user/manual/en/using-erpnext/articles/adding-attachments-to-outgoing-messages.md b/erpnext/docs/user/manual/en/using-erpnext/articles/adding-attachments-to-outgoing-messages.md
new file mode 100644
index 0000000..91f7950
--- /dev/null
+++ b/erpnext/docs/user/manual/en/using-erpnext/articles/adding-attachments-to-outgoing-messages.md
@@ -0,0 +1,10 @@
+<h1>Adding Attachments to Outgoing Messages</h1>
+
+ERPNext has in-built file manage system. Click [here](https://erpnext.com/kb/tools/managing-attachments) to learn more on how attachments are managed in ERPNext.
+
+If you have some files attached in your transaction (say Purchase Order), which needs to be emailed with Purchase Order details. When click on Email option, at the end of the Communication dialog box, you will find all the attachments listed with check-box option. You should check files which needs to be emailed as an attachment to recipient.
+
+![Emailing Attachments]({{docs_base_url}}/assets/img/articles/$SGrab_422.png)
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/using-erpnext/articles/check-link-between-documents.md b/erpnext/docs/user/manual/en/using-erpnext/articles/check-link-between-documents.md
new file mode 100644
index 0000000..27ad650
--- /dev/null
+++ b/erpnext/docs/user/manual/en/using-erpnext/articles/check-link-between-documents.md
@@ -0,0 +1,27 @@
+<h1>Checking Link Between Documents</h1>
+
+Linked With function in ERPNext allows you checking a document is linked with which other documents. You will find Linked With function in the every document.
+
+![linked with icon]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-10 at 5.32.56 pm.png)
+
+####Scenario
+
+If you need to check which Delivery Note and Sales Invoice has been created against Sales Order, you should open Sales Order document, and click on Linked With in it.
+
+![Sales Order Links]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-10 at 5.35.44 pm.png)
+
+Since Sales Order is a centralize transaction, using linked-with option in the Sales Order, you can track complete deal, like billing done, purchases made, manufacturing development against this particular order.
+
+####How It Works?
+
+When you check Linked With in for a Sales Order, it lists all the record where this Sales Order ID is updated. It will not show documents where this Sales Order Id is entered as text, and not in the link field.
+
+####Backward Links
+
+If I check Linked With in the Delivery Note, will it list Sales Order created before this delivery  note?
+
+Linked With function works only for the forward linkages. For the backward linkages, you should check current document itself. In the Delivery Note, you can check Item table to see which Sales Order it is linked with.
+
+![Linked With Backward]({{docs_base_url}}/assets/img/articles/Screen Shot 2015-02-10 at 5.36.23 pm.png)
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/using-erpnext/articles/delete-submitted-document.md b/erpnext/docs/user/manual/en/using-erpnext/articles/delete-submitted-document.md
new file mode 100644
index 0000000..dad85ad
--- /dev/null
+++ b/erpnext/docs/user/manual/en/using-erpnext/articles/delete-submitted-document.md
@@ -0,0 +1,27 @@
+<h1>Delete Submitted Document</h1>
+
+ERPNext allows you to assign deletion permission exclusively to User. Only those users will be able to delete records. Click [here](/user-guide/setting-up/permissions/role-based-permissions) to learn more about permissions.
+
+To delete any document from system you should cancel all linked documents. For example if you need to delete Sales Order, but Delivery Note and Sales Invoice has already been created against that Sales Order. Then you should cancel and delete documents in reverse order, i.e. Sales Invoice, Delivery Note and then Sales Order. If payment entry was also made against Sales Invoice, then you should first Cancel and Delete that Journal Voucher, and then come to Sales Invoice.
+
+Following are step to delete submitted documents.
+
+####1. Cancel Document
+
+To be able to delete Submitted document, it must be cancelled first. After document is cancelled, you will find option to delete it.
+
+![Cancel Sales Order]({{docs_base_url}}/assets/img/articles/Selection_064.png)
+
+####2. Delete Document
+
+After cancellation, go to File menu and click on Delete option.
+
+![Cancel Sales Order]({{docs_base_url}}/assets/img/articles/Selection_066.png)
+
+#### Deleting from List
+
+For bulk deletion, you can select multiple Cancelled records and delete them at once from the list.
+
+![Cancel Sales Order List]({{docs_base_url}}/assets/img/articles/Selection_069.png)
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/using-erpnext/articles/duplicate-record.md b/erpnext/docs/user/manual/en/using-erpnext/articles/duplicate-record.md
new file mode 100644
index 0000000..2a1c0b4
--- /dev/null
+++ b/erpnext/docs/user/manual/en/using-erpnext/articles/duplicate-record.md
@@ -0,0 +1,17 @@
+<h1>Duplicate a Record</h1>
+
+ERPNext allows you to duplicate existing record. With this, you get values of existing record into new form, and create entries faster.
+
+####Scenario
+
+An electronic supplier receives a repeat order from an existing customer. Since new order will have details just like previous order, you can open previous order, and Copy it to create new order faster. On copying, details of the previous transaction will be updated in the new form. You can make changes where needed and submit the transaction.
+
+You will find Copy option under:
+
+File > Copy
+
+![Copy]({{docs_base_url}}/assets/img/articles/Order Copy.png)
+
+When Copy function is executed, values are mapped field-by-field from existing to new form.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/using-erpnext/articles/index.md b/erpnext/docs/user/manual/en/using-erpnext/articles/index.md
new file mode 100644
index 0000000..4e1be28
--- /dev/null
+++ b/erpnext/docs/user/manual/en/using-erpnext/articles/index.md
@@ -0,0 +1 @@
+{content}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/using-erpnext/articles/index.txt b/erpnext/docs/user/manual/en/using-erpnext/articles/index.txt
new file mode 100644
index 0000000..460fa16
--- /dev/null
+++ b/erpnext/docs/user/manual/en/using-erpnext/articles/index.txt
@@ -0,0 +1,10 @@
+adding-attachments-to-outgoing-messages
+check-link-between-documents
+delete-submitted-document
+duplicate-record
+managing-attachments
+merging-documents
+rename-tool
+renaming-documents
+search-filters
+tree-master-renaming
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/using-erpnext/articles/managing-attachments.md b/erpnext/docs/user/manual/en/using-erpnext/articles/managing-attachments.md
new file mode 100644
index 0000000..e7420b7
--- /dev/null
+++ b/erpnext/docs/user/manual/en/using-erpnext/articles/managing-attachments.md
@@ -0,0 +1,20 @@
+<h1>Adding Attachments in a Documents</h1>
+
+ERPNext allows to attach files with documents like Order, Invoices, Items etc. User with a read permission on particular document will also be able to access files attached with it. For example, Sales Order can have text file attached detailing item description and specification as decided with customers. Also it can be image file of drawing as per which product is to be manufactured.
+
+Open to attach file is at the footer of a form.
+
+![Sales Order File Attachment]({{docs_base_url}}/assets/img/articles/$SGrab_406.png)
+
+Click on Attach to browse and select the file.
+
+![Sales Order Select File]({{docs_base_url}}/assets/img/articles/$SGrab_407.png)
+
+If you maintain separate server for the files, or use online service like Dropbox, you can provide link of a particular file in the document in ERPNext.
+
+![Sales Order File Link]({{docs_base_url}}/assets/img/articles/$SGrab_408.png)
+
+`For hosted users, limit of 1 MB is applied on file size.`
+
+To ensure there are not many files attached against the document, which can lead to your system slowing down, you can set limit as how many files can be attached against particular document. Click [here](https://erpnext.com/kb/customize/increase-max-attachments) to learn more about it.
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/using-erpnext/articles/merging-documents.md b/erpnext/docs/user/manual/en/using-erpnext/articles/merging-documents.md
new file mode 100644
index 0000000..08a2620
--- /dev/null
+++ b/erpnext/docs/user/manual/en/using-erpnext/articles/merging-documents.md
@@ -0,0 +1,32 @@
+<h1>Merging Documents </h1>
+
+Document merging feature is available in ERPNext. You can done this via 'Rename' feature in ERPNext. 
+
+Following are step to merge document in existing document. Let's assume we are merging Account Ledger.
+
+#### 1: Go to Chart of Account
+
+`Accounts > Setup > Chart of Accounts`
+
+#### 2: Go to Account 
+
+Click on Rename option of that account, which you want to merge in existing account.
+
+#### 3: Merge Account
+
+Enter existing account name in New Name field and check Mark on "Merge with existing" option. Then press 'Rename' button to merge.
+
+![Account]({{docs_base_url}}/assets/img/articles/Selection_043.png)
+
+Following is how merged account will appear in the Chart of Account master.
+
+![New Account]({{docs_base_url}}/assets/img/articles/Selection_044.png)
+
+###Effect of Merging 
+
+Merging document affects existing transaction where this record is selected. As well as it will affected on existing document balance.
+
+<div class="well"> Note: You can't merge Group into Ledger documents. As well as Ledger into Group documents. Also this feature is applicable for few documents only.</div>
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/using-erpnext/articles/rename-tool.md b/erpnext/docs/user/manual/en/using-erpnext/articles/rename-tool.md
new file mode 100644
index 0000000..3bae21d
--- /dev/null
+++ b/erpnext/docs/user/manual/en/using-erpnext/articles/rename-tool.md
@@ -0,0 +1,37 @@
+<h1>Rename Tool</h1>
+
+ERPNext has Renaming Tool which allows you to rectify/change record id for existing records. This facility can be only performed by User with System Manager's role.
+
+There are two ways you can rename records in your account. You can follow the approach based on how many records needs to be renamed.
+
+###Rename Record via Rename Tool
+
+Using this tool you can correct/rectify primary ids of 500 records at a time.
+
+Following are step to rename bulk records in ERPNext. Let's assume we are renaming Item Codes for existing Items.
+
+#### Step 1: Open Excel File
+
+In new excel file enter old Item Ids in one column and enter new Item Ids in exact next column. Then save data file in .csv format.
+
+![Data File]({{docs_base_url}}/assets/img/articles/Selection_018ef32b6.png)
+
+#### Step 2: Upload Data File
+
+To upload data file go to,
+
+`Setup > Data > Rename Tool`
+
+Select DocType which you want to rename. Here DocType will be Item. Then Browse and Upload data file.
+
+![Upload Data]({{docs_base_url}}/assets/img/articles/Selection_0173436a8.png) 
+
+Following are the renamed Item Codes.
+
+![New Name]({{docs_base_url}}/assets/img/articles/Selection_019bf0547.png)
+
+###Rename Individual Document
+
+Click [here](https://erpnext.com/kb/tools/renaming-documents) for detailed steps on how to rename document one by one.
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/using-erpnext/articles/renaming-documents.md b/erpnext/docs/user/manual/en/using-erpnext/articles/renaming-documents.md
new file mode 100644
index 0000000..064f41d
--- /dev/null
+++ b/erpnext/docs/user/manual/en/using-erpnext/articles/renaming-documents.md
@@ -0,0 +1,69 @@
+<h1>Renaming Documents</h1>
+
+ERPNext has Renaming feature which allows you to correct primary id of a record. 
+	
+Following are step to rename document in ERPNext. Let's assume we are renaming Item Code for existing Item.
+ 
+#### 1. Go to Item
+
+`Stock > Documents > Item List > (Open Item)`
+
+Open Item for which Item Code needs to be renamed.
+
+#### 2. Go to File
+
+![Item]({{docs_base_url}}/assets/img/articles/Selection_013.png)
+
+#### 3. Rename
+
+Enter desired Item Code, and click on "Rename".
+
+![Renamed Item]({{docs_base_url}}/assets/img/articles/Selection_0149d98bf.png)
+
+###Effect of Renaming
+
+Renaming document affects existing transaction where this record is selected. Consider given example, Item Code for a given item will be updated in the existing transaction as well.
+
+###See Also
+
+1. [Bulk Renaming](https://erpnext.com/kb/tools/rename-tool)
+2. [Document Merging](https://erpnext.com/kb/tools/merging-documents)
+
+**List of Renamable Documents**
+
+1. Contact        					     	
+2. Address         					     	
+3. Warehouse       			   
+4. Supplier        		
+5. Customer      						    	
+6. User           				    	
+7. Sales Partner  		
+8. Project	   		
+9. Cost Center	   	
+10. Item Group
+11. Item	   	
+12. Company
+13. Role
+14. Earning Type
+15. Note 
+16. Serial No
+17. Account
+18. Territory
+19. Terms and Conditions
+20. Supplier Type	
+21. Workstation		
+22. Employee
+23. Sales Taxes and Charges Master
+24. Purchase Taxes and Charges Master
+25. Price List
+26. Party Type	
+27. Mode of Payment
+28. Designation
+29. Department
+30. Deduction Type
+31. Customer Group
+32. Brand	
+33. Branch
+34. Sales Person
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/using-erpnext/articles/search-filters.md b/erpnext/docs/user/manual/en/using-erpnext/articles/search-filters.md
new file mode 100644
index 0000000..0853ab1
--- /dev/null
+++ b/erpnext/docs/user/manual/en/using-erpnext/articles/search-filters.md
@@ -0,0 +1,39 @@
+<h1>Search Filters</h1>
+
+Search Filter option allows user to filter records based on value in the specific fields of that form.
+
+Search Filter option is available on the List View page of transactions.
+
+![Filter in List]({{docs_base_url}}/assets/img/articles/$SGrab_323.png)
+
+Each filter option has three fields to select value in.
+
+#### Field
+
+Select field of the form based on which you wish to filter records.
+
+![Filter Field]({{docs_base_url}}/assets/img/articles/$SGrab_327.png)
+
+#### Based On
+
+With Field, you will provide a value. In the based on field, you can define a criterion that when filter should be applied in record. It will be when value define for the field if filter is:
+
+![Filter Based On]({{docs_base_url}}/assets/img/articles/$SGrab_328.png)
+
+#### Value
+
+A value should be entered in this field based on while records will be filtered.
+
+![Filter Value]({{docs_base_url}}/assets/img/articles/$SGrab_329.png)
+
+After filter is applied, records will be filtered based on it. And filter will shrunk under one field/button.
+
+![Filter Result]({{docs_base_url}}/assets/img/articles/$SGrab_330.png)
+ 
+On the transactions, Document Status - Not Equal To - Cancelled is applied by default. With this, Cancelled transactions are hidden from the list. 
+
+![Default filter]({{docs_base_url}}/assets/img/articles/$SGrab_331.png)
+
+You can apply multiple filters on a list of transactions one-by-one. To remove specific filter, just click on cancelled (X) sign ahead of it.
+
+<!-- markdown -->
diff --git a/erpnext/docs/user/manual/en/using-erpnext/articles/tree-master-renaming.md b/erpnext/docs/user/manual/en/using-erpnext/articles/tree-master-renaming.md
new file mode 100644
index 0000000..30aa979
--- /dev/null
+++ b/erpnext/docs/user/manual/en/using-erpnext/articles/tree-master-renaming.md
@@ -0,0 +1,29 @@
+<h1>Tree Master Renaming</h1>
+
+There are various master which are maintained in tree structure. Click [here](https://erpnext.com/kb/setup/managing-tree-structure-masters) to learn more about tree structured masters in ERPNext.
+
+Following are the steps to be followed for renaming Account/Ledger ID, master which is maintained in tree structure. These steps will be applicable for renaming any master which is maintained in tree structure.
+
+#### Step 1: Go to Chart of Account
+
+`Accounts > Setup > Chart of Accounts`
+
+#### Step 2: Go to Account 
+
+Expand Chart of Accounts and click on that account which you want to rename. When you click on that account, you will find Rename option.
+
+![Account]({{docs_base_url}}/assets/img/articles/Selection_028.png)
+
+#### Step 2: Rename Account
+
+On clicking Rename option, dialog box will give you field to enter New Name for this Account. You should enter new name for the Account/Ledger and click on "Rename" button. On clicking Rename button, existing account will be renamed.
+
+![Account]({{docs_base_url}}/assets/img/articles/Selection_029.png)
+
+Following is how renamed account will appear in the Chart of Account master.
+
+![New Account]({{docs_base_url}}/assets/img/articles/Selection_030.png)
+  
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/collaboration-tools/assignment.md b/erpnext/docs/user/manual/en/using-erpnext/assignment.md
similarity index 78%
rename from erpnext/docs/user/guides/collaboration-tools/assignment.md
rename to erpnext/docs/user/manual/en/using-erpnext/assignment.md
index d78cf0c..6ecd377 100644
--- a/erpnext/docs/user/guides/collaboration-tools/assignment.md
+++ b/erpnext/docs/user/manual/en/using-erpnext/assignment.md
@@ -10,16 +10,16 @@
 
 Assign to option is located at the footer of document. Clicking on Assignment Icon on the tool bar will fast-forward you to footer of same document.
 
-![Assigned To Icon]({{url_prefix}}/assets/old_images/erpnext/assigned-to-icon.png)
+![Assigned To Icon]({{docs_base_url}}/assets/old_images/erpnext/assigned-to-icon.png)
 
 
-![Assigned To]({{url_prefix}}/assets/old_images/erpnext/assigned-to.png)
+![Assigned To]({{docs_base_url}}/assets/old_images/erpnext/assigned-to.png)
 
 #### Step 2: Assign to User
 
 In the Assign To section, you will find option to select User to whom this document will be assigned to. You can assign one document to multiple people at a time.
 
-![Assign User]({{url_prefix}}/assets/old_images/erpnext/assign-user.png)
+![Assign User]({{docs_base_url}}/assets/old_images/erpnext/assign-user.png)
 
 With assignment, you can also leave a comment for the review of asignee.
 
@@ -27,13 +27,13 @@
 
 This transaction will appear in the To-do list of the ser in “Todo” section.
 
-![Assign Todo]({{url_prefix}}/assets/old_images/erpnext/assign-todo.png)
+![Assign Todo]({{docs_base_url}}/assets/old_images/erpnext/assign-todo.png)
 
 ####Removing Assignment
 
 User will be able to remove assignment by clicking on "Assignment Completed" button in the document.
 
-![Assign Remove]({{url_prefix}}/assets/old_images/erpnext/assign-remove.png)
+![Assign Remove]({{docs_base_url}}/assets/old_images/erpnext/assign-remove.png)
 
 Once assignment is set as completed, Status of its ToDo record will be set as Closed.
 
diff --git a/erpnext/docs/user/guides/collaboration-tools/calendar.md b/erpnext/docs/user/manual/en/using-erpnext/calendar.md
similarity index 75%
rename from erpnext/docs/user/guides/collaboration-tools/calendar.md
rename to erpnext/docs/user/manual/en/using-erpnext/calendar.md
index 5750777..de564be 100644
--- a/erpnext/docs/user/guides/collaboration-tools/calendar.md
+++ b/erpnext/docs/user/manual/en/using-erpnext/calendar.md
@@ -11,7 +11,7 @@
 
 This view will 24 hours of a day broken in various slots. You should click on slot for Event Start Time, and drag it down till you reach event end time.
 
-![Calender Event Manually]({{url_prefix}}/assets/old_images/erpnext/calender-event-manually.png)
+![Calender Event Manually]({{docs_base_url}}/assets/old_images/erpnext/calender-event-manually.png)
 
 Based on the selection of time slot, Start Time and End Time will be updated in the Event master. Then you can set subject for an event, and save it.
 
@@ -19,7 +19,7 @@
 
 In the Lead form, you will find a field called Next Contact By and Next Contact Date. Event will be auto created for date and person person specified in this field.
 
-![Calender Event Lead]({{url_prefix}}/assets/old_images/erpnext/calender-event-lead.png)
+![Calender Event Lead]({{docs_base_url}}/assets/old_images/erpnext/calender-event-lead.png)
 
 ####Birthday Event
 
@@ -30,7 +30,7 @@
 You can set events as recurring in specific interval by Checking the "Repeat This
 Event".
 
-![Calender Event Recurring]({{url_prefix}}/assets/old_images/erpnext/calender-event-recurring.png)
+![Calender Event Recurring]({{docs_base_url}}/assets/old_images/erpnext/calender-event-recurring.png)
 
 ###Permission for Event
 
@@ -38,7 +38,7 @@
 
 Public Event, like Birthday will be visible to all.
 
-![Calender Event Permission]({{url_prefix}}/assets/old_images/erpnext/calender-event-permission.png)
+![Calender Event Permission]({{docs_base_url}}/assets/old_images/erpnext/calender-event-permission.png)
 
 ###Event Reminders
 
@@ -48,7 +48,7 @@
 
 In the Event master, checking "Send an email reminder in the morning" will trigger notifcation email to all the participants for this event.
 
-![Calender Event Notification]({{url_prefix}}/assets/old_images/erpnext/calender-event-notification.png)
+![Calender Event Notification]({{docs_base_url}}/assets/old_images/erpnext/calender-event-notification.png)
 
 ####Create Email Digest
 
@@ -58,6 +58,6 @@
 
 `Setup > Email > Email Digest`
 
-![Calender Email Digest]({{url_prefix}}/assets/old_images/erpnext/calender-email-digest.png)
+![Calender Email Digest]({{docs_base_url}}/assets/old_images/erpnext/calender-email-digest.png)
 
 {next}
diff --git a/erpnext/docs/user/guides/collaboration-tools/collaborating-around-forms.md b/erpnext/docs/user/manual/en/using-erpnext/collaborating-around-forms.md
similarity index 73%
rename from erpnext/docs/user/guides/collaboration-tools/collaborating-around-forms.md
rename to erpnext/docs/user/manual/en/using-erpnext/collaborating-around-forms.md
index 11c7b81..2de6f12 100644
--- a/erpnext/docs/user/guides/collaboration-tools/collaborating-around-forms.md
+++ b/erpnext/docs/user/manual/en/using-erpnext/collaborating-around-forms.md
@@ -4,7 +4,7 @@
 button in the right sidebar. A log of all your sent emails will be maintained
 in Communication.
 
-![Forms]({{url_prefix}}/assets/old_images/erpnext/forms.png)
+![Forms]({{docs_base_url}}/assets/old_images/erpnext/forms.png)
 
 ### Comments
 
@@ -14,6 +14,6 @@
 
 ### Tags
 
-[Read more about Tags]({{url_prefix}}/user/guides/collaboration-tools/tags.html)  
+[Read more about Tags]({{docs_base_url}}/user/guides/collaboration-tools/tags.html)  
 
 {next}
diff --git a/erpnext/docs/user/guides/collaboration-tools/index.md b/erpnext/docs/user/manual/en/using-erpnext/index.md
similarity index 100%
rename from erpnext/docs/user/guides/collaboration-tools/index.md
rename to erpnext/docs/user/manual/en/using-erpnext/index.md
diff --git a/erpnext/docs/user/guides/collaboration-tools/index.txt b/erpnext/docs/user/manual/en/using-erpnext/index.txt
similarity index 88%
rename from erpnext/docs/user/guides/collaboration-tools/index.txt
rename to erpnext/docs/user/manual/en/using-erpnext/index.txt
index d02b6d9..259835e 100644
--- a/erpnext/docs/user/guides/collaboration-tools/index.txt
+++ b/erpnext/docs/user/manual/en/using-erpnext/index.txt
@@ -5,3 +5,4 @@
 calendar
 assignment
 tags
+articles
diff --git a/erpnext/docs/user/guides/collaboration-tools/messages.md b/erpnext/docs/user/manual/en/using-erpnext/messages.md
similarity index 67%
rename from erpnext/docs/user/guides/collaboration-tools/messages.md
rename to erpnext/docs/user/manual/en/using-erpnext/messages.md
index a905aeb..dfa0526 100644
--- a/erpnext/docs/user/guides/collaboration-tools/messages.md
+++ b/erpnext/docs/user/manual/en/using-erpnext/messages.md
@@ -3,10 +3,10 @@
 a popup message and the unread messages counter in the top toolbar will be
 updated.
 
-![Message List]({{url_prefix}}/assets/old_images/erpnext/message-list.png)
+![Message List]({{docs_base_url}}/assets/old_images/erpnext/message-list.png)
 
 You can choose to send message to all the users, or to specific user.
 
-![Messsage To]({{url_prefix}}/assets/old_images/erpnext/message-to.png)
+![Messsage To]({{docs_base_url}}/assets/old_images/erpnext/message-to.png)
 
 {next}
diff --git a/erpnext/docs/user/guides/collaboration-tools/notes.md b/erpnext/docs/user/manual/en/using-erpnext/notes.md
similarity index 82%
rename from erpnext/docs/user/guides/collaboration-tools/notes.md
rename to erpnext/docs/user/manual/en/using-erpnext/notes.md
index a9abc40..cc88aec 100644
--- a/erpnext/docs/user/guides/collaboration-tools/notes.md
+++ b/erpnext/docs/user/manual/en/using-erpnext/notes.md
@@ -8,13 +8,13 @@
 
 Enter Title and Context.
 
-![Note]({{url_prefix}}/assets/old_images/erpnext/note.png)
+![Note]({{docs_base_url}}/assets/old_images/erpnext/note.png)
 
 ####Set Permissions to select Users
 
 To make Note accessible for all, check "Public" under links section. If specific Note is to be made accessible to specific user, they shall be selected in the Share With table.
 
-![Note Permission]({{url_prefix}}/assets/old_images/erpnext/note-permission.png)
+![Note Permission]({{docs_base_url}}/assets/old_images/erpnext/note-permission.png)
 
 <div class=well>Notes can also be used as a knowledge base internally. You can also attach file in the Notes, and make it accessible to specific set of users only.</div>
 
diff --git a/erpnext/docs/user/guides/collaboration-tools/tags.md b/erpnext/docs/user/manual/en/using-erpnext/tags.md
similarity index 77%
rename from erpnext/docs/user/guides/collaboration-tools/tags.md
rename to erpnext/docs/user/manual/en/using-erpnext/tags.md
index 7ada9f5..6f6c983 100644
--- a/erpnext/docs/user/guides/collaboration-tools/tags.md
+++ b/erpnext/docs/user/manual/en/using-erpnext/tags.md
@@ -1,5 +1,5 @@
 Like Assignments and Comments, you can also add your own tags to each type of transactions. These tags can help you search a document and also classify it. ERPNext will also show you all the important tags in the document list.
 
-![Tags]({{url_prefix}}/assets/old_images/erpnext/tags-in-list.png)
+![Tags]({{docs_base_url}}/assets/old_images/erpnext/tags-in-list.png)
 
 {next}
diff --git a/erpnext/docs/user/guides/collaboration-tools/to-do.md b/erpnext/docs/user/manual/en/using-erpnext/to-do.md
similarity index 76%
rename from erpnext/docs/user/guides/collaboration-tools/to-do.md
rename to erpnext/docs/user/manual/en/using-erpnext/to-do.md
index af1c5ac..03f84d5 100644
--- a/erpnext/docs/user/guides/collaboration-tools/to-do.md
+++ b/erpnext/docs/user/manual/en/using-erpnext/to-do.md
@@ -1,10 +1,10 @@
 To Do is a simple tool where all the activities [assigned](https://erpnext.com/collaboration-tools/assignment) to you and assigned
 by you are listed. You can also add your own to-do items in the list.
 
-![Todo List]({{url_prefix}}/assets/old_images/erpnext/todo-list.png)
+![Todo List]({{docs_base_url}}/assets/old_images/erpnext/todo-list.png)
 
 When task is completed, you should simply remove assignment from the assigned document. With this, task will be removed from your Todo list as well. For Todo which are not assigned via document, you can set their status as Closed from the Todo record itself.
 
-![Todo Close]({{url_prefix}}/assets/old_images/erpnext/todo-close.png)
+![Todo Close]({{docs_base_url}}/assets/old_images/erpnext/todo-close.png)
 
 {next}
diff --git a/erpnext/docs/user/guides/website/add-products-to-website.md b/erpnext/docs/user/manual/en/website/add-products-to-website.md
similarity index 71%
rename from erpnext/docs/user/guides/website/add-products-to-website.md
rename to erpnext/docs/user/manual/en/website/add-products-to-website.md
index 55b7900..3bad0df 100644
--- a/erpnext/docs/user/guides/website/add-products-to-website.md
+++ b/erpnext/docs/user/manual/en/website/add-products-to-website.md
@@ -7,7 +7,7 @@
 
 ##### Step 1: Save Image
 
-![Webimage]({{url_prefix}}/assets/old_images/erpnext/item-webimage.png)
+![Webimage]({{docs_base_url}}/assets/old_images/erpnext/item-webimage.png)
 
   
 
@@ -17,13 +17,13 @@
 Once the box is checked, the page will display other fields for entering
 information.
 
-![Webimage]({{url_prefix}}/assets/old_images/erpnext/item-webimage-1.png)
+![Webimage]({{docs_base_url}}/assets/old_images/erpnext/item-webimage-1.png)
 
   
 
 ##### Step 3: Enter Website Details
 
-![Webimage]({{url_prefix}}/assets/old_images/erpnext/item-webimage-2.png)
+![Webimage]({{docs_base_url}}/assets/old_images/erpnext/item-webimage-2.png)
 
 The page name will be generated automatically. Mention the Item-Group under
 which the Item will be displayed.
@@ -37,18 +37,18 @@
 Website'. For Example, if you wish to create a category called 'Bags', create
 a Item Group named Bags.
 
-![Item Group]({{url_prefix}}/assets/old_images/erpnext/itemgroup-webimage-bags.png)
+![Item Group]({{docs_base_url}}/assets/old_images/erpnext/itemgroup-webimage-bags.png)
 
 Once the Item Group is created go to the Website Settings page under Website.
 Enter the Label, Url, and Parent Label.
 
-![Item Group]({{url_prefix}}/assets/old_images/erpnext/itemgroup-website-settings.png)
+![Item Group]({{docs_base_url}}/assets/old_images/erpnext/itemgroup-website-settings.png)
 
   
 
 #### Webpage labels
 
-![Webpage]({{url_prefix}}/assets/old_images/erpnext/webpage-labels.png)
+![Webpage]({{docs_base_url}}/assets/old_images/erpnext/webpage-labels.png)
 
 Add more Items under a particular Item Group.
 
@@ -58,12 +58,12 @@
 check the 'Show in Website'box. The Items will be placed under the Label Bags
 on the Webpage.
 
-![Item Group]({{url_prefix}}/assets/old_images/erpnext/itemgroup-websettings.png)
+![Item Group]({{docs_base_url}}/assets/old_images/erpnext/itemgroup-websettings.png)
 
   
 
 Item Group Display
 
-![Item Group Display]({{url_prefix}}/assets/old_images/erpnext/webpage-itemgroup-display.png)
+![Item Group Display]({{docs_base_url}}/assets/old_images/erpnext/webpage-itemgroup-display.png)
 
 {next}
diff --git a/erpnext/docs/user/manual/en/website/articles/index.md b/erpnext/docs/user/manual/en/website/articles/index.md
new file mode 100644
index 0000000..4e1be28
--- /dev/null
+++ b/erpnext/docs/user/manual/en/website/articles/index.md
@@ -0,0 +1 @@
+{content}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/website/articles/index.txt b/erpnext/docs/user/manual/en/website/articles/index.txt
new file mode 100644
index 0000000..a89040a
--- /dev/null
+++ b/erpnext/docs/user/manual/en/website/articles/index.txt
@@ -0,0 +1,3 @@
+managing-user-sign-up-via-website
+website-security
+wesite-home-page
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/website/articles/managing-user-sign-up-via-website.html b/erpnext/docs/user/manual/en/website/articles/managing-user-sign-up-via-website.html
new file mode 100644
index 0000000..cef6b7a
--- /dev/null
+++ b/erpnext/docs/user/manual/en/website/articles/managing-user-sign-up-via-website.html
@@ -0,0 +1,6 @@
+<h1>Managing User Sign Up via Website</h1>
+
+Users can sign up for ERPNext account via the ERPNext Website.<div><img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2014-12-10 at 4.45.27 pm.jpg"><br></div><div><br></div><div>As seen above the login / sign-up button appears on the homepage of the website generated using ERPNext.</div><div>One might want to disable this feature to prevent anonymous users from signing up via the web.</div><div>To do so -</div><div>1. Go to&nbsp;<span style="line-height: 1.42857143;">` Website > Setup > Website Settings `&nbsp;</span></div><div>2. In website settings doctype navigate to the misc section.</div><div>3. Check the disable SignUp check-box and save the doc.</div><div><br></div><div>Now only the login button shall appear and there shall be no option to sign-up via the website. You can always revert back by following the same steps.</div><div><br></div>
+
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/website/articles/website-security.html b/erpnext/docs/user/manual/en/website/articles/website-security.html
new file mode 100644
index 0000000..1371ca5
--- /dev/null
+++ b/erpnext/docs/user/manual/en/website/articles/website-security.html
@@ -0,0 +1,3 @@
+<h1>Website Security</h1>
+
+<div><span style="line-height: 1.42857143;">One can easily generate a website using erpnext. We can list out Products on the website and also create blogs. Products are directly fetched from the Item Master records of your erpnext account. some people would like to limit the access of the website generated by ERPNext to certain people. This is because some of the items may not be available to public.</span><br></div><div><span style="line-height: 1.42857143;"><br></span></div><div>Well at the moment this feature is not available. You cannot&nbsp;<span style="line-height: 1.42857143;">limit the access of the website generated by ERPNext to certain people.&nbsp;</span><span style="line-height: 1.42857143;">If you publish the website it will be&nbsp;</span><span style="line-height: 1.42857143;">publicly</span><span style="line-height: 1.42857143;">&nbsp;visible.</span></div><div><span style="line-height: 1.42857143;"><br></span></div><div><span style="line-height: 1.42857143;">However while you cannot control who can view the website, you can always choose which items to display on the website.</span></div><div><span style="line-height: 1.42857143;"><br></span></div><div><ul><li><span style="line-height: 1.42857143;">To show or not show an Item on your website go to 'Item Master' and in the Item form check the 'show in website' checkbox.</span><br></li></ul></div><div><span style="line-height: 1.42857143;"><br></span></div><div><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;"><div><img src="{{docs_base_path}}/assets/img/articles/Screen Shot 2014-11-26 at 10.43.51 am.png"></div></blockquote></div><div><ul><li><span style="line-height: 1.42857143;">You can also fill in the details of the product as to be shown on the website here.</span><br></li></ul></div>
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/website/articles/wesite-home-page.md b/erpnext/docs/user/manual/en/website/articles/wesite-home-page.md
new file mode 100644
index 0000000..363926e
--- /dev/null
+++ b/erpnext/docs/user/manual/en/website/articles/wesite-home-page.md
@@ -0,0 +1,23 @@
+<h1>Wesite Home Page</h1>
+
+It is very much possible in ERPNext to setup certain standard page as default website Home Page. Following are steps to setup default website home page.
+
+#### **Step 1: Open Website Settings Page.**
+To Open website settings page go to:
+
+`Website > Setup > Website Settings`
+
+
+#### **Step 2: Set Home page.**
+
+Enter standard page like, index, login, products, blog, about, contact etc. as Home Page in Landing Page section of Website Settings page. For e.g consider you want login page as your default website home page.      
+
+![Website Setting Home]({{docs_base_url}}/assets/img/articles/Selection_021.png)
+
+#### **Step 3: Save Website Settings Form.**
+
+After setting up Home Page Press 'Save' button from website settings page and refresh the system from Help menu.Like this you can set any standard page as your default website home page. When some one visited to your website, he/she will see home page as default landing page on your website.
+
+![Website Home Page]({{docs_base_url}}/assets/img/articles/Selection_022.png)    
+
+<!-- markdown -->
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/website/blog-post.md b/erpnext/docs/user/manual/en/website/blog-post.md
similarity index 72%
rename from erpnext/docs/user/guides/website/blog-post.md
rename to erpnext/docs/user/manual/en/website/blog-post.md
index e0b8862..dbf7b17 100644
--- a/erpnext/docs/user/guides/website/blog-post.md
+++ b/erpnext/docs/user/manual/en/website/blog-post.md
@@ -8,13 +8,13 @@
 
 > Website > Blog > New Blog
 
-<img class="screenshot" alt="Blog Post" src="{{url_prefix}}/assets/img/website/blog-post.png">
+<img class="screenshot" alt="Blog Post" src="{{docs_base_url}}/assets/img/website/blog-post.png">
 
 You can format a blog using the Markdown format.You can also access your blog
 by going to the page “blog.html”.
 
 #### A sample blog-page.
 
-<img class="screenshot" alt="Blog Sample" src="{{url_prefix}}/assets/img/website/blog-sample.png">
+<img class="screenshot" alt="Blog Sample" src="{{docs_base_url}}/assets/img/website/blog-sample.png">
 
 {next}
diff --git a/erpnext/docs/user/manual/en/website/blogger.md b/erpnext/docs/user/manual/en/website/blogger.md
new file mode 100644
index 0000000..cb39f80
--- /dev/null
+++ b/erpnext/docs/user/manual/en/website/blogger.md
@@ -0,0 +1,6 @@
+Blogger is a user who can post blogs. 
+You can mention a shori bio about the blogger and also set a avatar here.
+
+<img class="screenshot" alt="Blogger" src="{{docs_base_url}}/assets/img/website/blogger.png">
+
+{next}
\ No newline at end of file
diff --git a/erpnext/docs/user/guides/website/index.md b/erpnext/docs/user/manual/en/website/index.md
similarity index 100%
rename from erpnext/docs/user/guides/website/index.md
rename to erpnext/docs/user/manual/en/website/index.md
diff --git a/erpnext/docs/user/manual/en/website/index.txt b/erpnext/docs/user/manual/en/website/index.txt
new file mode 100644
index 0000000..846011d
--- /dev/null
+++ b/erpnext/docs/user/manual/en/website/index.txt
@@ -0,0 +1,8 @@
+web-page
+blog-post
+web-form
+blogger
+setup
+add-products-to-website
+shopping-cart
+articles
diff --git a/erpnext/docs/user/guides/website/setup/index.md b/erpnext/docs/user/manual/en/website/setup/index.md
similarity index 100%
rename from erpnext/docs/user/guides/website/setup/index.md
rename to erpnext/docs/user/manual/en/website/setup/index.md
diff --git a/erpnext/docs/user/guides/website/setup/index.txt b/erpnext/docs/user/manual/en/website/setup/index.txt
similarity index 100%
rename from erpnext/docs/user/guides/website/setup/index.txt
rename to erpnext/docs/user/manual/en/website/setup/index.txt
diff --git a/erpnext/docs/user/guides/website/setup/social-login-keys.md b/erpnext/docs/user/manual/en/website/setup/social-login-keys.md
similarity index 100%
rename from erpnext/docs/user/guides/website/setup/social-login-keys.md
rename to erpnext/docs/user/manual/en/website/setup/social-login-keys.md
diff --git a/erpnext/docs/user/guides/website/setup/website-settings.md b/erpnext/docs/user/manual/en/website/setup/website-settings.md
similarity index 60%
rename from erpnext/docs/user/guides/website/setup/website-settings.md
rename to erpnext/docs/user/manual/en/website/setup/website-settings.md
index 95d705a..0868e8c 100644
--- a/erpnext/docs/user/guides/website/setup/website-settings.md
+++ b/erpnext/docs/user/manual/en/website/setup/website-settings.md
@@ -1,10 +1,10 @@
 Most of the website related settings can be defined here.
 
-<img class="screenshot" alt="Website Settings" src="{{url_prefix}}/assets/img/website/website-settings.png">
+<img class="screenshot" alt="Website Settings" src="{{docs_base_url}}/assets/img/website/website-settings.png">
 
 ####Landing Page
 
-* Home Page: You can specify which [Web Page]({{url_prefix}}/user/guides/website/web-page.html) must be the homepage of the website
+* Home Page: You can specify which [Web Page]({{docs_base_url}}/user/guides/website/web-page.html) must be the homepage of the website
 
 * Home Page is Products: if Checked, the Home page will be the default Item Group for the website.
 
@@ -14,7 +14,7 @@
 
 Select the theme for the website. You can create new Theme for you website also.
 
-<img class="screenshot" alt="Website Theme" src="{{url_prefix}}/assets/img/website/website-theme.png">
+<img class="screenshot" alt="Website Theme" src="{{docs_base_url}}/assets/img/website/website-theme.png">
 
 * Select 'create new website theme' if you wish to customize the default website theme.
 
@@ -23,13 +23,13 @@
 You can add a banner/ logo to your website here. Attach the image and click on set banner from Image.
 An HTML code will be generated by the system under Banner HTML.
 
-<img class="screenshot" alt="Banner" src="{{url_prefix}}/assets/img/website/banner.png">
+<img class="screenshot" alt="Banner" src="{{docs_base_url}}/assets/img/website/banner.png">
 
 ####Top Bar
 
 You can set the menus items in the Top Bar here.
 
-<img class="screenshot" alt="Top Bar" src="{{url_prefix}}/assets/img/website/top-bar.png">
+<img class="screenshot" alt="Top Bar" src="{{docs_base_url}}/assets/img/website/top-bar.png">
 
  * Similarlly you can also set sidebar and footer links.
  
@@ -37,7 +37,7 @@
 
 You can integrate the website using Google Analytics and enable social media sharing for post shared on the website.
 
-<img class="screenshot" alt="Integrations" src="{{url_prefix}}/assets/img/website/integrations.png">
+<img class="screenshot" alt="Integrations" src="{{docs_base_url}}/assets/img/website/integrations.png">
 
 * You can disable public signup to your ERPNext account by checking 'disable signup'
 
diff --git a/erpnext/docs/user/guides/website/shopping-cart.md b/erpnext/docs/user/manual/en/website/shopping-cart.md
similarity index 74%
rename from erpnext/docs/user/guides/website/shopping-cart.md
rename to erpnext/docs/user/manual/en/website/shopping-cart.md
index 0c27f4b..773e162 100644
--- a/erpnext/docs/user/guides/website/shopping-cart.md
+++ b/erpnext/docs/user/manual/en/website/shopping-cart.md
@@ -12,13 +12,13 @@
 
 #### Step 1: Enter Company Details and Default Territory.
 
-![Shopping Cart]({{url_prefix}}/assets/old_images/erpnext/shopping-cart-1.png)
+![Shopping Cart]({{docs_base_url}}/assets/old_images/erpnext/shopping-cart-1.png)
 
   
 
 #### Step 2: Enter Price List, Tax Master and Shipping Rule.
 
-![Shopping Cart]({{url_prefix}}/assets/old_images/erpnext/shopping-cart-2.png)
+![Shopping Cart]({{docs_base_url}}/assets/old_images/erpnext/shopping-cart-2.png)
 
   
 
@@ -29,13 +29,13 @@
 buy. The Item number will be stored on the right hand corner of the page, next
 to the flower sign.
 
-![Shopping Cart]({{url_prefix}}/assets/old_images/erpnext/shopping-cart-display-1.png)
+![Shopping Cart]({{docs_base_url}}/assets/old_images/erpnext/shopping-cart-display-1.png)
 
   
 
 Click on the flower sign on the right hand side to see the cart details. Click
 on the cart to get the final amount details.
 
-![Shopping Cart]({{url_prefix}}/assets/old_images/erpnext/shopping-cart-display-amount.png)
+![Shopping Cart]({{docs_base_url}}/assets/old_images/erpnext/shopping-cart-display-amount.png)
 
 {next}
diff --git a/erpnext/docs/user/guides/website/web-form.md b/erpnext/docs/user/manual/en/website/web-form.md
similarity index 81%
rename from erpnext/docs/user/guides/website/web-form.md
rename to erpnext/docs/user/manual/en/website/web-form.md
index 9fa8a1b..1668ac0 100644
--- a/erpnext/docs/user/guides/website/web-form.md
+++ b/erpnext/docs/user/manual/en/website/web-form.md
@@ -17,7 +17,7 @@
 1. Select if you require the user to login, edit records, manage multiple records etc.
 1. Add the fields you want in the record.
 
-<img class="screenshot" alt="Web Form" src="{{url_prefix}}/assets/img/website/web-form.png">
+<img class="screenshot" alt="Web Form" src="{{docs_base_url}}/assets/img/website/web-form.png">
 
 ---
 
@@ -25,7 +25,7 @@
 
 Once you create the web form, you can view it on the url and test it out!
 
-<img class="screenshot" alt="Web form" src="{{url_prefix}}/assets/img/website/web-form-view.png">
+<img class="screenshot" alt="Web form" src="{{docs_base_url}}/assets/img/website/web-form-view.png">
 
 ---
 
diff --git a/erpnext/docs/user/guides/website/web-page.md b/erpnext/docs/user/manual/en/website/web-page.md
similarity index 91%
rename from erpnext/docs/user/guides/website/web-page.md
rename to erpnext/docs/user/manual/en/website/web-page.md
index 2a4c616..947891e 100644
--- a/erpnext/docs/user/guides/website/web-page.md
+++ b/erpnext/docs/user/manual/en/website/web-page.md
@@ -4,7 +4,7 @@
 
 > Website > Web Page > New
 
-<img class="screenshot" alt="Web Page" src="{{url_prefix}}/assets/img/website/web-page.png">
+<img class="screenshot" alt="Web Page" src="{{docs_base_url}}/assets/img/website/web-page.png">
 
 #### Title
 
diff --git a/erpnext/docs/user/manual/index.md b/erpnext/docs/user/manual/index.md
new file mode 100644
index 0000000..47fc2c2
--- /dev/null
+++ b/erpnext/docs/user/manual/index.md
@@ -0,0 +1,5 @@
+# ERPNext User Manual
+
+Select your language
+
+1. [English](en)
diff --git a/erpnext/docs/user/manual/index.txt b/erpnext/docs/user/manual/index.txt
new file mode 100644
index 0000000..c574d07
--- /dev/null
+++ b/erpnext/docs/user/manual/index.txt
@@ -0,0 +1 @@
+en
diff --git a/erpnext/docs/user/videos/index.md b/erpnext/docs/user/videos/index.md
index 9976dd4..dcefe84 100644
--- a/erpnext/docs/user/videos/index.md
+++ b/erpnext/docs/user/videos/index.md
@@ -1,13 +1,13 @@
 # ERPNext Videos
 
 <h3>
-	<a class="no-decoration" href="{{url_prefix}}/user/videos/learn">Learn ERPNext</a>
+	<a class="no-decoration" href="{{docs_base_url}}/user/videos/learn">Learn ERPNext</a>
 </h3>
 
 <div class="row">
     <div class="col-sm-4">
-        <a href="{{url_prefix}}/user/videos/learn">
-            <img src="{{url_prefix}}/assets/img/videos/learn.jpg" class="img-responsive" style="margin-top: 0px;">
+        <a href="{{docs_base_url}}/user/videos/learn">
+            <img src="{{docs_base_url}}/assets/img/videos/learn.jpg" class="img-responsive" style="margin-top: 0px;">
         </a>
     </div>
     <div class="col-sm-8">
@@ -24,7 +24,7 @@
 <div class="row">
     <div class="col-sm-4">
         <a href="https://conf.erpnext.com/2014/videos">
-            <img src="{{url_prefix}}/assets/img/videos/conf-2014.jpg" class="img-responsive" style="margin-top: 0px;">
+            <img src="{{docs_base_url}}/assets/img/videos/conf-2014.jpg" class="img-responsive" style="margin-top: 0px;">
         </a>
     </div>
     <div class="col-sm-8">
diff --git a/erpnext/docs/user/videos/index.txt b/erpnext/docs/user/videos/index.txt
new file mode 100644
index 0000000..b2d525b
--- /dev/null
+++ b/erpnext/docs/user/videos/index.txt
@@ -0,0 +1 @@
+index
\ No newline at end of file
diff --git a/erpnext/docs/user/videos/learn/index.html b/erpnext/docs/user/videos/learn/index.md
similarity index 64%
rename from erpnext/docs/user/videos/learn/index.html
rename to erpnext/docs/user/videos/learn/index.md
index 2dceecf..35e1ad7 100644
--- a/erpnext/docs/user/videos/learn/index.html
+++ b/erpnext/docs/user/videos/learn/index.md
@@ -12,7 +12,7 @@
     <h3>Using ERPNext</h3>
     <ul class="list-unstyled video-list">
         <li>
-            <a href="{{url_prefix}}/user/videos/learn/navigation.html">
+            <a href="{{docs_base_url}}/user/videos/learn/navigation.html">
               User Interface and Navigation</a>
             <span class="text-muted pull-right">1:17</span>
         </li>
@@ -20,39 +20,39 @@
     <br>
     <h3>Setting Up</h3>
     <ul class="list-unstyled video-list">
-        <li><a href="{{url_prefix}}/user/videos/learn/setup-wizard.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/setup-wizard.html">
             The Setup Wizard</a>
             <span class="text-muted pull-right">2:28</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/user-and-permission.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/user-and-permission.html">
             User and Permissions</a>
             <span class="text-muted pull-right">4:20</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/data-import-tool.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/data-import-tool.html">
             Data Import Tool</a>
             <span class="text-muted pull-right">3:24</span>
     </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/printing-and-branding.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/printing-and-branding.html">
             Printing and Branding</a>
             <span class="text-muted pull-right">4:00</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/customer-and-supplier.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/customer-and-supplier.html">
             Customer and Supplier</a>
             <span class="text-muted pull-right">3:21</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/item.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/item.html">
             Item and Pricing</a>
             <span class="text-muted pull-right">3:17</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/opening-stock.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/opening-stock.html">
             Opening Stock</a>
             <span class="text-muted pull-right">2:06</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/opening-account-balances.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/opening-account-balances.html">
             Opening Account Balances</a>
             <span class="text-muted pull-right">3:46</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/email-account.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/email-account.html">
             Email Account</a>
             <span class="text-muted pull-right">2:27</span>
         </li>
@@ -60,23 +60,23 @@
     <br>
     <h3>CRM and Sales</h3>
     <ul class="list-unstyled video-list">
-        <li><a href="{{url_prefix}}/user/videos/learn/lead-to-quotation.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/lead-to-quotation.html">
             Lead to Quotation</a>
             <span class="text-muted pull-right">2:00</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/sales-cycle.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/sales-cycle.html">
             Sales Order to Payment</a>
               <span class="text-muted pull-right">4:28</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/product-bundle.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/product-bundle.html">
             Product Bundle</a>
             <span class="text-muted pull-right">2:31</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/newsletter.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/newsletter.html">
             Newsletter</a>
             <span class="text-muted pull-right">2:04</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/taxes.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/taxes.html">
             Taxes</a>
             <span class="text-muted pull-right">3:00</span>
         </li>
@@ -84,15 +84,15 @@
     <br>
     <h3>Buying</h3>
     <ul class="list-unstyled video-list">
-        <li><a href="{{url_prefix}}/user/videos/learn/material-request-to-purchase-order.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/material-request-to-purchase-order.html">
             Material Request to Purchase Order</a>
             <span class="text-muted pull-right">2:25</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/purchase-cycle.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/purchase-cycle.html">
             Purchase Order to Payment</a>
               <span class="text-muted pull-right">3:16</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/taxes.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/taxes.html">
             Taxes</a>
             <span class="text-muted pull-right">3:00</span>
         </li>
@@ -100,35 +100,35 @@
     <br>
     <h3>Stock</h3>
     <ul class="list-unstyled video-list">
-        <li><a href="{{url_prefix}}/user/videos/learn/item.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/item.html">
             Item and Pricing</a>
             <span class="text-muted pull-right">3:17</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/item-variant.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/item-variant.html">
             Item Variant</a>
             <span class="text-muted pull-right">2:38</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/opening-stock.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/opening-stock.html">
             Opening Stock</a>
             <span class="text-muted pull-right">2:06</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/stock-entries.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/stock-entries.html">
             Stock Entries</a>
               <span class="text-muted pull-right">3:46</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/serialized-inventory.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/serialized-inventory.html">
             Seriralized Inventory</a>
             <span class="text-muted pull-right">4:12</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/batch-inventory.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/batch-inventory.html">
             Batch Inventory</a>
             <span class="text-muted pull-right">3:46</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/subcontracting.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/subcontracting.html">
             Managing Subcontracting</a>
             <span class="text-muted pull-right">4:37</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/quality-inspection.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/quality-inspection.html">
             Quality Inspection</a>
             <span class="text-muted pull-right">2:36</span>
         </li>
@@ -136,15 +136,15 @@
     <br>
     <h3>Accounts</h3>
     <ul class="list-unstyled video-list">
-        <li><a href="{{url_prefix}}/user/videos/learn/chart-of-accounts.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/chart-of-accounts.html">
             Chart of Accounts</a>
             <span class="text-muted pull-right">2:26</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/opening-account-balances.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/opening-account-balances.html">
             Opening Account Balances</a>
             <span class="text-muted pull-right">3:46</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/taxes.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/taxes.html">
             Taxes</a>
               <span class="text-muted pull-right">3:00</span>
         </li>
@@ -152,15 +152,15 @@
     <br>
     <h3>Manufacturing</h3>
     <ul class="list-unstyled video-list">
-        <li><a href="{{url_prefix}}/user/videos/learn/bill-of-materials.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/bill-of-materials.html">
             Bill of Materials</a>
             <span class="text-muted pull-right">3:27</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/production-planning.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/production-planning.html">
             Production Planning Tool</a>
               <span class="text-muted pull-right">1:41</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/production-order.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/production-order.html">
             Production Order</a>
             <span class="text-muted pull-right">2:24</span>
         </li>
@@ -168,19 +168,19 @@
     <br>
     <h3>Human Resource</h3>
     <ul class="list-unstyled video-list">
-        <li><a href="{{url_prefix}}/user/videos/learn/employee.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/employee.html">
             Employee</a>
             <span class="text-muted pull-right">1:59</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/processing-payroll.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/processing-payroll.html">
             Processing Payroll</a>
               <span class="text-muted pull-right">4:00</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/leave-management.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/leave-management.html">
             Leave Management</a>
             <span class="text-muted pull-right">2:50</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/expense-claim.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/expense-claim.html">
             Expense Claim</a>
             <span class="text-muted pull-right">2:52</span>
         </li>
@@ -188,7 +188,7 @@
     <br>
     <h3>Retail</h3>
     <ul class="list-unstyled video-list">
-        <li><a href="{{url_prefix}}/user/videos/learn/point-of-sale.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/point-of-sale.html">
             Point of Sale</a>
             <span class="text-muted pull-right">2:34</span>
         </li>
@@ -196,7 +196,7 @@
     <br>
     <h3>Project</h3>
     <ul class="list-unstyled video-list">
-        <li><a href="{{url_prefix}}/user/videos/learn/project-and-task.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/project-and-task.html">
             Project and Task</a>
             <span class="text-muted pull-right">3:52</span>
         </li>
@@ -204,11 +204,11 @@
     <br>
     <h3>Customization</h3>
     <ul class="list-unstyled video-list">
-        <li><a href="{{url_prefix}}/user/videos/learn/field-customization.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/field-customization.html">
             Field Customization</a>
             <span class="text-muted pull-right">3:10</span>
         </li>
-        <li><a href="{{url_prefix}}/user/videos/learn/workflow.html">
+        <li><a href="{{docs_base_url}}/user/videos/learn/workflow.html">
             Workflow</a>
             <span class="text-muted pull-right">3:38</span>
         </li>
diff --git a/erpnext/docs/user/videos/learn/index.txt b/erpnext/docs/user/videos/learn/index.txt
new file mode 100644
index 0000000..ed1002c
--- /dev/null
+++ b/erpnext/docs/user/videos/learn/index.txt
@@ -0,0 +1,36 @@
+batch-inventory
+bill-of-materials
+chart-of-accounts
+customer-and-supplier
+data-import-tool
+email-account
+employee
+expense-claim
+field-customization
+index
+item
+item-variant
+lead-to-quotation
+leave-management
+material-request-to-purchase-order
+navigation
+newsletter
+opening-account-balances
+opening-stock
+point-of-sale
+printing-and-branding
+processing-payroll
+product-bundle
+production-order
+production-planning
+project-and-task
+purchase-cycle
+quality-inspection
+sales-cycle
+serialized-inventory
+setup-wizard
+stock-entries
+subcontracting
+taxes
+user-and-permission
+workflow
\ No newline at end of file
diff --git a/erpnext/docs/user/videos/learn/opening-stock.md b/erpnext/docs/user/videos/learn/opening-stock.md
index 7626316..6048039 100644
--- a/erpnext/docs/user/videos/learn/opening-stock.md
+++ b/erpnext/docs/user/videos/learn/opening-stock.md
@@ -6,4 +6,4 @@
 
 This tutorial demonstrates updating opening stock balance of an item. Following same steps, you can also reconcile stock of an item with respect to physical stock in a warehouse.
 
-If you maintain serialized inventory, [click here]({{url_prefix}}/user/videos/learn/serialized-inventory.html) for the tutorial on updating it's opening stock in ERPNext.
+If you maintain serialized inventory, [click here]({{docs_base_url}}/user/videos/learn/serialized-inventory.html) for the tutorial on updating it's opening stock in ERPNext.
