a:6:{i:0;s:10376:"					<section class="headBg theme2 ">
					<div class="wrap">
					<div class="page-title-inner fo"> 
					<div class="h1"><h1>Job openings for full stack developer in pune</h1></div>
					<p class="breadcrumb ar uu small"><a href="http://www.puneplacement.com/" title="Home">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b><a href="http://www.puneplacement.com/current-jobs.htm" title="Current Opening">Current Opening</a>
																
					<b class="ffv p2px">&rsaquo;</b> Job openings for full stack developer 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">Full Stack Developer (ReachJS)</div>
									<p class="mt7px fw6">Pune</p>
									
				<br>
				<p class="aj mt7px">We are looking for a versatile JavaScript developer proficient in React JS.<br />
You’ll follow well know React JS workflows such as Flux or Redux.<br />
You’ll also ensure that these components and the overall application are robust and easy to maintain.<br />
Develop new user-facing features using React JS<br />
 Build reusable components and front-end libraries for future use<br />
Translation of designs and wireframes into high quality code<br />
Optimize components for maximum performance across a vast array of web capable devices and browsers You will love this job if you are:<br />
A technology addict who has a plan to stay ahead of the curve.A problem solver who jumpstarts at work to resolve issues • A continuous learner who wants to make a difference with innovation<br />
Hands-on experience (3-6 years) of JavaScript and Node JS based solution/projects • Experience with popular React JS workflows such as Flux or Redux • Exposure to with ES6/ES7 and RESTful APIs • Familiarity with UI components library such as material-ui or Bootstrap • Knowledge of modern authorization mechanisms, such as JSON Web Token • Experience with common front-end development tools such as Babel, Webpack, NPM, etc<br />
Responsibilities:<br />
1.     Build a bleeding edge platform for India and global market using Python, Node.js Angular JS and other technologies<br />
2.     You will be responsible for developing business requirements using above technologies<br />
3.     Work with Sr Technical Leads to understand feasibility of UI & workflow requirements<br />
4.     Translate Wireframes / UI Prototypes to functional user interface with best in class user experience<br />
5.     Learn and implement new technologies with mentorship from senior mentors<br />
6.     Should be a quick learner to understand and implement innovative approach to complex business requirements<br />
Skill(s) required: HTML, CSS, jQuery, Bootstrap, ReactJS, & Node js<br />
Optional Tech Skills: Python, Kafka, Kubernetes, Mongo DB, Cockroach DB<br />
Experience Required:</p>
				
				<table class="w100 formTable bdr0 mt20px">	
				<tr>
				<td class="w195 alpha75 p5px">Experience</td>
				<td class="p5px">3 - 7 Years</td>
				</tr>			
											<tr>
							<td class="alpha75 p5px">Salary</td>
							<td class="p5px"> 3  Lac  To  8  Lac  P.A.</td>
							</tr>				
											
					<tr>
					<td class="alpha75 p5px">Industry</td>
					<td class="p5px">IT Software - System Programming</td>
					</tr>
									
									<tr>
					<td class="alpha75 p5px">Qualification</td>
					<td class="p5px">Other Bachelor Degree</td>
					</tr>					
										<tr>
					<td class="alpha75 p5px">Key Skills</td>
					<td class="p5px">
											<span class="bdr dib p2px10px mr5px mt2px">react js</span>
												<span class="bdr dib p2px10px mr5px mt2px"> full stack developer </span>
												<span class="bdr dib p2px10px mr5px mt2px"> JavaScript Development</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 vat">Company Name</td>
						<td class="p5px vat"><p class="dif b">TMS</p></td>
						</tr>
												<tr>
						<td class="w195 alpha75 p5px vat">About Company</td>
						<td class="p5px vat">MNC Company Based at Kharadi</td>
						</tr>
												<tr>
						<td class="w195 alpha75 p5px">Email ID</td>
						<td class="p5px"><a href="mailto:deeptimane26@gmail.com"> deeptimane26@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="779497">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="844609"><input type="hidden" name="subject" value="Applied for Full Stack Developer (ReachJS)">
					</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">(27)</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">(4)</span><a href="jobs-in-property-construction-fid.htm" title="Real Estate / Construction Jobs">Real Estate / Construction</a></p>
										<p class="mb5px "><span class="fr">(3)</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">(3)</span><a href="jobs-in-system-programming-fid.htm" title="IT Software - System Programming Jobs">IT Software - System Programmi...</a></p>
										<p class="mb5px "><span class="fr">(3)</span><a href="jobs-in-sales-marketing-business-development-telecaller-fid.htm" title="Sales & Marketing / Business Development/telecaller Jobs">Sales & Marketing / Business D...</a></p>
										<p class="mb5px "><span class="fr">(2)</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">(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-application-programming-fid.htm" title="IT Software - Application Programming / Maintenance Jobs">IT Software - Application Prog...</a></p>
										<p class="mb5px "><span class="fr">(2)</span><a href="jobs-in-education-teaching-training-counselling-fid.htm" title="Education / Teaching / Training / Counselling / Academic Jobs">Education / Teaching / Trainin...</a></p>
										<p class="mb5px "><span class="fr">(1)</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">(1)</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-self-employed-entrepreneur-consultants-freelancers-fid.htm" title="Self Employed / Entrepreneur / Consultants / Freelancers Jobs">Self Employed / Entrepreneur /...</a></p>
										<p class="mb5px spanlist dn"><span class="fr">(1)</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 spanlist dn"><span class="fr">(1)</span><a href="jobs-in-public-relation-pr-advertising-events-fid.htm" title="Public Relation (PR) /  Advertising / Events Jobs">Public Relation (PR) /  Advert...</a></p>
										<p class="mb5px spanlist dn"><span class="fr">(1)</span><a href="jobs-in-fresh-graduate-fid.htm" title="Fresher / Trainee Jobs">Fresher / Trainee</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: 'NGZENUwvbUlUd3hGdDJlRjVKdXlCQT09',data_type: 'RExzRmw1cmRsdlh6YkJlVUZBNnA4UT09'},
	  cache : false,
	  async: true
	  
	}).done(function(resp) {
	  //alert(resp)
	});
	</script>
	";i:1;s:62:"Job openings for full stack developer in pune | Pune Placement";i:2;s:217:"Full Stack Developer (ReachJS) Jobs,Full Stack Developer (ReachJS) Jobs in Pune,Full Stack Developer (ReachJS) Vacancy in Pune,Full Stack Developer (ReachJS) jobs in India,IT Software - System Programming jobs in Pune";i:3;s:303:"Apply for Full Stack Developer (ReachJS) Jobs in Pune India - Full Stack Developer (ReachJS) Vacancy  in IT Software - System Programming field with 3 to 7 years Work Experience, Key Skills are react js, full stack developer , JavaScript Development, IT Software - System Programming jobs in Pune  India";i:4;s:2692:"
		<script type="application/ld+json">
		{
		  "@context": "http://schema.org",
		  "@type": "JobPosting",
		  "title": "Full Stack Developer (ReachJS)",
		  "baseSalary": " 3  Lac  To  8  Lac ",
		  "description": "We are looking for a versatile JavaScript developer proficient in React JS.
You’ll follow well know React JS workflows such as Flux or Redux.
You’ll also ensure that these components and the overall application are robust and easy to maintain.
Develop new user-facing features using React JS
 Build reusable components and front-end libraries for future use
Translation of designs and wireframes into high quality code
Optimize components for maximum performance across a vast array of web capable devices and browsers You will love this job if you are:
A technology addict who has a plan to stay ahead of the curve.A problem solver who jumpstarts at work to resolve issues • A continuous learner who wants to make a difference with innovation
Hands-on experience (3-6 years) of JavaScript and Node JS based solution/projects • Experience with popular React JS workflows such as Flux or Redux • Exposure to with ES6/ES7 and RESTful APIs • Familiarity with UI components library such as material-ui or Bootstrap • Knowledge of modern authorization mechanisms, such as JSON Web Token • Experience with common front-end development tools such as Babel, Webpack, NPM, etc
Responsibilities:
1.     Build a bleeding edge platform for India and global market using Python, Node.js Angular JS and other technologies
2.     You will be responsible for developing business requirements using above technologies
3.     Work with Sr Technical Leads to understand feasibility of UI & workflow requirements
4.     Translate Wireframes / UI Prototypes to functional user interface with best in class user experience
5.     Learn and implement new technologies with mentorship from senior mentors
6.     Should be a quick learner to understand and implement innovative approach to complex business requirements
Skill(s) required: HTML, CSS, jQuery, Bootstrap, ReactJS, & Node js
Optional Tech Skills: Python, Kafka, Kubernetes, Mongo DB, Cockroach DB
Experience Required:",
		  "educationRequirements": "Other Bachelor Degree",
		  "experienceRequirements": "3 - 7 Years",
		  "industry": "IT Software - System Programming",
		  "jobLocation": {
		    "@type": "Place",
		    "address": {
		      "@type": "PostalAddress",
		      "addressLocality": "Maharashtra",
		      "addressRegion": "Pune"
		    }
		  },
		 "qualifications": "Other Bachelor Degree",
		     "skills": "react js, full stack developer , JavaScript Development"
		  }
		</script>
		";i:5;N;}