Responsibilities
- Manage your own and your team's time while adhering to priorities set by the company
- Own complex engineering problems end-to-end, from problem framing and design through to delivery and iteration
- Take responsibility for critical areas of the platform, ensuring they remain reliable, performant, and maintainable
- Build new features and improve existing ones across our platforms.
- Refactor legacy and modern codebases pragmatically, balancing long-term health with delivery needs
- Write tests (unit, integration, and end-to-end) to ensure software reliability.
- Be involved in every phase of the software lifecycle, from ideation to deployment.
- Participate in (and at times lead) deep technical discussions, helping drive sound decisions and trade-offs
- Work hands-on across backend and frontend systems, stepping in wherever the problem lives
- Identify inefficiencies and help streamline workflows, reducing unnecessary work.
- Collaborate closely with other senior engineers, raising the bar through example rather than authority
- Take ownership of your work, ensuring high-quality results and maintainable solutions.
Requirements
- You're a Principal-Level Engineer first.
- You understand the system most deeply and keep the clearest head under pressure.
- You hire, you steer, you unblock, but you do it the way a strong engineer does everything: with good judgment, minimal ceremony, and no interest in making it a bigger deal than it is.
- You are still, genuinely, happiest close to the code and driving projects forward.
- You are also more than happy to take ownership over driving them forward.
- Programming languages don't impress you. You've used enough of them to treat them as what they are: different syntaxes for expressing the same fundamental ideas, some more suited to the problem than others, none worth being religious about.
- You've written things in languages that no longer exist, maintained systems built on frameworks that peaked at a conference talk in 2013, and learned the hard way that novelty and progress are not the same thing.
- When you join a new codebase, you go quiet and start reading.
- You find the abstractions that are holding up weight, identify the ones that are just decorative, and build a mental model of the whole thing before you touch anything.
- Then you make one small, careful change, and the way it lands tells you everything you didn't yet know.
- You have strong, well-earned instincts around performance.
- Hot-path optimisation, speculative execution, lazy initialisation: these feel obvious to you, and you've mostly stopped being surprised when they don't feel obvious to others.
- You know where latency actually hides, and it's rarely where the team thinks it is.
- You profile before you optimize, but you usually already know what you're going to find.
- Your system design isn't flashy. It's load-bearing.
- You've seen enough over-engineered architectures to have a near-allergic reaction to complexity that isn't earning its keep.
- When you design something, it's because you've thought about what it needs to do in two years, not just the next sprint.
- Once you've got your footing in the project, you'll build the team around it.
- You know how to hire for this kind of work.
- You're looking for engineers with genuine curiosity, sound instincts, and the humility to learn a system before trying to improve it.
- You'll form a team that can own hard problems.
- Getting that right is important to you, but it's not where you live. Where you live is in the work itself.
- In a well-reasoned commit.
- In a system that behaves exactly as it should at 3am when nobody's watching.
- In the quiet satisfaction of a codebase that's a little more honest than it was before you touched it.
- The homelab is always running something.
Team
Structure: You're the person the team orbits around.
