Engineering Manager

As an Engineering Manager, you will lead a small group of engineers that are working on a particular facet of our products and infrastructure across the stack. You will be working closely with other stakeholders to help us achieve our goals. You will also work closely with other leaders throughout the company to build the right organisational structures and processes as we continue to grow.

As a company, we are passionate about our customers, fearless in the face of barriers, and driven by data. As an engineering team, we value bottom-up innovation and decentralised decision-making: We believe the best ideas can come from anyone in the company, and we are working hard to create an environment where everyone feels empowered to propose solutions to the challenges we face. We are looking for individuals who thrive in a fast-moving, innovative, and customer-focused setting.

Responsibilities:

• Lead a team of engineers building and operating production systems, owning delivery, quality, and costs.
• Craft a thoughtful, long-term technical strategy in collaboration with your team and other company leaders that anticipates future needs while being pragmatic about what's needed today. Set direction and ambitious goals for your team, engineering, and branch as a whole.
• Drive the full delivery cycle: scoping, sequencing, estimation, execution, and post-launch ownership across one or more concurrent initiatives.
• Be accountable for engineering standards on your team: code review culture, testing discipline, observability, security posture, and responsible AI use.
• Recruit, grow, and empower driven engineers with high expectations around ownership, impact, and technical excellence.
• Help build a culture of collaboration that embodies our values: Passionate about our customers. Fearless in the face of barriers. Driven by data.
• Be a hands-on technical contributor and mentor for your team. Not afraid to roll up your sleeves and do actual technical work when appropriate.
• Represent the team's work to the company through clear written updates, metrics, and well-run forums.

Requirements:

• 7+ years' experience building production software, with about 2 years managing engineers directly (line management, not just tech lead).
• Track record of shipping non-trivial systems end-to-end in a planned and organised manner and operating them in production at a meaningful scale.
• Strong foundation in backend or full-stack development, distributed systems, and data modelling. Comfortable being the technical decision-maker for your team. Experience in non-backend systems like AI or mobile is a plus.
• Demonstrated fluency with modern AI-assisted development workflows and a point of view on their effectiveness for various use cases.
• Experience hiring engineers and building a team's bar over time, including making hard calls on performance.
• Clear, structured written and verbal communication; comfortable operating asynchronously effectively.

Core Engineering Expectations:

• The following describes the traits we expect in our engineering managers and reflects instincts developed over years of shipping real software through teams. We do expect a genuine appreciation for why these qualities matter, an honest sense of where you stand against them, and the drive to close the gap.

Engineering craft and judgement:

• You provide architectural leadership. You see across systems, spot the coupling that'll hurt in six months, and steer the team towards designs that match the scale of the problem.
• You contribute to the codebase when it matters. Not to prove a point or compete with your engineers, but to stay grounded in the systems you are responsible for, unblock critical work, or pick up what nobody else can.
• You run reviews that raise the bar. You catch what others miss, explain why it matters, and leave engineers sharper than they were before the review.
• You balance technical excellence with business and consumer needs. You research and seek opinions to identify the best solution for a problem, not just the first one that comes to mind. You intentionally weigh technical debt, ensuring it is paid down before it compounds.
• You have a deep understanding of web fundamentals, data modelling, and distributed systems. You apply proven design patterns to build modular, scalable solutions and ensure that security, performance, and observability are baked into your work from the outset.
• You use automated testing as both a blueprint for clean architecture and a safety net for refactoring. You believe that well-designed code should be inherently testable, and you hold all contributions, whether human- or AI-generated, to the same standard of quality and maintainability.
• You are comfortable navigating and evaluating unfamiliar codebases. You can integrate into and evolve existing architectures with care, researching thoroughly and seeking peer feedback to ensure your changes improve the system without breaking it.
• You understand the full software development lifecycle. You can break down ambiguous projects into granular, estimable tasks that can be delegated effectively, ensuring a predictable and transparent path to delivery. You treat your delivery commitments as something the rest of the team plans against.
• You consider the ripple effects of your work. You think critically about how your choices impact the end user, the business, and the team's future velocity, and you have the drive to master the domain knowledge required to make those calls.
• You partner with product, design, and other functions to shape the work, not just receive it. You push back when the spec is wrong, ask the question that reframes the problem, and share ownership of whether the thing was worth building in the first place.

AI proficiency:

