diff --git a/erpnext/docs/assets/img/education/student/student group.gif b/erpnext/docs/assets/img/education/student/student-group.gif
similarity index 100%
rename from erpnext/docs/assets/img/education/student/student group.gif
rename to erpnext/docs/assets/img/education/student/student-group.gif
Binary files differ
diff --git a/erpnext/docs/user/manual/en/education/Assessment/assessment_criteria.md b/erpnext/docs/user/manual/en/education/Assessment/assessment_criteria.md
index b97cfb1..64183ad 100644
--- a/erpnext/docs/user/manual/en/education/Assessment/assessment_criteria.md
+++ b/erpnext/docs/user/manual/en/education/Assessment/assessment_criteria.md
@@ -10,4 +10,17 @@
 
 <img class="screenshot" alt="Assessment Plan Criteria" src="/docs/assets/img/education/assessment/assessment-plan-criteria.png">
 
+#### Video Tutorial on Assessment Criteria
+
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed/t8ZDDq4qtIk?end=52' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+<div>
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/Assessment/assessment_criteria_group.md b/erpnext/docs/user/manual/en/education/Assessment/assessment_criteria_group.md
deleted file mode 100644
index 4287ca8..0000000
--- a/erpnext/docs/user/manual/en/education/Assessment/assessment_criteria_group.md
+++ /dev/null
@@ -1 +0,0 @@
-#
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/Assessment/assessment_group.md b/erpnext/docs/user/manual/en/education/Assessment/assessment_group.md
index ed02a53..35e00ad 100644
--- a/erpnext/docs/user/manual/en/education/Assessment/assessment_group.md
+++ b/erpnext/docs/user/manual/en/education/Assessment/assessment_group.md
@@ -10,4 +10,17 @@
 
 <img class="screenshot" alt="Assessment Group Term" src="/docs/assets/img/education/assessment/assessment-group-details.png">
 
+#### Video Tutorial on Assessment Group
+
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed/I1T7Z2JbcP4' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+<div>
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/Assessment/assessment_plan.md b/erpnext/docs/user/manual/en/education/Assessment/assessment_plan.md
index 7272279..8e08535 100644
--- a/erpnext/docs/user/manual/en/education/Assessment/assessment_plan.md
+++ b/erpnext/docs/user/manual/en/education/Assessment/assessment_plan.md
@@ -16,4 +16,17 @@
 
 <img class="screenshot" alt="Assessment Plan Criteria" src="/docs/assets/img/education/assessment/assessment-plan-criteria.png">
 
+#### Video Tutorial on Assessment Plan
+
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed/Q9CzzoYb_Js' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>    
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/Assessment/assessment_result.md b/erpnext/docs/user/manual/en/education/Assessment/assessment_result.md
index ed3e5fb..5547f22 100644
--- a/erpnext/docs/user/manual/en/education/Assessment/assessment_result.md
+++ b/erpnext/docs/user/manual/en/education/Assessment/assessment_result.md
@@ -4,4 +4,16 @@
 
 <img class="screenshot" alt="Assessment Result" src="/docs/assets/img/education/assessment/assessment-result.png">
 
+#### Video Tutorial on Assessment Result 
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed/U8ZRB8CM-UM?end=89' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/Assessment/assessment_result_tool.md b/erpnext/docs/user/manual/en/education/Assessment/assessment_result_tool.md
index 88b7a7a..1cd0762 100644
--- a/erpnext/docs/user/manual/en/education/Assessment/assessment_result_tool.md
+++ b/erpnext/docs/user/manual/en/education/Assessment/assessment_result_tool.md
@@ -6,4 +6,17 @@
 
 As you go on entering marks for a Student, and switch to next student, in the backend, Student Result record will be auto-created for that Student.
 
+#### Video Tutorial on Assessment Result Tool
+
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed/U8ZRB8CM-UM?start=80' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>    
+
 {next}
diff --git a/erpnext/docs/user/manual/en/education/Assessment/grading_scale.md b/erpnext/docs/user/manual/en/education/Assessment/grading_scale.md
index 0ad610b..c3d8b21 100644
--- a/erpnext/docs/user/manual/en/education/Assessment/grading_scale.md
+++ b/erpnext/docs/user/manual/en/education/Assessment/grading_scale.md
@@ -4,4 +4,17 @@
 
 <img class="screenshot" alt="Grading Scale" src="/docs/assets/img/education/assessment/grading-scale.png">
 
