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>Sales Director</strong></p>
<p><strong>Location: Home based (with travel around the South of the UK)</strong></p>
<p>As the UK’s favourite property platform, Rightmove aims to give everyone the belief that they can make their move. To help us achieve this, we’re looking for a Sales Director to join our Estate Agency team</p>
<p>We're looking for a dynamic and experienced senior sales leader to take on a key operational role within our team. In this position, you’ll lead and support up to four Area Directors covering the southern half of the UK. Each Area Director oversees a team of 6–7 Field-Based Account Managers. </p>
<p>As a key member of our leadership team, you’ll play a central role in shaping and delivering our agency’s strategic plan. You'll be responsible for mentoring, developing, and guiding the Area Directors - helping them grow high-performing teams and ensuring clear, effective communication across all levels. If you're a strategic thinker with a passion for leadership and growth, we’d love to hear from you. </p>
<p><strong>What you’ll be doing</strong></p>
<p>You will lead and manage the part of the UK sales teams, supporting team development, fostering key customer relationships, and driving collaboration across departments to deliver the business strategy. </p>
<ul>
<li>Manage day-to-day operations of the UK sales teams to ensure smooth performance. </li>
<li>Drive the team to consistently meet or exceed pre-defined KPIs and sales targets. </li>
<li>Set clear expectations, model desired behaviours, and create an environment that supports achieving account plans and objectives. </li>
<li>Develop and support territory and area plans to align with overall sales targets. </li>
<li>Account planning discipline: prioritisation, growth planning, and execution cadence</li>
<li>Data-led planning and decision-making; turn insight into clear actions</li>
<li>Advanced Excel and PowerPoint capability for performance storytelling and governance</li>
<li>Build and maintain strong relationships with key customers and influencers in the region. </li>
<li>Collaborate with other departments and lead by example in managing key accounts to deliver the business strategy. </li>
<li>Mentor and develop senior leaders; embed coaching-led leadership at scale</li>
<li>Performance appraisals, feedback, and development planning to raise standards</li>
<li>Build succession pipelines and strengthen leadership bench strength</li>
<li>Align leaders and teams through clear messaging, purpose, and priorities</li>
<li>Model desired behaviours; create an environment that supports delivery</li>
</ul>
<p><strong>Who you are</strong></p>
<ul>
<li>Proven experience in B2B sales management with a strong track record of success. </li>
<li>Skilled leader with a history of guiding large sales teams to consistently exceed targets. </li>
<li>Strong analytical and planning abilities</li>
<li>A true sales leader who goes beyond forecasting and administration to inspire and drive teams. </li>
<li>Excellent communicator, able to engage and influence both verbally and in writing. </li>
<li>Confident influencer who collaborates effectively with internal teams and customers to achieve goals. </li>
<li>Self-motivated and independent thinker, passionate about leading teams and driving best practices for commercial success. </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>