a:6:{i:0;s:9393:"					<div id="append2PageTittle">
    				<div class="page-title-inner bread-right head-inner fo">
    				<div id="breadcrumb">
					<div class="h1"><h1>Job openings for data product manager in kochi</h1></div>
					<p class="breadcrumb ar uu small"><a href="https://www.adihrconsulting.com/" title="Home">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b><a href="https://www.adihrconsulting.com/current-jobs.htm" title="Current Jobs">Current Jobs</a>
																
					<b class="ffv p2px">&rsaquo;</b> Job openings for data product manager in kochi</p>
					</div>
					</div>
					</div>
					<script>jQuery('#breadcrumbA').append(jQuery('#append2PageTittle').html());jQuery('#append2PageTittle').remove()</script>
									<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">Data Product Manager</div>
									<p class="mt7px fw6">Kochi</p>
									
				<br>
				<p class="aj mt7px">Update: Important to note (Mandatory): <br />
•	Experience with 1st party, 2nd party, 3rd party, multiple party data Eg. CRM, is good to have.<br />
•	Experience in identity based data with a SaaS platform<br />
•	Management of the Product's Back-end process<br />
•	This is a "Data Centric" role and not business development or other functions.<br />
•	Relevant AdTech experience is essential. (Even if less than 3 years)<br />
<br />
Qualifications<br />
5-10 years’ experience in a Product Management role, that involves the integration of multiple teams to deliver the product.<br />
A minimum of 3 years of (recent) experience in the enterprise product domain with exposure to big data systems<br />
Exposure to data delivery systems - Real-Time APIs at scale<br />
Hands-on product envisaging, coordinating, and development experience, preferably in a Data-based product.<br />
Understanding of Big Data environments and technologies. Knowledge of SaaS business models and enabling technologies such as the AWS ecosystem.<br />
Experience leading an Agile product or engineering team.<br />
Client-facing product ownership experience is a plus, though not mandatory.<br />
Software Engineering experience at the start of the career is a plus, though not mandatory.</p>
				
				<table class="w100 formTable bdr0 mt20px">	
				<tr>
				<td class="w195 alpha75 p5px">Experience</td>
				<td class="p5px">5 - 10 Years</td>
				</tr>			
											<tr>
							<td class="alpha75 p5px">Salary</td>
							<td class="p5px"> 17  Lac  To   22 Lac  50 Thousand  P.A.</td>
							</tr>				
											
					<tr>
					<td class="alpha75 p5px">Industry</td>
					<td class="p5px">IT Software - Application Programming / Maintenance</td>
					</tr>
									
									<tr>
					<td class="alpha75 p5px">Qualification</td>
					<td class="p5px">B.Tech/B.E, M.B.A/PGDM</td>
					</tr>					
										<tr>
					<td class="alpha75 p5px">Key Skills</td>
					<td class="p5px">
											<span class="bdr dib p2px10px mr5px mt2px">Product Management</span>
												<span class="bdr dib p2px10px mr5px mt2px"> saas business models</span>
												<span class="bdr dib p2px10px mr5px mt2px"> big data</span>
												<span class="bdr dib p2px10px mr5px mt2px"> data delivery systems</span>
												<span class="bdr dib p2px10px mr5px mt2px"></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">FullContact Technologies Pvt Ltd</p></td>
						</tr>
												<tr>
						<td class="w195 alpha75 p5px vat">About Company</td>
						<td class="p5px vat">FullContact is a mass-scale Identity Resolution leader that connects fragmented customer data using social, digital and traditional consumer identifiers, plus provides extensive audience insights. FullContact provides marketers, agencies, media firms, and customer service providers with trusted, relevant and real-time data to deliver enhanced customer experiences in the moments that matter. FullContact’s consumer business, Contacts Plus, is one of the most popular contact management applications in the mobile world with more than 20MM users. We are a truly global company with headquarters in Denver, Colorado, and presence in Latvia, Israel, and India. The India office of FullContact is located in Kochi and houses over 130 associates. The FullContact India office is now certified as a Great Place to Work®. FullContact is ranked #29 on OUTSIDE’s Best Places to Work 2017 list. Plus, FullContact, Inc. is listed #1100 among USA's Inc 5000 list of fastest-growing private companies. Read more: www.fullcontact.com About FullContact Culture and Values We at FullContact believe in being awesome with people. FullContact is built on the strong fundamentals of our core values. We look forward to welcoming the candidates who can match our values and competencies. Read about our values at http://fullcontact.com/about</td>
						</tr>
												<tr>
						<td class="w195 alpha75 p5px">Email ID</td>
						<td class="p5px"><a href="mailto:hiring@adihrconsulting.com"> hiring@adihrconsulting.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="754737">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="918536"><input type="hidden" name="subject" value="Applied for Data Product Manager">
					</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-gurgaon.htm" title="Jobs in Gurgaon">Gurgaon</a> <b class="alpha50 bn small">(3)</b></span>
										<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-kochi.htm" title="Jobs in Kochi">Kochi</a> <b class="alpha50 bn small">(2)</b></span>
										<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-bangalore.htm" title="Jobs in Bangalore">Bangalore</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">(4)</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">(1)</span><a href="jobs-in-erp-crm-edp-software-fid.htm" title="IT Software- ERP / CRM / EDP / MIS Jobs">IT Software- ERP / CRM / EDP /...</a></p>
										<p class="mb5px "><span class="fr">(1)</span><a href="jobs-in-computers-it-fid.htm" title="IT Hardware / Technical Support / Telecom Engineering Jobs">IT Hardware / Technical Suppor...</a></p>
										<p class="mb5px "><span class="fr">(1)</span><a href="jobs-in-sales-marketing-fid.htm" title="Sales/Marketing Jobs">Sales/Marketing</a></p>
										<p class="mb5px "><span class="fr">(1)</span><a href="jobs-in-legal-services-fid.htm" title="Legal / Law Services / Judiciary Jobs">Legal / Law Services / Judicia...</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: 'RC9hQ0s4eHR2TXZGemZYWTRPRVJiUT09',data_type: 'RExzRmw1cmRsdlh6YkJlVUZBNnA4UT09'},
	  cache : false,
	  async: true
	  
	}).done(function(resp) {
	  //alert(resp)
	});
	</script>
	";i:1;s:68:"Job openings for data product manager in kochi | ADI HR & Consulting";i:2;s:199:"Data Product Manager Jobs,Data Product Manager Jobs in Kochi,Data Product Manager Vacancy in Kochi,Data Product Manager jobs in India,IT Software - Application Programming / Maintenance jobs in Kochi";i:3;s:343:"Apply for Data Product Manager Jobs in Kochi India - Data Product Manager Vacancy  in IT Software - Application Programming / Maintenance field with 5 to 10 years Work Experience, Key Skills are Product Management, saas business models, big data, data delivery systems,, IT Software - Application Programming / Maintenance jobs in Kochi  India";i:4;s:1955:"
		<script type="application/ld+json">
		{
		  "@context": "http://schema.org",
		  "@type": "JobPosting",
		  "title": "Data Product Manager",
		  "baseSalary": " 17  Lac  To   22 Lac  50 Thousand ",
		  "description": "Update: Important to note (Mandatory): 
•	Experience with 1st party, 2nd party, 3rd party, multiple party data Eg. CRM, is good to have.
•	Experience in identity based data with a SaaS platform
•	Management of the Product's Back-end process
•	This is a "Data Centric" role and not business development or other functions.
•	Relevant AdTech experience is essential. (Even if less than 3 years)

Qualifications
5-10 years’ experience in a Product Management role, that involves the integration of multiple teams to deliver the product.
A minimum of 3 years of (recent) experience in the enterprise product domain with exposure to big data systems
Exposure to data delivery systems - Real-Time APIs at scale
Hands-on product envisaging, coordinating, and development experience, preferably in a Data-based product.
Understanding of Big Data environments and technologies. Knowledge of SaaS business models and enabling technologies such as the AWS ecosystem.
Experience leading an Agile product or engineering team.
Client-facing product ownership experience is a plus, though not mandatory.
Software Engineering experience at the start of the career is a plus, though not mandatory.",
		  "educationRequirements": "B.Tech/B.E, M.B.A/PGDM",
		  "experienceRequirements": "5 - 10 Years",
		  "industry": "IT Software - Application Programming / Maintenance",
		  "jobLocation": {
		    "@type": "Place",
		    "address": {
		      "@type": "PostalAddress",
		      "addressLocality": "Kerala",
		      "addressRegion": "Kochi"
		    }
		  },
		 "qualifications": "B.Tech/B.E, M.B.A/PGDM",
		     "skills": "Product Management, saas business models, big data, data delivery systems,"
		  }
		</script>
		";i:5;N;}