+#### Video Tutorial on Grading Scale
+
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed/t8ZDDq4qtIk?start=52' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/Attendance/index.txt b/erpnext/docs/user/manual/en/education/Attendance/index.txt
index 8cd0262..14ecda3 100644
--- a/erpnext/docs/user/manual/en/education/Attendance/index.txt
+++ b/erpnext/docs/user/manual/en/education/Attendance/index.txt
@@ -1,3 +1,3 @@
 student-attendance
-student-leave-application
-student-attendance-tool
\ No newline at end of file
+student-attendance-tool
+student-leave-application
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/Attendance/student-attendance-tool.md b/erpnext/docs/user/manual/en/education/Attendance/student-attendance-tool.md
index fac9d6e..c68f473 100644
--- a/erpnext/docs/user/manual/en/education/Attendance/student-attendance-tool.md
+++ b/erpnext/docs/user/manual/en/education/Attendance/student-attendance-tool.md
@@ -12,4 +12,17 @@
 
 <img class="screenshot" alt="Student Attendance" src="/docs/assets/img/education/setup/student-attendance-tool.gif">
 
+#### Tutorial Video for Student Attendance Tool
+
+
+
+<div>
+  <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+  </style>
+  <div class='embed-container'>
+    <iframe src='https://www.youtube.com/embed//j9pgkPuyiaI?start=63' frameborder='0' allowfullscreen>
+    </iframe>
+  </div>
+<div>
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/Attendance/student-attendance.md b/erpnext/docs/user/manual/en/education/Attendance/student-attendance.md
index 4be2831..b931146 100644
--- a/erpnext/docs/user/manual/en/education/Attendance/student-attendance.md
+++ b/erpnext/docs/user/manual/en/education/Attendance/student-attendance.md
@@ -12,4 +12,17 @@
 
 **Student Attendance tool** can be used for bulk updation of the attendance based on **Batch, Course or Activity**.
 
+#### Tutorial Video on Student Attendance
+
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed//j9pgkPuyiaI' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/Attendance/student-leave-application.md b/erpnext/docs/user/manual/en/education/Attendance/student-leave-application.md
index e22c6e9..011d07c 100644
--- a/erpnext/docs/user/manual/en/education/Attendance/student-leave-application.md
+++ b/erpnext/docs/user/manual/en/education/Attendance/student-leave-application.md
@@ -10,4 +10,17 @@
 
 Once a Leave Application is recorded for a student it will not be recorded in the absent student report as he has applied for a leave. 
 
+#### Tutorial Video for Student Leave Application
+
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed/NwwH5t-NKBE' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/admission/program-enrollment-tool.md b/erpnext/docs/user/manual/en/education/admission/program-enrollment-tool.md
index 97a26c7..5727bc2 100644
--- a/erpnext/docs/user/manual/en/education/admission/program-enrollment-tool.md
+++ b/erpnext/docs/user/manual/en/education/admission/program-enrollment-tool.md
@@ -18,4 +18,16 @@
 
 For promoting the students, the new academic year, academic term and program can also be selected for the enrollment of the fetched students list.
 
+#### Video Tutorial for Program Enrollment Tool
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed//5nxWYBRHY_o?start=82' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>    
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/admission/program-enrollment.md b/erpnext/docs/user/manual/en/education/admission/program-enrollment.md
index 6fe9692..36af3f2 100644
--- a/erpnext/docs/user/manual/en/education/admission/program-enrollment.md
+++ b/erpnext/docs/user/manual/en/education/admission/program-enrollment.md
@@ -17,5 +17,15 @@
 
 Student Category: For the Institutions having multiple Fees Structure, this field can be used to differentiate the student enrollment in a given fee category. 
 
+#### Video Tutorial For Program Enrollment
 
-{next}
\ No newline at end of file
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }</style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed//5nxWYBRHY_o?start=0&end=88' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>
+
+{next}
diff --git a/erpnext/docs/user/manual/en/education/admission/student-applicant.md b/erpnext/docs/user/manual/en/education/admission/student-applicant.md
index 121844c..fa1b4c2 100644
--- a/erpnext/docs/user/manual/en/education/admission/student-applicant.md
+++ b/erpnext/docs/user/manual/en/education/admission/student-applicant.md
@@ -27,4 +27,16 @@
 
 <img class="screenshot" alt="Student Applicant Enrollment" src="/docs/assets/img/education/admission/student-applicant-enroll.png">
 
