hackajob is collaborating with Rightmove to connect them with exceptional professionals for this role.

<p>Our vision is to give everyone the belief they can make their move. We aim to make moving simpler, by giving everyone the best place to turn to and return to for access to the tools, expertise, trust, and belief to make it happen.</p>
<p>We’re home to the UK’s largest choice of properties and are the go-to destination for millions of people planning their next move, reading the latest industry news, or just browsing what’s on the market. </p>


<p><strong>We are looking for a Product Manager - House Prices</strong></p>
<p><strong>Location: </strong>London (Hybrid) with 2 days a week in the London office        </p>
<p><strong>Reporting to: </strong>Senior Product Manager</p>
<p><strong>Business Unit: </strong>Consumer - House Prices   </p>
<p><strong>The Role </strong></p>
<p>Joining the House Prices team, you’ll help build engaging, insight-led experiences that ensure consumers turn to Rightmove first to help understand the price of their property and house prices in their local area. The team manages Rightmove’s instant valuation (track a property) tool, the sold house prices search and renovation tools. </p>
<p>The Product Development team at Rightmove plays a pivotal role in delivering the overall consumer and customer digital experience underpinning the Rightmove business.  We recognise that to deliver the best products and features for our customers and consumers we need to work together effectively as a healthy, high performing team. We work collaboratively across a mix of product and centralised teams, together working towards Rightmove’s strategy.     </p>
<p>The Product Manager role reports into a Senior Product Manager in our Consumer Domain, responsible for our Move &amp; Home pillars.</p>
<p><strong>What you’ll be doing:</strong></p>
<ul>
<li>Manage the ownership and monitoring of the products and functionality owned by the team through use of the objectives and KPIs you will define</li>
<li>Create and validate business cases that underpin the product/initiative, with clear definition of opportunity, costs, and benefit</li>
<li>Proactively contribute to initiatives that aim to improve our customer or consumer experience, both identifying your own contribution and supporting others in theirs</li>
<li>Initiate and/or undertake any analysis to highlight any impacts to systems or business processes</li>
<li>Take an active role in the experience discovery of initiatives and products, working closely with Product Designers, Researchers, and AI squads to define the approach</li>
<li>Collaborates with user experience specialists and visual designers to re-work existing experiences, as well as creating new ones</li>
<li>Spends time understanding what motivates our customers and ensuring they are up to date with industry insights</li>
<li>Generates unique ideas, resourceful in identifying opportunities, and encourages innovation within the team</li>
<li>Works with engineers, AI specialists, and technical architects to understand technology limitations, recommendations and development options</li>
<li>Accountable for requirements definition and delivery of solutions across your product/initiatives</li>
<li>Maintain a backlog of improvements for your area, clearly describing how they support our overall business goals and work with the Senior Product Manager &amp; Head of Product to prioritise these alongside the wider priorities for the domain and product function</li>
<li>Work with Senior Product Manager &amp; the Head of Product to help shape the strategic direction, vision and objectives for Search based on clear rational, analysis and insights</li>
</ul>
<p><strong>We’re looking for someone who:</strong></p>
<ul>
<li>Can lead product discovery, culminating in clear recommendations and, where relevant, the best approaches for delivery </li>
<li>Has experience delivering successful end-to-end delivery of software products in a technology-led company </li>
<li>Takes responsibility for a product and deliver it with an autonomous delivery team  </li>
<li>Makes data informed decisions, leveraging quantitative and qualitative insights </li>
<li>Is passionate about delivering quality experience and software to end users  </li>
<li>Has excellent organisational and prioritisation skills with the ability to multitask and make tough calls </li>
<li>Effectively manages relationships with key stakeholders, ensuring clear communication, alignment on product goals, and collaboration throughout the product lifecycle </li>
<li>Sets and measures clear, realistic and timely goals  </li>
<li>Builds a deep understanding of how an organisation is run, both commercially and operationally </li>
<li>Actively encourages contributions from all those around them recognising the value of team members input when solving problems </li>
<li>Thinks long term, and will drive the vision for the product their team is working on </li>
<li>Has found the agile philosophy to be second nature </li>
<li>Comfortable describing the technical implementation of their product </li>
<li>Desire to learn and improve themselves and the processes within the team </li>
<li>Is equally comfortable and engaged negotiating the roadmap with product leaders, presenting to senior leaders, or discussing implementation with our engineers. </li>
</ul>
<h3><strong>About Rightmove</strong></h3>
<p>Our vision is to give everyone the belief that they can make their move. We aim to make moving simpler, by giving everyone the best place to turn to and return to for access to the tools, expertise, trust and belief to make it happen.</p>
<p>We're home to the UK's largest choice of properties, and are the go-to destination for millions of people planning their next move, reading the latest industry news, or just browsing what's on the market.</p>
<p>Despite this growth, we’ve remained a friendly, supportive place to work, with employee #1 still working here!  We’ve done this by placing the Rightmove Hows at the heart of everything we do. These are the essential values that reflect our culture, and include:</p>
<ul>
<li><strong>We create value…</strong>by delivering results and building trust with partners and consumers.</li>
<li><strong>We think bigger…</strong>by acting with curiosity and setting bold aspirations.</li>
<li><strong>We care deeply…</strong>by being real, having fun, and valuing diversity.</li>
<li><strong>We move together…</strong>by being one team - internally collaborative, externally competitive.</li>
<li><strong>We make a difference…</strong>by focusing on delivering measurable impact.</li>
</ul>
<p>We believe in careers that open doors and help our team develop by providing an open and inclusive work environment, offering ongoing training opportunities, and supporting charity fundraising events. And with <strong>88% of Rightmovers saying we’re a great place to work</strong>, we’re clearly doing something right!<strong> </strong></p>
<p><strong>If all of this has caught your eye, you may well be a Rightmover in the making......<br></strong></p>
<strong>People are the foundation of Rightmove - We’ll help you build a career on it.</strong>
<strong>What we offer </strong>
<ul>
<li>Cash plan for dental, optical and physio treatments.</li>
<li>Private Medical Insurance, Pension and Life Insurance, Employee Assistance Plan.</li>
<li>27 days holiday plus two (paid) volunteering days a year to give back, and holiday buy schemes.</li>
<li>Hybrid working pattern with 2 days in the office.</li>
<li>Contributory stakeholder pension.</li>
<li>Life assurance at 4x your basic salary to a spouse, family member or other nominated person in your life.</li>
<li>Competitive compensation package.</li>
<li>Paid leave for maternity, paternity, adoption &amp; fertility.</li>
<li>Travel Loans, Bike to Work scheme, Rental Deposit Loan.</li>
<li>Charitable contributions through Payroll Giving and donation matching.</li>
<li>Access deals and discounts on things like travel, electronics, fashion, gym memberships, cinema discounts and more.</li>
</ul>

<em>As an Equal Opportunity Employer, Rightmove will never discriminate based on age, disability, sex, race, religion or belief, gender reassignment, marriage / civil partnership, pregnancy/maternity or sexual orientation. <br></em><br><em>At Rightmove, we believe that a diverse and inclusive workforce leads to better innovation, productivity, and overall success., We are committed to creating a welcoming and inclusive environment for all employees, regardless of their background or identity, to develop and promote a diverse culture that reflects the communities we serve.</em> 

<p>By applying, you confirm that you are aged at least 18 or over and that you’ve read and understood our</p><p>Privacy Policy</p><p>, which explains how we handle and protect your personal information during the recruitment process.</p>