a:6:{i:0;s:8531:"				<section id="middle">
				<div class="wrap" id="bodyFormatNT">
				<div class="row1 dt columns23"><!--MIDDLE ROW1 STARTS-->
				<div class="col-2 wideColumn ip ls detail_pm_15"><!--MIDDLE ROW1 COL-2 STARTS-->
				
									<div class="h1"><h1>Job openings for business development executive in delhi ncr bangalore indore</h1></div>
					<p class="breadcrumb ar uu small"> <a href="http://www.realtechindia.com/">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b><a href="http://www.realtechindia.com/current-jobs.htm" title="Current Jobs">Current Jobs</a>  			
											
					<b class="ffv p2px">&rsaquo;</b> Job openings for business development executive in delhi ncr bangalore indore</p>
									<div class="pt10px">
				<div class="xxxlarge fw6 dif">Business Development Executive</div>
									<p class="mt7px fw6">Bangalore, Indore, Mumbai, Lucknow</p>
									
				<br>
				<p class="aj mt7px">Why to Be a Part of Lido?<br />
<br />
lido’s Goal is to Inspire and Empower Every Child for the Future. in Order to Achieve this Goal, We Invite You to Be a Part of Our Ever-growing Lido Family. Grab the Opportunity to Work with Passionate Individuals, from Stanford, Duke, Iit and Bits, as We Open the Door to Engaging and Impactful Learning!<br />
<br />
field: Ed-tech.--<br />
we’re Looking for Self-motivated Candidates with Impeccable Social Skills to Join Our Business Development Team. this is a High-engagement Role and Thus Requires Candidates Who are Dedicated and have a Go-getter Attitude.<br />
<br />
join Us (if):<br />
- You Believe Education is Beyond Books and Can Be Damn Exciting<br />
- You are Extremely Customer-centric and are Excited By the Challenges of a New Emerging Business Environment<br />
- You have a Competitive Spirit and Hunger to Achieve Beyond Kra's<br />
<br />
--profile--<br />
the Candidate Will Assist Students and Parents Across India Through Consultative Sales Model Via Both Tele and Field Sales. Coordination with the Marketing, and Technology Teams Will Be Required to Leverage Branding, Partnerships and Software to Help Drive Growth and Conversions.<br />
skill Set:<br />
<br />
interest in Consultative Sales and Business Development.<br />
tonnes of Energy, Initiative and Passion for Startup Life.<br />
good Verbal and Written Communication Skills.<br />
strong Sense of Personal Leadership and Ability to Function Independently.<br />
you Must Be Articulate, Organized, Detail-oriented, and Tech-savvy.<br />
<br />
responsibilities:<br />
<br />
Identify and Develop Strategic Relationships with Potential Customers<br />
Assist in the Development of a Strong Pipeline of New Customers Through Direct or Indirect Customer Contact and Prospecting<br />
Ongoing Monitoring and Analysis of Pipeline to Review Performance & Optimize Accordingly to Ensure Objectives are Met<br />
Maintaining Strong Follow-ups and Regular Feedback Calls<br />
Update and Create Tailored Client Proposals</p>
				
				<table class="w100 formTable bdr0 mt20px">	
				<tr>
				<td class="w195 alpha75 p5px">Experience</td>
				<td class="p5px">0 - 4 Years</td>
				</tr>			
											<tr>
							<td class="alpha75 p5px">Salary</td>
							<td class="p5px"> 5  Lac  To  10  Lac  P.A.</td>
							</tr>				
											
					<tr>
					<td class="alpha75 p5px">Industry</td>
					<td class="p5px">Education / Teaching / Training / Counselling / Academic</td>
					</tr>
									
									<tr>
					<td class="alpha75 p5px">Qualification</td>
					<td class="p5px">Other Bachelor Degree</td>
					</tr>					
										<tr>
					<td class="alpha75 p5px">Key Skills</td>
					<td class="p5px">
											<span class="bdr dib p2px10px mr5px mt2px">B2c Sales</span>
												<span class="bdr dib p2px10px mr5px mt2px">Education Counselor</span>
											</td>
					</tr>
									
				</table>
				</div>
				<br>
				<div class="pt20px">
				<p class="large fw6">About Company</p>
				<div class="mt10px">
				
									<table class="w100 formTable bdr0 mt5px">
											<tr>
						<td class="w195 alpha75 p5px vat">Company Name</td>
						<td class="p5px vat"><p class="dif b">Lido Learning</p></td>
						</tr>
												<tr>
						<td class="w195 alpha75 p5px vat">About Company</td>
						<td class="p5px vat">LIDO is an ed-tech company revolutionizing the formal classroom education through a unique and immersive online classroom for every child in India. With our exciting and fun online classes for our students, we are building the Lido experience: cutting edge content like animated videos and interactive games, a personalized platform for homework, tests, challenges, and inspiring teachers.</td>
						</tr>
												<tr>
						<td class="w195 alpha75 p5px">Email ID</td>
						<td class="p5px"><a href="mailto:hr@realtechindia.com"> hr@realtechindia.com </a></td>
						</tr>
										
					</table>
									
				<br />
				
									
					<div class="bdrT pt20px">
					<form name="frmvacdetail" method="post" action="enquiry-form-10009.htm">
					<input style="padding:7px 15px;" class="button b ffos" type="submit" value="APPLY NOW !" />
					<input type="hidden" name="catalog_mi" value="902229">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="900284"><input type="hidden" name="subject" value="Applied for Business Development Executive">
					</form>
					</div>
			
									</div>
				</div>			
				
				<!--MIDDLE ROW1 COL-2 ENDS--> 
				</div>
				<div class="col-3 thinColumn"><!--MIDDLE ROW1 COL-1 STARTS-->
				
				<div class="column_Box mc">
				<div class="tcl bullet divider">
				<div class="large fw6 alpha75 p12px bdrB">
				<h2>Jobs by Location</h2>
				</div>
				<div class="ic">
				<div class="mt10px">
									<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-mumbai.htm" title="Jobs in Mumbai">Mumbai</a> <b class="alpha50 bn small">(3)</b></span>
										<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-bangalore.htm" title="Jobs in Bangalore">Bangalore</a> <b class="alpha50 bn small">(2)</b></span>
										<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-indore.htm" title="Jobs in Indore">Indore</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-lucknow.htm" title="Jobs in Lucknow">Lucknow</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-noida.htm" title="Jobs in Noida">Noida</a> <b class="alpha50 bn small">(1)</b></span>
									</div>
				</div>
				</div>
				</div>
				
				<div class="column_Box mc">
				<div class="tcl bullet divider">
				<div class="large fw6 alpha75 p12px bdrB">
				<h2>Jobs by Functional Area</h2>
				</div>
				<div style="padding:10px 18px;" class="ic">
									<p class="mb5px "><span class="fr">(3)</span><a href="jobs-in-education-teaching-training-counselling-fid.htm" title="Education / Teaching / Training / Counselling / Academic Jobs">Education / Teaching / Trainin...</a></p>
										<p class="mb5px "><span class="fr">(2)</span><a href="jobs-in-sales-marketing-fid.htm" title="Sales/Marketing Jobs">Sales/Marketing</a></p>
									
				</div>
				</div>
				</div>
				
				</div>
				<!--MIDDLE ROW1 COL-1 ENDS-->
				
				<!--MIDDLE ROW1 ENDS--> 
				</div>
				<br><br>
				</div>
				</section>
				<script>
					window.addEventListener("DOMContentLoaded", function(){
						jQuery(document).on("click", ".showallspan", function(){
							if(jQuery(this).attr("data-target") === 'show'){
								jQuery(this).text("View Less");
								jQuery(this).attr("data-target", "hide");
								jQuery(this).closest("div").find(".spanlist").removeClass("dn");
							}else{
								jQuery(this).text("View More");
								jQuery(this).attr("data-target", "show");
								jQuery(this).closest("div").find(".spanlist").addClass("dn");
							}
						});
					});
				</script>
					<script>
	$.ajax({
	  url: "https://www.placementindia.com/job_posting_view.php",
	  type: "POST",
	  dataType: 'html',
	  data: {job_view_id: 'ZmJNN3lOcWVPMWt0bHRDNGdJRktjZz09',data_type: 'RExzRmw1cmRsdlh6YkJlVUZBNnA4UT09'},
	  cache : false,
	  async: true
	  
	}).done(function(resp) {
	  //alert(resp)
	});
	</script>
	";i:1;s:96:"Job openings for business development executive in delhi ncr bangalore indore | Parth Associates";i:2;s:331:"Business Development Executive Jobs,Business Development Executive Jobs in Bangalore, Indore, Mumbai, Lucknow,Business Development Executive Vacancy in Bangalore, Indore, Mumbai, Lucknow,Business Development Executive jobs in India,Education / Teaching / Training / Counselling / Academic jobs in Bangalore, Indore, Mumbai, Lucknow";i:3;s:385:"Apply for Business Development Executive Jobs in Bangalore, Indore, Mumbai, Lucknow India - Business Development Executive Vacancy  in Education / Teaching / Training / Counselling / Academic field with 0 to 4 years Work Experience, Key Skills are B2c Sales,Education Counselor, Education / Teaching / Training / Counselling / Academic jobs in Bangalore, Indore, Mumbai, Lucknow  India";i:4;s:2681:"
		<script type="application/ld+json">
		{
		  "@context": "http://schema.org",
		  "@type": "JobPosting",
		  "title": "Business Development Executive",
		  "baseSalary": " 5  Lac  To  10  Lac ",
		  "description": "Why to Be a Part of Lido?

lido’s Goal is to Inspire and Empower Every Child for the Future. in Order to Achieve this Goal, We Invite You to Be a Part of Our Ever-growing Lido Family. Grab the Opportunity to Work with Passionate Individuals, from Stanford, Duke, Iit and Bits, as We Open the Door to Engaging and Impactful Learning!

field: Ed-tech.--
we’re Looking for Self-motivated Candidates with Impeccable Social Skills to Join Our Business Development Team. this is a High-engagement Role and Thus Requires Candidates Who are Dedicated and have a Go-getter Attitude.

join Us (if):
- You Believe Education is Beyond Books and Can Be Damn Exciting
- You are Extremely Customer-centric and are Excited By the Challenges of a New Emerging Business Environment
- You have a Competitive Spirit and Hunger to Achieve Beyond Kra's

--profile--
the Candidate Will Assist Students and Parents Across India Through Consultative Sales Model Via Both Tele and Field Sales. Coordination with the Marketing, and Technology Teams Will Be Required to Leverage Branding, Partnerships and Software to Help Drive Growth and Conversions.
skill Set:

interest in Consultative Sales and Business Development.
tonnes of Energy, Initiative and Passion for Startup Life.
good Verbal and Written Communication Skills.
strong Sense of Personal Leadership and Ability to Function Independently.
you Must Be Articulate, Organized, Detail-oriented, and Tech-savvy.

responsibilities:

Identify and Develop Strategic Relationships with Potential Customers
Assist in the Development of a Strong Pipeline of New Customers Through Direct or Indirect Customer Contact and Prospecting
Ongoing Monitoring and Analysis of Pipeline to Review Performance & Optimize Accordingly to Ensure Objectives are Met
Maintaining Strong Follow-ups and Regular Feedback Calls
Update and Create Tailored Client Proposals",
		  "educationRequirements": "Other Bachelor Degree",
		  "experienceRequirements": "0 - 4 Years",
		  "industry": "Education / Teaching / Training / Counselling / Academic",
		  "jobLocation": {
		    "@type": "Place",
		    "address": {
		      "@type": "PostalAddress",
		      "addressLocality": "Delhi/NCR, Karnataka, Madhya Pradesh, Maharashtra, Uttar Pradesh",
		      "addressRegion": "Bangalore, Indore, Mumbai, Lucknow"
		    }
		  },
		 "qualifications": "Other Bachelor Degree",
		     "skills": "B2c Sales,Education Counselor"
		  }
		</script>
		";i:5;N;}