diff --git a/erpnext/education/doctype/program/program.json b/erpnext/education/doctype/program/program.json
index 17a7f9d..a0a2aa2 100644
--- a/erpnext/education/doctype/program/program.json
+++ b/erpnext/education/doctype/program/program.json
@@ -74,8 +74,7 @@
   {
    "fieldname": "description",
    "fieldtype": "Small Text",
-   "label": "Description",
-   "reqd": 1
+   "label": "Description"
   },
   {
    "fieldname": "intro_video",
@@ -113,7 +112,7 @@
    "label": "Allow Self Enroll"
   }
  ],
- "modified": "2019-05-29 14:42:44.693874",
+ "modified": "2019-06-05 17:47:26.877296",
  "modified_by": "Administrator",
  "module": "Education",
  "name": "Program",
diff --git a/erpnext/www/lms/content.html b/erpnext/www/lms/content.html
index acdc54d..92cfec2 100644
--- a/erpnext/www/lms/content.html
+++ b/erpnext/www/lms/content.html
@@ -38,9 +38,9 @@
 		</div>
 		<div id="nav-buttons" class="col-md-5 text-right" {{ 'hidden' if content_type=='Quiz' }}>
 			{% if previous %}
-				<a href="/lms/content?program={{ program }}&course={{ course }}&topic={{ topic }}&type={{ previous.content_type }}&content={{ previous.content }}" class='btn btn-outline-secondary'>Previous</a>
+				<a href="/lms/content?program={{ program }}&course={{ course }}&topic={{ topic }}&type={{ previous.content_type }}&content={{ previous.content }}" class='btn text-muted' style="box-shadow: none;">Previous</a>
 			{% else %}
-				<a href="/lms/course?name={{ course }}&program={{ program }}" class='btn btn-outline-secondary'>Back to Course</a>
+				<a href="/lms/course?name={{ course }}&program={{ program }}" class='btn text-muted' style="box-shadow: none;">Back to Course</a>
 			{% endif %}
 
 			{% if next %}
diff --git a/erpnext/www/lms/macros/card.html b/erpnext/www/lms/macros/card.html
index a0e4dab..213978f 100644
--- a/erpnext/www/lms/macros/card.html
+++ b/erpnext/www/lms/macros/card.html
@@ -11,7 +11,7 @@
 		{% endif %}
 		<div class='card-body'>
 			<h5 class='card-title'>{{ program.program_name }}</h5>
-			<div>{{ program.description }}</div>
+			<div>{{ program.description or '' }}</div>
 		</div>
 		<div class='card-footer'>
 			{% if has_access %} <span class="indicator green">Enrolled</span>
diff --git a/erpnext/www/lms/macros/hero.html b/erpnext/www/lms/macros/hero.html
index dfee93f..d9c4059 100644
--- a/erpnext/www/lms/macros/hero.html
+++ b/erpnext/www/lms/macros/hero.html
@@ -6,7 +6,7 @@
 			</a>
 		</div>
 		<h1>{{ title }}</h1>
-		<p class='lead' style="max-width: 100%;">{{ description }}</p>
+		<p class='lead' style="max-width: 100%;">{{ description or ''}}</p>
 		<p class="mt-4">
 			{% if frappe.session.user == 'Guest' %}
 			<a id="signup" class="btn btn-primary btn-lg" href="/login#signup">Sign Up</a>
diff --git a/erpnext/www/lms/program.html b/erpnext/www/lms/program.html
index a0e45e3..07536da 100644
--- a/erpnext/www/lms/program.html
+++ b/erpnext/www/lms/program.html
@@ -45,7 +45,7 @@
 		{% endif %}
 		<div class='card-body'>
 			<h5 class='card-title'>{{ course.course_name }}</h5>
-			<div>{{ course.course_intro }}</div>
+			<div>{{ course.course_intro or '' }}</div>
 		</div>
 		{% if has_access and progress[course.name] %}
 		<div class='card-footer'>
@@ -65,7 +65,7 @@
 
 {% block content %}
 <section class="section">
-	{{ hero(program.program_name, program.description, has_access, {'name': 'LMS Home', 'url': '/lms'}) }}
+	{{ hero(program.program_name, program.description, has_access, {'name': 'Home', 'url': '/lms'}) }}
 	<div class='container'>
 		<div class="row mt-5">
 			{% for course in courses %}