+#### Video Tutorial for Student Application
+
+
+
+<div>
+	<style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }</style>
+	<div class='embed-container'>
+		<iframe src='https://www.youtube.com/embed/l8PUACusN3E' frameborder='0' allowfullscreen>
+		</iframe>
+	</div>
+</div>
+
 {next}
diff --git a/erpnext/docs/user/manual/en/education/fees/fee-structure.md b/erpnext/docs/user/manual/en/education/fees/fee-structure.md
index 2131c4a..76d43a4 100644
--- a/erpnext/docs/user/manual/en/education/fees/fee-structure.md
+++ b/erpnext/docs/user/manual/en/education/fees/fee-structure.md
@@ -20,4 +20,16 @@
 
 If you are going to use this in the Fee Schedule, you must select the Accounts carefully as Fee Schedule updates the respected Accounts in bulk. 
 
+#### Video Tutorial for Fee Structure
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed//_ZkvyVnWgYk' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/schedule/course-schedule.md b/erpnext/docs/user/manual/en/education/schedule/course-schedule.md
index f5134d5..8b8a36e 100644
--- a/erpnext/docs/user/manual/en/education/schedule/course-schedule.md
+++ b/erpnext/docs/user/manual/en/education/schedule/course-schedule.md
@@ -5,6 +5,18 @@
 
 <img class="screenshot" alt="Course Schedule" src="/docs/assets/img/education/schedule/course-schedule.png">
 
+#### Video Tutorial on Course Scheduling
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed/iy-DBV9jI-A?start=0&end=114' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>
+
 ### Marking Attendance
 
 You can mark attendance for a Student Group against a Course Schedule.
diff --git a/erpnext/docs/user/manual/en/education/schedule/scheduling-tool.md b/erpnext/docs/user/manual/en/education/schedule/scheduling-tool.md
index 08a7fa9..087c933 100644
--- a/erpnext/docs/user/manual/en/education/schedule/scheduling-tool.md
+++ b/erpnext/docs/user/manual/en/education/schedule/scheduling-tool.md
@@ -20,4 +20,14 @@
 - Check the 'Reschedule' checkbox and then click 'Schedule Course' button.
 - System will delete existing Course Schedules for specified Course within the mentioned Course Start Date and Course End Date and crate new Course Schedules.
 
+#### Video Tutorial on Scheduling Tool
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }</style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed/iy-DBV9jI-A?start=114' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>    
+
 {next}
diff --git a/erpnext/docs/user/manual/en/education/setup/course.md b/erpnext/docs/user/manual/en/education/setup/course.md
index 0d6e5ac..ec7d813 100644
--- a/erpnext/docs/user/manual/en/education/setup/course.md
+++ b/erpnext/docs/user/manual/en/education/setup/course.md
@@ -12,4 +12,18 @@
 
 The Course form is further linked to **Program, Student Group and Assessment Plan** doctypes. The links allow to view/create the related documents for a **Course**.
 
+#### Video Tutorial for Course
+
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>   
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed//1ueE4seFTp8?start=66' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>    
+
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/setup/instructor.md b/erpnext/docs/user/manual/en/education/setup/instructor.md
index 219413d..5af4cc0 100644
--- a/erpnext/docs/user/manual/en/education/setup/instructor.md
+++ b/erpnext/docs/user/manual/en/education/setup/instructor.md
@@ -16,5 +16,16 @@
 
 Further, the log for the Instructor can be entered in the Instructor Log table which can be used for keeping the records of subjects taught by that Instructor.
 
+#### Video Tutorial for Instructor
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed//rVqQYS1_02k' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>
 
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/setup/program.md b/erpnext/docs/user/manual/en/education/setup/program.md
index 25e390e..0d2a4d2 100644
--- a/erpnext/docs/user/manual/en/education/setup/program.md
+++ b/erpnext/docs/user/manual/en/education/setup/program.md
@@ -4,7 +4,7 @@
 
 To create a Program go to :
 
-###education >> Setup >> Program >> New Program
+> Education > Setup > Program > New Program
 
 Enter a unique code for every **Program**. You can also link the **Program** to the department under which it is conducted.
 
