a:6:{i:0;s:10705:"				<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>Purchase Manager - Male For Construction Industry.</h1></div>
					<p class="breadcrumb ar uu small"> <a href="http://www.vijayamanagement.net/">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b><a href="http://www.vijayamanagement.net/current-jobs.htm" title="Current Jobs">Current Jobs</a>  			
											
					<b class="ffv p2px">&rsaquo;</b> Purchase Manager - Male For Construction Industry.</p>
									<p class="mb5px"><i class="fa fa-briefcase mr7px fl w15px alpha50"></i> 3 - 10 Years</p>
				
									<p class="mb10px"><i class="fa fa-map-marker mr7px fl pl1px w15px alpha50"></i>Pune</p>
										
					<div>
					<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="364232">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="780075"><input type="hidden" name="subject" value="Applied for Purchase Manager - Male for Construction Industry.">
					</form>
					</div>
			
						
				
				<br>
				<div class="bdrT pt20px">
				<p class="xlarge b">Job Description</p>
				<p class="aj mt10px">To procure material as per indenters requirement.<br />
Maintaining ISO Documentation.<br />
To locate new suppliers who can supply material at lower price, better quality and more credit.<br />
Inform quality rating and add or delist supplier.<br />
Keep watch on excess requirements and inform Director about any wrong practice.<br />
Try to maintain minimum inventory level.<br />
Bills Processing after collecting the bill taking all the approval of and then forwarded the bill to accounts department.<br />
Always study and inform Director about market trend.<br />
Undertake responsibility as and when given by superiors.<br />
Responsible for sub-contracting activity.<br />
Locate Select and Develop Qualified sources of supply for sub-contracted items.<br />
Follow up with supplier to ensure that they deliver right quantity of material at the right time.<br />
Maintain proper records of materials received from the supplies.<br />
Oversee the activity of rectification of defective material oft supplier.<br />
Initiate corrective action when 100% On time delivery is not mate.<br />
<br />
3 to 7 Years Exp in Purchase - Construction Company</p>
				
				<table class="w100 formTable bdr0 mt10px">				
											<tr>
							<td class="w22 alpha75 p5px">Salary</td>
							<td class="p5px"> 3  Lac  To  4  Lac  50 Thousand  P.A.</td>
							</tr>				
											
					<tr>
					<td class="w22 alpha75 p5px">Industry</td>
					<td class="p5px">Purchase / Supply Chain</td>
					</tr>
									<tr>
				<td class="w22 alpha75 p5px">Work Experience</td>
				<td class="p5px">3 - 10 Years</td>
				</tr>
									<tr>
					<td class="w22 alpha75 p5px">Qualification</td>
					<td class="p5px">Other Bachelor Degree</td>
					</tr>					
									
				</table>
				
				
				</div>
				
				<br>
				<div class="bdrT pt20px">
									<p class="xlarge b">Key Skills</p>
					<div class="mt10px dif">
											<span class="bn dib p5px10px c2px headVr mr7px mb7px">Purchase Management</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> Procurement</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> process requisitions</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> Budget Control</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> Vendor Development</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> Supply Chain</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> Hiring</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> Interviewing</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> staff training</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> Market Analysis</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> grievance Handling</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> formulating policies</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> negotiating contracts</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"></span>
											</div>
									</div>
				
				
				<br>
				<div class="bdrT pt20px">
				<p class="xlarge b">Company Profile</p>
				<div class="mt10px">
				
									<table class="w100 formTable bdr0 mt5px">
											<tr>
						<td class="w22 alpha75 p5px">Contact Person</td>
						<td class="p5px">Deepak</td>
						</tr>					
												<tr>
						<td class="w22 alpha75 p5px">Address</td>
						<td class="p5px">600, Krushna Business Centre,1st Floor, Behind Sai Service Petrol Pump, J.M. Road</td>
						</tr>					
												<tr>
						<td class="w22 alpha75 p5px">Mobile </td>
						<td class="p5px">7757087059 </td>
						</tr>
												<tr>
						<td class="w22 alpha75 p5px">Email ID</td>
						<td class="p5px"><a href="mailto:deepak@vijayamanagement.com"> deepak@vijayamanagement.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="364232">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="780075"><input type="hidden" name="subject" value="Applied for Purchase Manager - Male for Construction Industry.">
					</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="h h2"><b class="plusMinus"></b>
				<h2>Jobs by Location</h2>
				</div>
				<div class="ic showHide_rp">
				<div class="mt10px">
									<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-pune.htm" title="Jobs in Pune">Pune</a> <b class="alpha50 bn small">(14)</b></span>
									</div>
				</div>
				</div>
				</div>
				
				<div class="column_Box mc">
				<div class="tcl bullet divider">
				<div class="h h2"><b class="plusMinus"></b>
				<h2>Jobs by Functional Area</h2>
				</div>
				<div class="ic showHide_rp">
				<div class="mt10px">
									<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-accounting-tax-fid.htm" title="Accounting / Auditing / Taxation Jobs">Accounting / Auditing / Taxation</a> <b class="alpha50 bn small">(2)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-transportation-logistic-fid.htm" title="Cargo / Freight / Transportation / Packaging / Shipping Jobs">Cargo / Freight / Transportation / Packaging / Shipping</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-engineering-technical-rd-fid.htm" title="Engineering / Technical / R&D Jobs">Engineering / Technical / R&D</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-front-office-data-entry-fid.htm" title="Front Office / Executive Assistant / Data Entry Jobs">Front Office / Executive Assistant / Data Entry</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-human-resources-fid.htm" title="HR / Recruitment / Administration / IR Jobs">HR / Recruitment / Administration / IR</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-computers-it-fid.htm" title="IT Hardware / Technical Support / Telecom Engineering Jobs">IT Hardware / Technical Support / Telecom Engineering</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-application-programming-fid.htm" title="IT Software - Application Programming / Maintenance Jobs">IT Software - Application Programming / Maintenance</a> <b class="alpha50 bn small">(2)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-manufacturing-production-fid.htm" title="Manufacturing / Production / Quality Jobs">Manufacturing / Production / Quality</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-purchase-supply-chain-fid.htm" title="Purchase / Supply Chain Jobs">Purchase / Supply Chain</a> <b class="alpha50 bn small">(3)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-sales-marketing-fid.htm" title="Sales/Marketing Jobs">Sales/Marketing</a> <b class="alpha50 bn small">(3)</b></span>
									
				</div>
				</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: 'WDArd3ZXcWFYRnRKSHZYWW9wcmNPQT09',data_type: 'RExzRmw1cmRsdlh6YkJlVUZBNnA4UT09'},
	  cache : false,
	  async: true
	  
	}).done(function(resp) {
	  //alert(resp)
	});
	</script>
	";i:1;s:100:"Purchase Manager - Male for Construction Industry. Jobs in Pune - Vacancy in Purchase / Supply Chain";i:2;s:288:"Purchase Manager - Male for Construction Industry. Jobs,Purchase Manager - Male for Construction Industry. Jobs in Pune,Purchase Manager - Male for Construction Industry. Vacancy in Pune,Purchase Manager - Male for Construction Industry. jobs in India,Purchase / Supply Chain jobs in Pune";i:3;s:496:"Apply for Purchase Manager - Male for Construction Industry. Jobs in Pune India - Purchase Manager - Male for Construction Industry. Vacancy  in Purchase / Supply Chain field with 3 to 10 years Work Experience, Key Skills are Purchase Management, Procurement, process requisitions, Budget Control, Vendor Development, Supply Chain, Hiring, Interviewing, staff training, Market Analysis, grievance Handling, formulating policies, negotiating contracts,, Purchase / Supply Chain jobs in Pune  India";i:4;s:1974:"
		<script type="application/ld+json">
		{
		  "@context": "http://schema.org",
		  "@type": "JobPosting",
		  "title": "Purchase Manager - Male for Construction Industry.",
		  "baseSalary": " 3  Lac  To  4  Lac  50 Thousand ",
		  "description": "To procure material as per indenters requirement.
Maintaining ISO Documentation.
To locate new suppliers who can supply material at lower price, better quality and more credit.
Inform quality rating and add or delist supplier.
Keep watch on excess requirements and inform Director about any wrong practice.
Try to maintain minimum inventory level.
Bills Processing after collecting the bill taking all the approval of and then forwarded the bill to accounts department.
Always study and inform Director about market trend.
Undertake responsibility as and when given by superiors.
Responsible for sub-contracting activity.
Locate Select and Develop Qualified sources of supply for sub-contracted items.
Follow up with supplier to ensure that they deliver right quantity of material at the right time.
Maintain proper records of materials received from the supplies.
Oversee the activity of rectification of defective material oft supplier.
Initiate corrective action when 100% On time delivery is not mate.

3 to 7 Years Exp in Purchase - Construction Company",
		  "educationRequirements": "Other Bachelor Degree",
		  "experienceRequirements": "3 - 10 Years",
		  "industry": "Purchase / Supply Chain",
		  "jobLocation": {
		    "@type": "Place",
		    "address": {
		      "@type": "PostalAddress",
		      "addressLocality": "Maharashtra",
		      "addressRegion": "Pune"
		    }
		  },
		 "qualifications": "Other Bachelor Degree",
		     "skills": "Purchase Management, Procurement, process requisitions, Budget Control, Vendor Development, Supply Chain, Hiring, Interviewing, staff training, Market Analysis, grievance Handling, formulating policies, negotiating contracts,"
		  }
		</script>
		";i:5;N;}