a:6:{i:0;s:7683:"					<section class="headBg theme2 ">
					<div class="wrap">
					<div class="page-title-inner fo"> 
					<div class="h1"><h1>Job openings for it engineer cad administrator in pune</h1></div>
					<p class="breadcrumb ar uu small"><a href="http://www.sathvacloudtech.in/" title="Home">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b><a href="http://www.sathvacloudtech.in/current-jobs.htm" title="Current Jobs">Current Jobs</a>
																
					<b class="ffv p2px">&rsaquo;</b> Job openings for it engineer cad administrator in pune</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">Job Opening - Sr. Engineer IT (CAD Administrator , PLM Administrator , PLM Consultant ) - PUNE</div>
									<p class="mt7px fw6">Pune</p>
									
				<br>
				<p class="aj mt7px">Hello, <br />
We happen to go through your profile. We have opportunities matching your profile with our client – Pune <br />
Kindly let us know your interest in taking this forward. If your keen in taking this forward, request you to kindly share the below details with your updated resume. <br />
Total years of Experience - . <br />
Relevant years of Experience <br />
Your Current CTC: <br />
Your Expected CTC: <br />
Notice Period : <br />
Notice Period : Buyout available or not <br />
Communication Skills (Rate : 1-being lowest & 5 being highest) : <br />
Bond or Contract with Present Company(Yes/No): <br />
Do you have any offer ? If yes then mention the CTC <br />
Ready to relocate to Pune : <br />
Valid Passport details : <br />
Ready to sing a bond with Client IF position required <br />
Current location : <br />
Job location: <br />
Native Location: <br />
Why looking for change :<br />
<br />
How many year of experience you have in ALM ::- <br />
How many year of experience in CAD Application Management:-<br />
How many year of Experience in CAE application Management:- <br />
How many year of Experience in Toolkits : GIT, Jenkins, Eclipse:-<br />
Do you have experience on HPC Secure data exchanges tools like Open DXM, Open PDM, Siemens Teamcenter  :- <br />
Do you have experience on Enterprise Linux OS (SuSE/ Red hat) Catia, enovia, 3D experience,  : - <br />
Do you have experience on automation, ( CAD Macros, MS office ( 2010 and above) application , windows 10 :- <br />
Do you have any knowledge or experience in IT service management (ITSM) tools like Ivanti Service manager ( Preferred), Service Now , Remedy Etc  <br />
The person will be traveling to Germany in future <br />
Education <br />
Engineering degree  or Diploma <br />
Work Experience   - 4-8 yrs <br />
Specialized knowledge and skills<br />
Application lifecycle management ( ALM) and related toolkits ( GIT , Jenkins, Eclipse, etc.) <br />
HPC Secure data exchanges tools like Open DXM, Open PDM, Siemens Teamcenter, etd., <br />
Basic skills,<br />
Enterprise Linux OS (SuSE/ Red hat) Catia, enovia, 3D experience, automation, ( 2010 and above) application , windows 10,</p>
				
				<table class="w100 formTable bdr0 mt20px">	
				<tr>
				<td class="w195 alpha75 p5px">Experience</td>
				<td class="p5px">4 - 8 Years</td>
				</tr>			
									<tr>
					<td class="alpha75 p5px">Salary</td>
					<td class="p5px">Not Disclosed</td>
					</tr>
									
					<tr>
					<td class="alpha75 p5px">Industry</td>
					<td class="p5px">Engineering/ Engineering Design / R&D / Quality</td>
					</tr>
									
									<tr>
					<td class="alpha75 p5px">Qualification</td>
					<td class="p5px">B.Tech/B.E</td>
					</tr>					
										<tr>
					<td class="alpha75 p5px">Key Skills</td>
					<td class="p5px">
											<span class="bdr dib p2px10px mr5px mt2px">PLM Consultant</span>
												<span class="bdr dib p2px10px mr5px mt2px">CAD Administration</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">Contact Person</td>
						<td class="p5px">Girija K</td>
						</tr>					
												<tr>
						<td class="w195 alpha75 p5px">Address</td>
						<td class="p5px">No. 159, 6th Cross, 1st Stage, Pillanna Garden</td>
						</tr>					
												<tr>
						<td class="w195 alpha75 p5px">Mobile </td>
						<td class="p5px">8050061289 </td>
						</tr>
												<tr>
						<td class="w195 alpha75 p5px">Email ID</td>
						<td class="p5px"><a href="mailto:girijak2014@gmail.com"> girijak2014@gmail.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="880357">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="881736"><input type="hidden" name="subject" value="Applied for Job opening - Sr. Engineer IT (CAD Administrator , PLM Administrator , PLM Consultant ) - PUNE">
					</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-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">(1)</span><a href="jobs-in-engineering-design-rd-quality-fid.htm" title="Engineering/ Engineering Design / R&D / Quality Jobs">Engineering/ Engineering Desig...</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: 'L2JWMlR2L1l6WEc4eXRpcG40OFlwUT09',data_type: 'RExzRmw1cmRsdlh6YkJlVUZBNnA4UT09'},
	  cache : false,
	  async: true
	  
	}).done(function(resp) {
	  //alert(resp)
	});
	</script>
	";i:1;s:90:"Job openings for it engineer cad administrator in pune | Sathva Cloud Tech Private Limited";i:2;s:488:"Job opening - Sr. Engineer IT (CAD Administrator , PLM Administrator , PLM Consultant ) - PUNE Jobs,Job opening - Sr. Engineer IT (CAD Administrator , PLM Administrator , PLM Consultant ) - PUNE Jobs in Pune,Job opening - Sr. Engineer IT (CAD Administrator , PLM Administrator , PLM Consultant ) - PUNE Vacancy in Pune,Job opening - Sr. Engineer IT (CAD Administrator , PLM Administrator , PLM Consultant ) - PUNE jobs in India,Engineering/ Engineering Design / R&D / Quality jobs in Pune";i:3;s:439:"Apply for Job opening - Sr. Engineer IT (CAD Administrator , PLM Administrator , PLM Consultant ) - PUNE Jobs in Pune India - Job opening - Sr. Engineer IT (CAD Administrator , PLM Administrator , PLM Consultant ) - PUNE Vacancy  in Engineering/ Engineering Design / R&D / Quality field with 4 to 8 years Work Experience, Key Skills are PLM Consultant,CAD Administration, Engineering/ Engineering Design / R&D / Quality jobs in Pune  India";i:4;s:2699:"
		<script type="application/ld+json">
		{
		  "@context": "http://schema.org",
		  "@type": "JobPosting",
		  "title": "Job opening - Sr. Engineer IT (CAD Administrator , PLM Administrator , PLM Consultant ) - PUNE",
		  "baseSalary": "",
		  "description": "Hello, 
We happen to go through your profile. We have opportunities matching your profile with our client – Pune 
Kindly let us know your interest in taking this forward. If your keen in taking this forward, request you to kindly share the below details with your updated resume. 
Total years of Experience - . 
Relevant years of Experience 
Your Current CTC: 
Your Expected CTC: 
Notice Period : 
Notice Period : Buyout available or not 
Communication Skills (Rate : 1-being lowest & 5 being highest) : 
Bond or Contract with Present Company(Yes/No): 
Do you have any offer ? If yes then mention the CTC 
Ready to relocate to Pune : 
Valid Passport details : 
Ready to sing a bond with Client IF position required 
Current location : 
Job location: 
Native Location: 
Why looking for change :

How many year of experience you have in ALM ::- 
How many year of experience in CAD Application Management:-
How many year of Experience in CAE application Management:- 
How many year of Experience in Toolkits : GIT, Jenkins, Eclipse:-
Do you have experience on HPC Secure data exchanges tools like Open DXM, Open PDM, Siemens Teamcenter  :- 
Do you have experience on Enterprise Linux OS (SuSE/ Red hat) Catia, enovia, 3D experience,  : - 
Do you have experience on automation, ( CAD Macros, MS office ( 2010 and above) application , windows 10 :- 
Do you have any knowledge or experience in IT service management (ITSM) tools like Ivanti Service manager ( Preferred), Service Now , Remedy Etc  
The person will be traveling to Germany in future 
Education 
Engineering degree  or Diploma 
Work Experience   - 4-8 yrs 
Specialized knowledge and skills
Application lifecycle management ( ALM) and related toolkits ( GIT , Jenkins, Eclipse, etc.) 
HPC Secure data exchanges tools like Open DXM, Open PDM, Siemens Teamcenter, etd., 
Basic skills,
Enterprise Linux OS (SuSE/ Red hat) Catia, enovia, 3D experience, automation, ( 2010 and above) application , windows 10,",
		  "educationRequirements": "B.Tech/B.E",
		  "experienceRequirements": "4 - 8 Years",
		  "industry": "Engineering/ Engineering Design / R&D / Quality",
		  "jobLocation": {
		    "@type": "Place",
		    "address": {
		      "@type": "PostalAddress",
		      "addressLocality": "Maharashtra",
		      "addressRegion": "Pune"
		    }
		  },
		 "qualifications": "B.Tech/B.E",
		     "skills": "PLM Consultant,CAD Administration"
		  }
		</script>
		";i:5;N;}