a:4:{i:0;s:7314:"				<p class="xxlarge b bdrB orange ffv">MSL~ DGM (production Planning), Raigarh</p>
				<p class="ar mb15px">&bull; <a href="http://www.jobmanagement.net/">Home</a> &bull; MSL~ DGM (production Planning), Raigarh</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"> MSL~ DGM (production Planning), Raigarh</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"> Manufacturing / Production / Quality</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Key Skills </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> Production Planning Engineer, Production Engineer, Manufacturing Engineer</td>
					</tr>
			
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Qualification </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> B.Com, B.Tech/B.E, M.Arch, M.Com</td>
					</tr>
					
											
						<tr valign="top">
						<td class="p5px10px b vcBdrB"> Salary (Per Annum) </td>
						<td class="p5px">:</td>
						<td class="p5px10px vcBdrB ffv">  8  Lac  To  11  Lac </td>
						</tr>
						
											
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Work Experience </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> 10 - 20 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"> Maharashtra Seamless Require Head of Ppc.<br />
skill:<br />
-production Planning Process<br />
-experience in Erp / Sap<br />
-six Sigma & 5s<br />
-conversant with Technical Presentation<br />
-monitoring the Co's Central Planning<br />
-prefer from Pipe Industry</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="429350"><input type="hidden" name="subject" value="Applied for MSL~ DGM (production Planning), Raigarh">
					</form>
					</div>
			
									
				</div>
				<br />
				
				";i:1;s:105:"MSL~ DGM (production Planning), Raigarh Jobs in Gurgaon - Vacancy in Manufacturing / Production / Quality";i:2;s:266:"MSL~ DGM (production Planning), Raigarh Jobs,MSL~ DGM (production Planning), Raigarh Jobs in Gurgaon,MSL~ DGM (production Planning), Raigarh Vacancy in Gurgaon,MSL~ DGM (production Planning), Raigarh jobs in India,Manufacturing / Production / Quality jobs in Gurgaon";i:3;s:355:"Apply for MSL~ DGM (production Planning), Raigarh Jobs in Gurgaon India - MSL~ DGM (production Planning), Raigarh Vacancy  in Manufacturing / Production / Quality field with 10 to 20 years Work Experience, Key Skills are Production Planning Engineer, Production Engineer, Manufacturing Engineer, Manufacturing / Production / Quality jobs in Gurgaon  India";}