Technical Lead, Software Development, Software Engineer

This is a real opportunity to shape how a squad builds and delivers software, at a moment when that direction is yours to influence. You will have genuine input into the technical approach, the team culture, and the outcomes, with the support of Engineering Managers and coaches around you.

We are restructuring how we build and own software. That means moving from a traditional release cycle to CI/CD, decomposing shared services into team-owned boundaries, and shifting the squad towards a genuine Dev Ops model. AI is central to how we work, not as a layer on top but embedded in how the team thinks, builds, and delivers. The goal is a truly autonomous team: one that owns its own systems, sets its own pace, and uses AI as a natural part of how it operates.

You will be hands‑on in making that happen. You will write code daily, make architectural calls, and help your engineers develop into the team we are working towards. Engineering Managers and coaches will be alongside you, but the technical direction is yours to lead.

This role will suit someone who is energised by complexity and wants to make a real difference. If you want a place where your technical decisions have visible impact, this is it.

• Lead the technical execution of a major platform restructure. This is hands‑on architecture work, not oversight.
• Drive the decomposition of shared hosted services into team‑owned libraries and services, defining the boundaries, managing the risk, and delivering the change.
• Own the move from a traditional release process to CI/CD. Build the pipelines, establish trunk‑based development, ensure fast and reliable deployments, and make continuous delivery the norm for your squad.
• Work towards a Dev Ops model where your team owns the full lifecycle, covering infrastructure, observability, and deployment. Expert support is available, and the goal is a team that grows in confidence to own it fully.
• Make pragmatic calls about technical debt in the context of active change, knowing what to tackle now and what can safely wait.

• Make architectural decisions for your product area and own the technical direction.
• Design and implement complex features hands‑on. Write production code daily.
• Lead technical discussions and design sessions, and make the call when the team needs direction.
• Run technical spikes and proof‑of‑concepts to validate approaches before full implementation.
• Balance technical excellence with delivery pragmatism.
• Collaborate with architects and other Tech Leads on decisions that cut across the wider organisation.

• Lead by example: write clean, testable, secure code that others want to emulate, and show how AI can support that standard rather than shortcut it.
• Drive TDD/BDD adoption through pairing and demonstration. Use AI to accelerate this, generating test scaffolding, exploring edge cases, and helping engineers see good practice in action more quickly.
• Own the code review culture and provide constructive, educational feedback that raises the bar for everyone.
• Embed secure coding practices across the team: threat modelling, security testing, and dependency management.
• Build observability into your systems from the start, covering instrumentation, logging, monitoring, and alerting, so that your team always has a clear picture of what their systems are doing in production.
• Manage technical debt at both the code and system level, and refactor proactively.
• Bring AI into how you reason about problems and design solutions, treating it as a core part of your engineering practice rather than an occasional tool.
• Design and build AI agents that do real work: automating repetitive engineering tasks, accelerating delivery workflows, and reducing the coordination overhead that slows teams down.
• Embed AI‑powered workflows into the team's delivery capability, from code generation and review through to testing, deployment, and observability, so that the team ships with greater speed and confidence.
• Help your engineers develop real AI fluency, including how to frame problems well, how to verify outputs…