a:6:{i:0;s:11464:"					<section class="headBg theme2 ">
					<div class="wrap">
					<div class="page-title-inner fo"> 
					<div class="h1"><h1>Job openings for assistant manager qc in dahej gidc bharuch</h1></div>
					<p class="breadcrumb ar uu small"><a href="http://www.sangamconsultancy.com/" title="Home">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b><a href="http://www.sangamconsultancy.com/recent-jobs.htm" title="Recent Jobs">Recent Jobs</a>
																
					<b class="ffv p2px">&rsaquo;</b> Job openings for assistant manager qc in dahej gidc bharuch</p>
					</div>
					</div>
					</section>
									<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="pt10px">
				<div class="xxxlarge fw6 dif">Assistant Manager QC</div>
									<p class="mt7px fw6">Bharuch, Dahej GIDC</p>
									
				<br>
				<p class="aj mt7px">Handled Qualification (IQ, OQ and PQ) and documentation activity of all QC instruments<br />
 Leading a team of chemist, executive and senior excutiives (8 analyst) for testing of raw materials, in-process,<br />
intermediates, and finished products (trial, validation and stability batches) using HPLC, GC and wet analysis<br />
 Prepared all general, operational, and calibration standard operating procedures (SOPs) at QC and maintained good<br />
QMS system<br />
 Prepared Standard test procedures, specifications of raw materials, intermediates, finshed products as per tentative<br />
specifications, STPs received from R&D<br />
 Ensured timely sampling of raw materials (RMs) from warehouse, testing as per R&D soecification, preparation of<br />
approved lebels, preparation of COAs and sharing to warehouse<br />
 Ensured timely release of In-process, cleaning, intermediate and finished product results, preparartion of COA and<br />
timely intimation to production<br />
 Handled analytical method transfer activity of KSMs, intermediates and APIs of the oncology and non oncology<br />
products from ARD (R&D) by both collaborative and non-collaborative methods.<br />
 Ensured timely completion of method transfer protocol & report and its submission to QA<br />
 Ensured calibration of all QC instruments within stipulated time as per the master calibration schedule<br />
 Preparaion and timely storage of control samples of validation baches<br />
 Preparation of stability protocol, and storing of validation batches under long term, intermediate and accelerated<br />
stability conditions.<br />
 Handled the disregard, incident, deviation, OOS, CAPA and change control activities at QC<br />
 Coordinated with vendors (instrument, chemicals etc) and purchase dept. for timely indent and release of purchase<br />
order</p>
				
				<table class="w100 formTable bdr0 mt20px">	
				<tr>
				<td class="w195 alpha75 p5px">Experience</td>
				<td class="p5px">6 - 10 Years</td>
				</tr>			
											<tr>
							<td class="alpha75 p5px">Salary</td>
							<td class="p5px"> 5  Lac  50 Thousand  To  10  Lac  P.A.</td>
							</tr>				
											
					<tr>
					<td class="alpha75 p5px">Industry</td>
					<td class="p5px">Manufacturing / Production / Quality</td>
					</tr>
									
									<tr>
					<td class="alpha75 p5px">Qualification</td>
					<td class="p5px">B.Pharma, B.Sc, M.Pharma, M.Sc</td>
					</tr>					
										<tr>
					<td class="alpha75 p5px">Key Skills</td>
					<td class="p5px">
											<span class="bdr dib p2px10px mr5px mt2px">quality assurance assistant manager</span>
												<span class="bdr dib p2px10px mr5px mt2px">quality control assistant manager</span>
											</td>
					</tr>
									
				</table>
				</div>
				<br>
				<div class="pt20px">
				<p class="large fw6">About Company</p>
				<div class="mt10px">
				
				Sangam Consultancy is a well-known placement firm in Ankleshwar (Gujarat). It was founded in the year 2015 by Mr. Ashutosh Singh. He founded the company with an aim of easing all operations related to placement and staffing solutions in the Gujarat placement industry. We serve as a placement consultant, HR consultant, and manpower recruiter in Ankleshwar. After expanding the business, we introduced the passport & visa consultancy, career consultancy, and training services in Ankleshwar. Under the guidance of Mr. Ashutosh, we are flourishing at pace.				
				<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="786061">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="928428"><input type="hidden" name="subject" value="Applied for Assistant Manager QC">
					</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-bharuch.htm" title="Jobs in Bharuch">Bharuch</a> <b class="alpha50 bn small">(81)</b></span>
										<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-vadodara.htm" title="Jobs in Vadodara">Vadodara</a> <b class="alpha50 bn small">(4)</b></span>
										<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">(4)</b></span>
										<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-anand.htm" title="Jobs in Anand">Anand</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-zirakpur.htm" title="Jobs in Zirakpur">Zirakpur</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-surat.htm" title="Jobs in Surat">Surat</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-rajkot.htm" title="Jobs in Rajkot">Rajkot</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-pune.htm" title="Jobs in Pune">Pune</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">(53)</span><a href="jobs-in-manufacturing-production-fid.htm" title="Manufacturing / Production / Quality Jobs">Manufacturing / Production / Q...</a></p>
										<p class="mb5px "><span class="fr">(16)</span><a href="jobs-in-biotech-scientist-fid.htm" title="Pharma / R&D / Biotech Jobs">Pharma / R&D / Biotech</a></p>
										<p class="mb5px "><span class="fr">(5)</span><a href="jobs-in-engineering-design-rd-quality-fid.htm" title="Engineering/ Engineering Design / R&D / Quality Jobs">Engineering/ Engineering Desig...</a></p>
										<p class="mb5px "><span class="fr">(4)</span><a href="jobs-in-financial-services-banking-investments-insurance-stock-market-loan-fid.htm" title="Financial Services / Banking, Investments / Insurance / stock market / Loan Jobs">Financial Services / Banking, ...</a></p>
										<p class="mb5px "><span class="fr">(2)</span><a href="jobs-in-front-office-reception-computer-operator-assistant-fid.htm" title="Front Office / Reception/Computer Operator/Assistant Jobs">Front Office / Reception/Compu...</a></p>
										<p class="mb5px "><span class="fr">(2)</span><a href="jobs-in-health-care-pharmaceuticals-medical-fid.htm" title="Health Care / Pharmaceuticals / Medical Jobs">Health Care / Pharmaceuticals ...</a></p>
										<p class="mb5px "><span class="fr">(2)</span><a href="jobs-in-hr-recruitment-administration-ir-training-development-operations-fid.htm" title="HR / Recruitment / Administration / IR / Training & Development / Operations Jobs">HR / Recruitment / Administrat...</a></p>
										<p class="mb5px "><span class="fr">(2)</span><a href="jobs-in-accounting-tax-fid.htm" title="Accounting / Auditing / Taxation Jobs">Accounting / Auditing / Taxati...</a></p>
										<p class="mb5px "><span class="fr">(2)</span><a href="jobs-in-advertisement-marketing-fid.htm" title="Marketing / Advertising / PR / Media Planning Jobs">Marketing / Advertising / PR /...</a></p>
										<p class="mb5px "><span class="fr">(1)</span><a href="jobs-in-export-import-merchandising-fid.htm" title="Export / Import / Merchandising Jobs">Export / Import / Merchandisin...</a></p>
										<p class="mb5px "><span class="fr">(1)</span><a href="jobs-in-corporate-planning-fid.htm" title="Corporate Planning & Strategy / Management Consulting Jobs">Corporate Planning & Strategy ...</a></p>
										<p class="mb5px spanlist dn"><span class="fr">(1)</span><a href="jobs-in-it-hardware-security-operating-systems-fid.htm" title="IT Hardware – Security / Operating Systems Jobs">IT Hardware – Security / Ope...</a></p>
										<p class="mb5px spanlist dn"><span class="fr">(1)</span><a href="jobs-in-application-programming-fid.htm" title="IT Software - Application Programming / Maintenance Jobs">IT Software - Application Prog...</a></p>
										<p class="mb5px spanlist dn"><span class="fr">(1)</span><a href="jobs-in-supply-chain-purchase-procurement-fid.htm" title="Supply Chain / Purchase / Procurement Jobs">Supply Chain / Purchase / Proc...</a></p>
										<span class="uu db ar"><a class="showallspan" data-target="show" href="javascript:void(0)" >View More</a></span>
									
				</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: 'RnBGOERnTy9hZU1BVks0clFyWlJ4dz09',data_type: 'RExzRmw1cmRsdlh6YkJlVUZBNnA4UT09'},
	  cache : false,
	  async: true
	  
	}).done(function(resp) {
	  //alert(resp)
	});
	</script>
	";i:1;s:80:"Job openings for assistant manager qc in dahej gidc bharuch | Sangam Consultancy";i:2;s:190:"Assistant Manager QC Jobs,Assistant Manager QC Jobs in Bharuch,Assistant Manager QC Vacancy in Bharuch,Assistant Manager QC jobs in India,Manufacturing / Production / Quality jobs in Bharuch";i:3;s:312:"Apply for Assistant Manager QC Jobs in Bharuch India - Assistant Manager QC Vacancy  in Manufacturing / Production / Quality field with 6 to 10 years Work Experience, Key Skills are quality assurance assistant manager,quality control assistant manager, Manufacturing / Production / Quality jobs in Bharuch  India";i:4;s:2528:"
		<script type="application/ld+json">
		{
		  "@context": "http://schema.org",
		  "@type": "JobPosting",
		  "title": "Assistant Manager QC",
		  "baseSalary": " 5  Lac  50 Thousand  To  10  Lac ",
		  "description": "Handled Qualification (IQ, OQ and PQ) and documentation activity of all QC instruments
 Leading a team of chemist, executive and senior excutiives (8 analyst) for testing of raw materials, in-process,
intermediates, and finished products (trial, validation and stability batches) using HPLC, GC and wet analysis
 Prepared all general, operational, and calibration standard operating procedures (SOPs) at QC and maintained good
QMS system
 Prepared Standard test procedures, specifications of raw materials, intermediates, finshed products as per tentative
specifications, STPs received from R&D
 Ensured timely sampling of raw materials (RMs) from warehouse, testing as per R&D soecification, preparation of
approved lebels, preparation of COAs and sharing to warehouse
 Ensured timely release of In-process, cleaning, intermediate and finished product results, preparartion of COA and
timely intimation to production
 Handled analytical method transfer activity of KSMs, intermediates and APIs of the oncology and non oncology
products from ARD (R&D) by both collaborative and non-collaborative methods.
 Ensured timely completion of method transfer protocol & report and its submission to QA
 Ensured calibration of all QC instruments within stipulated time as per the master calibration schedule
 Preparaion and timely storage of control samples of validation baches
 Preparation of stability protocol, and storing of validation batches under long term, intermediate and accelerated
stability conditions.
 Handled the disregard, incident, deviation, OOS, CAPA and change control activities at QC
 Coordinated with vendors (instrument, chemicals etc) and purchase dept. for timely indent and release of purchase
order",
		  "educationRequirements": "B.Pharma, B.Sc, M.Pharma, M.Sc",
		  "experienceRequirements": "6 - 10 Years",
		  "industry": "Manufacturing / Production / Quality",
		  "jobLocation": {
		    "@type": "Place",
		    "address": {
		      "@type": "PostalAddress",
		      "addressLocality": "Gujarat",
		      "addressRegion": "Bharuch, Dahej GIDC"
		    }
		  },
		 "qualifications": "B.Pharma, B.Sc, M.Pharma, M.Sc",
		     "skills": "quality assurance assistant manager,quality control assistant manager"
		  }
		</script>
		";i:5;N;}