a:6:{i:0;s:10228:"					<section class="headBg theme2 ">
					<div class="wrap">
					<div class="page-title-inner fo"> 
					<div class="h1"><h1>Php Developer Opencart</h1></div>
					<p class="breadcrumb ar uu small"><a href="https://www.freeworkindia.com/" title="Home">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b><a href="https://www.freeworkindia.com/current-jobs.htm" title="Current Jobs">Current Jobs</a>
																
					<b class="ffv p2px">&rsaquo;</b> Php Developer Opencart</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-->
				
								<p class="mb5px"><i class="fa fa-briefcase mr7px fl w15px alpha50"></i> 1 - 3 Years</p>
				
									<p class="mb10px"><i class="fa fa-map-marker mr7px fl pl1px w15px alpha50"></i>Noida</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="858118">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="879686"><input type="hidden" name="subject" value="Applied for Php Developer Opencart">
					</form>
					</div>
			
						
				
				<br>
				<div class="bdrT pt20px">
				<p class="xlarge b">Job Description</p>
				<p class="aj mt10px">We are Seeking Wordpress Developer Responsible for Both Back-end and Front-end Development, Including Creating Wordpress Themes and Plugins. this Position Requires a Combination of Programming Skills) and Aesthetics (understanding Element Arrangements On the Screen, the Color and Font Choices, and So On). the Candidate Should have a Strong Understanding of Industry Trends and Content Management Systems. Experience with the Responsive and Adaptive Design is Strongly Preferred. Also, An Understanding of the Entire Web Development Process, Including Design, Development, and Deployment is Preferred.<br />