@@ -16,4 +16,16 @@
 
 The Program Doctype is further linked to the **Student applicant**, **Program enrollment, Student group, Fee structre and Fee**. The links allow to view or create the related document for a Program.
 
+#### Video Tutorial on Program and Courses
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>   
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed//1ueE4seFTp8?end=70' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>    
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/setup/school-settings.md b/erpnext/docs/user/manual/en/education/setup/school-settings.md
index 44f9c44..74e5ed5 100644
--- a/erpnext/docs/user/manual/en/education/setup/school-settings.md
+++ b/erpnext/docs/user/manual/en/education/setup/school-settings.md
@@ -2,7 +2,7 @@
 
 The Education Settings page allow you to setup basic settings like **Academic Year and Term** for the educational setup. 
 
-<img class="screenshot" alt="Student" src="/docs/assets/img/education/student/education.png">
+<img class="screenshot" alt="Student" src="/docs/assets/img/education/student/schools-settings.png">
 
 The checkbox to Validate Batch for Students in Student Group enables the Student Batch validation for every Student from the Program Enrollment for the **Batch** based on **Student Group** 
 
diff --git a/erpnext/docs/user/manual/en/education/student/student-group-creation-tool.md b/erpnext/docs/user/manual/en/education/student/student-group-creation-tool.md
index aeedd97..d27f4f7 100644
--- a/erpnext/docs/user/manual/en/education/student/student-group-creation-tool.md
+++ b/erpnext/docs/user/manual/en/education/student/student-group-creation-tool.md
@@ -4,7 +4,7 @@
 
 To create Student group using this tool go to 
 
-##education >>Student >> Student Group creation tool
+> Education > Student > Student Group creation tool
 
 Select the **Academic Term** and the **Program** for which a student group is to be created. 
 
@@ -14,4 +14,16 @@
 
 You can leave it unchecked if you don't want to consider batch while making course based groups.
 
+#### Tutorial Video on Student Group Creation Tool
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style> 
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed/5K_smeeE1Q4?start=108' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>
+
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/student/student-group.md b/erpnext/docs/user/manual/en/education/student/student-group.md
index 467fb3e..be68df1 100644
--- a/erpnext/docs/user/manual/en/education/student/student-group.md
+++ b/erpnext/docs/user/manual/en/education/student/student-group.md
@@ -6,9 +6,9 @@
 
 To create a Student Group go to:
 
-education >> Student >> New Student Group 
+> Education > Student > New Student Group 
 
-<img class="screenshot" alt="Student Group" src="/docs/assets/img/education/student/Student-group.gif">
+<img class="screenshot" alt="Student Group" src="/docs/assets/img/education/student/student-group.gif">
 
 To create a Student group based on **Batch**, select the **Progam** and **Batch**, where as to create a Student group based on **Course**, you will only have to select the Course Code. Creating a student group based on activity allows you to group of student for events and activities happening in the institute. 
 
@@ -18,5 +18,18 @@
 
 You can also update the **Email Group** for the Student Group. Click on Update Email Group to add all the email ids of the gaurdians in the respective email group and **Newsletter** can be created and sent to the Email group.
 
+#### Tutorial Video on Student Groups
+
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>       
+        <iframe src='https://www.youtube.com/embed/QILiHiTD3uc'
+        frameborder='0' allowfullscreen>
+        </iframe>
+    </div> 
+</div>
 
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/education/student/student.md b/erpnext/docs/user/manual/en/education/student/student.md
index fce5d7b..9799e80 100644
--- a/erpnext/docs/user/manual/en/education/student/student.md
+++ b/erpnext/docs/user/manual/en/education/student/student.md
@@ -4,9 +4,21 @@
 The Student doctype maintains detials like personal information, date of birth, address etc. It also records the **Guardian** and sibling details. 
 
 <img class="screenshot" alt="Student" src="/docs/assets/img/education/student/student.png">
+
 The student is enrolled in a **Program** when the application is approved. Once the enrollement is done the **Student Applicant** status is update to Admitted.
 
 You can view every doctype created for a particular student. Eg : Fees, Student Group, etc
 
+#### Video Tutorial on Student Management
+
+
+<div>
+    <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
+    </style>
+    <div class='embed-container'>
+        <iframe src='https://www.youtube.com/embed//nIUsbl0rEE0' frameborder='0' allowfullscreen>
+        </iframe>
+    </div>
+</div>    
 
 {next}
\ No newline at end of file