• You set the bar for AI use on your team. You know what good looks like, call out what doesn't, and help the engineers who haven't figured it out yet get there. You treat resistance to AI as a performance gap.
• You understand how modern AI systems work underneath: RAG, tool use, agents, MCP, evals, and their tradeoffs. Enough to make sound calls about what your team builds.
• You coach calibration. Knowing when to trust AI, when to verify, and when to override is a learned skill. You build that judgement in your engineers deliberately, not by accident.
• AI fluency is table stakes. You use AI to amplify your logic, not to replace it. You decompose ambiguous problems into clear steps and dependencies before prompting, ensuring you drive the architecture rather than allowing the AI to improvise a structure that compounds errors at high speed.
• You hold AI-generated output to the same rigorous standards as human-written code. You have the intuition to catch hallucinations of correctness, e. g., elegant-looking code that fails subtly or tests that pass without actually asserting logic, and you take total accountability for the final implementation. Your trust is calibrated through experience; you can clearly articulate your technical reasoning whenever you choose to override an AI's suggestion.
• You manage tool context deliberately to avoid "model noise" and recognise the point of diminishing returns. You know exactly when to leverage a prompt to accelerate your workflow and when to step back to solve a high-complexity problem through deep, independent thought.
• You proactively mitigate risks inherent to agentic workflows, including prompt injection, data leakage, and secret management. You treat AI-era security as a fundamental part of the engineering process, ensuring that "agentic" doesn't mean "unsecured".
• You aggressively automate the mundane so your attention is reserved for the complex logic and design decisions that actually need a human.
• You stay current with the evolving AI landscape and understand the underlying mechanics of the models and tools you use. You continuously raise your own productivity ceiling as the tools improve.

How you lead:

• You develop people. You know your engineers' strengths, their gaps, and where they want to grow. You give them work that stretches them and feedback that lands.
• You hire well. You recognise talent early, sell the role honestly, and make sharp calls under uncertainty. You also know a bad hire costs the team more than an empty seat.
• You run projects that ship. Scope, sequencing, risks, dependencies, and tradeoffs. You stay ahead of the work instead of chasing it.
• You set a clear vision and keep the team pointed at it. Anyone on your team can explain what you're building and why without checking the doc.
• You think strategically. You make decisions that hold up over quarters, not just sprints, and you can explain the reasoning to engineers, peers, and leadership in their own language.
• You exercise judgement under ambiguity. Most hard decisions don't have a clean answer. You make the call, own the outcome, and adjust when the evidence changes.
• You manage stakeholders without making it the team's problem. You absorb the noise, translate what matters, and shield the team from what doesn't.
• You understand the organization you operate in. You know how decisions actually get made, who needs to be in the room, and how to move things forward without creating friction.
• You automate your own reporting. Status updates, metrics, dashboards. Making the team's work legible shouldn't consume the team.

Operating principles:

• You hold the team's quality bar, not just your own. You don't let things ship half-done across the team's surface area, and you don't accept technical debt without a timeline to repay it. The standard your team ships at is the one you've been willing to enforce.
• You communicate up, down, and sideways with intent. You write clearly enough that decisions don't get rediscussed, run tight meetings that earn the time they take, and say hard things without dressing them up.
• You make the managers around you better, not just your own team. You share what's working, surface what isn't, and treat the broader engineering org's success as part of your job.
• You make high-velocity, high-quality decisions. You move fast where the cost of being wrong is low and reversible, slow down where it isn't, and can articulate which mode you're in and why.
• You are highly entrepreneurial and manage your own time, energy, and quality without oversight. You take the initiative to solve problems before they arise; nobody has to ask you twice, and often, nobody has to ask at all.
• You are a high-velocity learner who handles setbacks without losing momentum. You possess the grit to keep moving when things go sideways and the judgement to know exactly when to pull in help to stay on track.
• You have an uncompromising attitude towards attention to detail. You catch the inconsistent behaviour, the edge case bug, and the green test suite that doesn't actually verify anything, maintaining a high bar for the small things that define quality.
• You simplify the complex. You write with the clarity of someone who expects to be read and ask the sharp, uncomfortable questions that often reveal hidden project risks.
• You treat engineering as a team sport. You make those around you better through candid, helpful feedback, active listening, and a genuine commitment to helping your peers grow.
• You're intellectually honest. You change your mind when you're wrong, credit others when they're right, and never defend a position or a design just because it's yours.
• You operate with integrity. You make the right call when no one is watching, raise concerns early when something feels off, and treat the trust placed in you by users, teammates, and the business as something to be earned every day.
• You own what you ship. Architecting and writing the code is half the job. Testing, monitoring, documenting, and being on the hook when it breaks is the other half.
• You bring discipline to how you work with others. You communicate in structured, async-friendly ways, keep your calendar and commitments reliable, and show up for shared responsibilities and rituals that keep the team functioning.

Skills

backend, data modeling, data modelling, distributed systems, full-stack