responsibilities and Duties<br />
designing and Implementing New Features and Functionality<br />
establishing and Guiding the Website’s Architecture<br />
ensuring High-performance and Availability, and Managing all Technical Aspects of the Cms<br />
helping Formulate An Effective, Responsive Design and Turning It Into a Working Theme and Plugin.<br />
skills and Qualifications<br />
good Understanding of Front-end Technologies, Including Html5, Css3, Javascript, Jquery<br />
experience Building User Interfaces for Websites And/or Web Applications<br />
experience Designing and Developing Responsive Design Websites<br />
comfortable Working with Debugging Tools like Firebug, Chrome Inspector, Etc.<br />
ability to Understand Css Changes and Their Ramifications to Ensure Consistent Style Across Platforms and Browsers<br />
ability to Convert Comprehensive Layout and Wireframes Into Working Html Pages<br />
knowledge of How to Interact with Restful Apis and Formats (json, Xml)<br />
prficient Understanding of Code Versioning Tools {{such as Git, Svn, and Mercurial}}<br />
strong Understanding of Php Back-end Development<br />
key Skills<br />
php, Wordpress, Html5, Css3, Javascript, Mysql</p>
				
				<table class="w100 formTable bdr0 mt10px">				
											<tr>
							<td class="w22 alpha75 p5px">Salary</td>
							<td class="p5px"> 1  Lac  25 Thousand  To  3  Lac  50 Thousand  P.A.</td>
							</tr>				
											
					<tr>
					<td class="w22 alpha75 p5px">Industry</td>
					<td class="p5px">IT Software - Application Programming / Maintenance</td>
					</tr>
									<tr>
				<td class="w22 alpha75 p5px">Work Experience</td>
				<td class="p5px">1 - 3 Years</td>
				</tr>
									<tr>
					<td class="w22 alpha75 p5px">Qualification</td>
					<td class="p5px">Other Bachelor Degree, B.A, B.Arch, B.C.A, B.B.A, Other Master Degree, Post Graduate Diploma</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">PHP</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> wordpress</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> HTML5</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> css3</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> JavaScript</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> PHP</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> PHP Development</span>
												<span class="bn dib p5px10px c2px headVr mr7px mb7px"> PHP Programming</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">Mr. Gagan sharma</td>
						</tr>					
												<tr>
						<td class="w22 alpha75 p5px">Address</td>
						<td class="p5px">R - 28 Vani vihar uttam nagar new delhi  110059</td>
						</tr>					
												<tr>
						<td class="w22 alpha75 p5px">Mobile </td>
						<td class="p5px">9958229227 </td>
						</tr>
												<tr>
						<td class="w22 alpha75 p5px">Email ID</td>
						<td class="p5px"><a href="mailto:indiafreework@gmail.com"> indiafreework@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="858118">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="879686"><input type="hidden" name="subject" value="Applied for Php Developer Opencart">
					</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-delhi.htm" title="Jobs in Delhi">Delhi</a> <b class="alpha50 bn small">(4)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-ghaziabad.htm" title="Jobs in Ghaziabad">Ghaziabad</a> <b class="alpha50 bn small">(5)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-gurgaon.htm" title="Jobs in Gurgaon">Gurgaon</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-noida.htm" title="Jobs in Noida">Noida</a> <b class="alpha50 bn small">(2)</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-application-programming-fid.htm" title="IT Software - Application Programming / Maintenance Jobs">IT Software - Application Programming / Maintenance</a> <b class="alpha50 bn small">(5)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-ecommerce-internet-marketing-fid.htm" title="IT Software - Ecommerce / Internet Technologies Jobs">IT Software - Ecommerce / Internet Technologies</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-call-center-medical-transcription-fid.htm" title="ITES / BPO / KPO / LPO / Customer Service / Operations Jobs">ITES / BPO / KPO / LPO / Customer Service / Operations</a> <b class="alpha50 bn small">(1)</b></span>
										<span class="dib p5px10px c2px headVr mr7px mb7px "><a class="dif" href="jobs-in-advertisement-marketing-fid.htm" title="Marketing / Advertising / PR / Media Planning Jobs">Marketing / Advertising / PR / Media Planning</a> <b class="alpha50 bn small">(1)</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">(5)</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: 'ZG1yVXhOUGl6UkRIRzQrWXE2clRFZz09',data_type: 'RExzRmw1cmRsdlh6YkJlVUZBNnA4UT09'},
	  cache : false,
	  async: true
	  
	}).done(function(resp) {
	  //alert(resp)
	});
	</script>
	";i:1;s:101:"Php Developer Opencart Jobs in Noida - Vacancy in IT Software - Application Programming / Maintenance";i:2;s:207:"Php Developer Opencart Jobs,Php Developer Opencart Jobs in Noida,Php Developer Opencart Vacancy in Noida,Php Developer Opencart jobs in India,IT Software - Application Programming / Maintenance jobs in Noida";i:3;s:350:"Apply for Php Developer Opencart Jobs in Noida India - Php Developer Opencart Vacancy  in IT Software - Application Programming / Maintenance field with 1 to 3 years Work Experience, Key Skills are PHP, wordpress, HTML5, css3, JavaScript, PHP, PHP Development, PHP Programming, IT Software - Application Programming / Maintenance jobs in Noida  India";i:4;s:2641:"
		<script type="application/ld+json">
		{
		  "@context": "http://schema.org",
		  "@type": "JobPosting",
		  "title": "Php Developer Opencart",
		  "baseSalary": " 1  Lac  25 Thousand  To  3  Lac  50 Thousand ",
		  "description": "We are Seeking Wordpress Developer Responsible for Both Back-end and Front-end Development, Including Creating Wordpress Themes and Plugins. this Position Requires a Combination of Programming Skills) and Aesthetics (understanding Element Arrangements On the Screen, the Color and Font Choices, and So On). the Candidate Should have a Strong Understanding of Industry Trends and Content Management Systems. Experience with the Responsive and Adaptive Design is Strongly Preferred. Also, An Understanding of the Entire Web Development Process, Including Design, Development, and Deployment is Preferred.
responsibilities and Duties
designing and Implementing New Features and Functionality
establishing and Guiding the Website’s Architecture
ensuring High-performance and Availability, and Managing all Technical Aspects of the Cms
helping Formulate An Effective, Responsive Design and Turning It Into a Working Theme and Plugin.
skills and Qualifications
good Understanding of Front-end Technologies, Including Html5, Css3, Javascript, Jquery
experience Building User Interfaces for Websites And/or Web Applications
experience Designing and Developing Responsive Design Websites
comfortable Working with Debugging Tools like Firebug, Chrome Inspector, Etc.
ability to Understand Css Changes and Their Ramifications to Ensure Consistent Style Across Platforms and Browsers
ability to Convert Comprehensive Layout and Wireframes Into Working Html Pages
knowledge of How to Interact with Restful Apis and Formats (json, Xml)
prficient Understanding of Code Versioning Tools {{such as Git, Svn, and Mercurial}}
strong Understanding of Php Back-end Development
key Skills
php, Wordpress, Html5, Css3, Javascript, Mysql",
		  "educationRequirements": "Other Bachelor Degree, B.A, B.Arch, B.C.A, B.B.A, Other Master Degree, Post Graduate Diploma",
		  "experienceRequirements": "1 - 3 Years",
		  "industry": "IT Software - Application Programming / Maintenance",
		  "jobLocation": {
		    "@type": "Place",
		    "address": {
		      "@type": "PostalAddress",
		      "addressLocality": "Uttar Pradesh",
		      "addressRegion": "Noida"
		    }
		  },
		 "qualifications": "Other Bachelor Degree, B.A, B.Arch, B.C.A, B.B.A, Other Master Degree, Post Graduate Diploma",
		     "skills": "PHP, wordpress, HTML5, css3, JavaScript, PHP, PHP Development, PHP Programming"
		  }
		</script>
		";i:5;N;}