a:4:{i:0;s:7351:"				<p class="xxlarge b bdrB orange ffv">JK~ Sr. Sales Officer Bihar & MP</p>
				<p class="ar mb15px">&bull; <a href="http://www.jobmanagement.net/">Home</a> &bull; JK~ Sr. Sales Officer Bihar & MP</p>
				<div class="vacancy">
				<p style="background:url(http://catalog.wlimg.com/templates-images/11786/11788/bb1.gif) no-repeat 0px 4px; padding-left:12px;" class="large b vacancyTitle">VACANCY DETAILS</p>
				<p style="margin:0 0 10px 12px;" class="bdrBottom"><img src="http://catalog.wlimg.com/templates-images/11786/11788/spacer.gif" /></p>
				<div style="width:95%; margin:0 auto;">
				<table class="w100">
				<tr valign="top">
				<td class="w30 p5px10px b vcBdrB"> Job Title </td>
				<td class="w1px p5px">:</td>
				<td class="w70 p5px10px vccompany vcBdrB b ffv"> JK~ Sr. Sales Officer Bihar & MP</td>
				</tr>
				
									
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Gender Preference </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> Any</td>
					</tr>
			
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Number Of Vacancy </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> 1</td>
					</tr>
		
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Industry Area </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> Sales/Marketing</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Key Skills </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> Sales,marketing,bussiness development,Business development manager,Channel Sales,automobile,Dealer Management</td>
					</tr>
			
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Qualification </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> Higher Secondary, Secondary School, M.A, M.B.A/PGDM, Other Doctorate Degree</td>
					</tr>
					
											
						<tr valign="top">
						<td class="p5px10px b vcBdrB"> Salary (Per Annum) </td>
						<td class="p5px">:</td>
						<td class="p5px10px vcBdrB ffv">  4  Lac  To  6  Lac </td>
						</tr>
						
											
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Work Experience </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> 2 - 4 Years</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB" colspan="3"> Job Requirement </td>
					</tr>
					<tr valign="top">
					<td class="p5px10px" colspan="3"> Ltd Tyre Co Require So OR Sr. Sales Officer for Bihar & MP area.<br />
Skills -<br />
Skills - Sales Acumen and selling skills<br />
Channel Sales<br />
Sales Distribution<br />
Dealer Management<br />
Tax Structure, Invoicing ,Consumer Behavior<br />
PREFER FROM: Battery/Lubricant</td>
					</tr>			
									
				</table>
				</div>
				<br />
				<p style="background:url(http://catalog.wlimg.com/templates-images/11786/11788/bb1.gif) no-repeat 0px 4px; padding-left:12px;" class="large b vacancyTitle">JOB LOCATION</p>
				<p style="margin:0 0 10px 12px;" class="bdrBottom"><img src="http://catalog.wlimg.com/templates-images/11786/11788/spacer.gif" /></p>
				<div style="width:95%; margin:0 auto;">
				<table width="100%"  border="0"  cellpadding="0" cellspacing="0">
			
									<tr valign="top">
					<td width="30%" class="p5px10px b vcBdrB">Job Country </td>
					<td width="1" class="p5px">:</td>
					<td width="70%" class="p5px10px vcBdrB ffv">India</td>
					</tr>
			
										<tr valign="top">
					<td class="p5px10px b vcBdrB">Job State / U.T.</td>
					<td width="1" class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv">Haryana</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB">Job City</td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> Gurgaon					
					</td>
					</tr>
			
									
				</table>
				</div>
				<br />
				
									
					<p style="background:url(http://catalog.wlimg.com/templates-images/11786/11788/bb1.gif) no-repeat 0px 4px; padding-left:12px;" class="large b vacancyTitle">COMPANY PROFILE </p>
					<p style="margin:0 0 10px 12px;" class="bdrBottom"><img src="http://catalog.wlimg.com/templates-images/11786/11788/spacer.gif" /></p>
					<div style="width:95%; margin:0 auto;">
					<table width="100%"  border="0"  cellpadding="0" cellspacing="0">
				
											
						<tr valign="top">
						<td width="30%" class="p5px10px b vcBdrB">Company Name</td>
						<td width="1" class="p5px">:</td>
						<td width="70%" class="p5px10px vcBdrB ffv">Job Management Institute</td>
						</tr>
				
												
						<tr valign="top">
						<td width="30%" class="p5px10px b vcBdrB">About Company</td>
						<td width="1" class="p5px">:</td>
						<td width="70%" class="p5px10px vcBdrB ffv">Job Management was established in the year 2006 as an initiative to provide manpower from entry level to senior level for various organizations across India and abroad. The firm has excelled in this field under the successful management of Mr. Basant Lakhotia. We have carved a niche in the industry by offering Manpower Recruitment, Staffing Solutions and recruiting for Work At Home opportunities. We are located in Mumbai, India.</td>
						</tr>
				
											</table>
					</div>
					<br />
									
				<p style="background:url(http://catalog.wlimg.com/templates-images/11786/11788/bb1.gif) no-repeat 0px 4px; padding-left:12px;" class="large b vacancyTitle">CONTACT DETAIL </p>
				<p style="margin:0 0 10px 12px;" class="bdrBottom"><img src="http://catalog.wlimg.com/templates-images/11786/11788/spacer.gif" /></p>
				<div style="width:95%; margin:0 auto;">
				<table width="100%"  border="0"  cellpadding="0" cellspacing="0">
			
									
					<tr valign="top">
					<td width="30%" class="p5px10px b vcBdrB">Contact Person</td>
					<td width="1" class="p5px">:</td>
					<td width="70%" class="p5px10px vcBdrB ffv">Basant</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB">Address </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv">Off Link Road, Mitha Nagar, Goregaon(w)</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB">Mobile </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv">9594935253</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB">Email ID </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"><a href="mailto:bl@jobmanagement.net">bl@jobmanagement.net</a> </td>
					</tr>
					
									
				
				</table>
				</div>
			
									
					<br class="lh1em" />
					<div class="ac">
					<form name="frmvacdetail" method="post" action="enquiry-form-10009.htm">
					<input class="Btn" type="submit" value="APPLY NOW !" />
					<input type="hidden" name="catalog_mi" value="276155">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="429343"><input type="hidden" name="subject" value="Applied for JK~ Sr. Sales Officer Bihar & MP">
					</form>
					</div>
			
									
				</div>
				<br />
				
				";i:1;s:77:"JK~ Sr. Sales Officer Bihar & MP Jobs in Gurgaon - Vacancy in Sales/Marketing";i:2;s:217:"JK~ Sr. Sales Officer Bihar & MP Jobs,JK~ Sr. Sales Officer Bihar & MP Jobs in Gurgaon,JK~ Sr. Sales Officer Bihar & MP Vacancy in Gurgaon,JK~ Sr. Sales Officer Bihar & MP jobs in India,Sales/Marketing jobs in Gurgaon";i:3;s:333:"Apply for JK~ Sr. Sales Officer Bihar & MP Jobs in Gurgaon India - JK~ Sr. Sales Officer Bihar & MP Vacancy  in Sales/Marketing field with 2 to 4 years Work Experience, Key Skills are Sales,marketing,bussiness development,Business development manager,Channel Sales,automobile,Dealer Management, Sales/Marketing jobs in Gurgaon  India";}