Defaqto
Principal Software Engineer
East Devon
Posted about 19 hours ago
Get notified of more jobs like this · No spam, ever
How your CV stacks up
1Upload CV
2Analyse CV
3Improve CV
Upload your CV to see how well it fits this job role
?%
Department: Technology Location: London
Description
Defaqto is one of the most trusted names in UK financial services research and ratings, and our technology turns deep market data into decisions that advisers, providers and consumers rely on every day. The credibility of that output rests on the quality of our engineering.
We are looking for a Principal Software Engineer to be the most senior individual contributor in our Technology function. Reporting to the Head of Engineering and working closely with the CTO, you will own how we build software at Defaqto: our engineering standards and practices, our technical direction, and above all the shift from AI-assisted coding towards AI-led delivery, with engineers directing and verifying rather than typing.
This is a hands-on technical leadership role without the requirement of management, unless you are keen to do so. You will guide several squads, earning influence through judgement, craft and delivered outcomes. You will also take direct technical ownership of the initiatives that carry the most technical risk or the most upside at any given time. Our current focus is opening Defaqto data to developers and AI agents through well-governed APIs and MCP servers, but the role is defined by the level you operate at, not by any one product — expect what you own to change as our priorities do.
You will also be a genuine sounding board for technology leadership, as comfortable shaping a multi-year technical strategy as unblocking a production problem this afternoon. If you are the engineer other engineers go to when a decision really matters, and you want the remit to raise the bar across a whole organisation rather than a single team, this is that role.
What you'll do
Lead our shift from AI-assisted coding to AI-led delivery
- Own the trajectory: take us from engineers using assistants to help write code, to engineers directing agents that write it — with the human firmly in the loop as architect, reviewer and accountable owner rather than as the typist.
- Define what good looks like at each step of that shift: context and prompt engineering, agent-readable codebases (clear structure, strong typing, rich tests, machine-readable specs and repository guidance), and tooling that makes agent output reproducible rather than lucky.
- Make the review layer the new craft. Raise our standards for reading, verifying and hardening generated code: tests as the contract, static analysis and security scanning inside the loop, and no unreviewed AI-authored change reaching production.
- Rebuild our practices around specification over syntax, so engineers spend their time on problem framing, acceptance criteria, architecture and verification instead of on implementation keystrokes.
- Run structured experiments with new models, agents and workflows. Measure lead time, change failure rate, review burden and developer experience, and retire anything that does not earn its place.
- Set the guardrails that make this safe in a regulated business: secure and licence-aware tooling, provenance and auditability for generated code, client and personal data kept inside approved boundaries, and a named human accountable for everything that ships.
- Take the organisation with you. Coach engineers through the identity shift from writing code to engineering outcomes, and make the sceptics as fluent as the enthusiasts.
Turn developer practices into engineering practices
- Move us beyond individual developer habits to engineering discipline that holds at organisational scale — and at the change volume that agentic delivery produces.
- Codify practice into the paved road: templates, scaffolds, pipelines, linters, policy-as-code, automated checks and agent instructions, so the right thing is the easy thing for humans and agents alike.
- Define, document and continuously evolve the engineering standards that apply across Defaqto Technology — code review, testing, branching, observability, security by design, documentation and definition of done.
- Hold the line on quality in a way teams welcome: coaching, pairing and reviewing rather than policing. Be our evangelist for software craftsmanship, and help raise the hiring bar to match it.
Reasons to use Rodeo
Start with a chat, not a search bar
Grad scheme, placement, apprenticeship? Not sure what you want yet — that's fine. Your agent talks it through with you and turns "I have no idea" into a shortlist.
It searches the market for you
Every day your agent scans the market matching roles against what actually matters to you, not just keywords on a CV.
Only hits
No noise. No "maybe this fits." Just roles with a clear explanation of why they're right — and where to focus when applying.
Take hands-on technical ownership of the problems that matter most
- Own the initiatives that carry the most technical risk or the most upside, end to end — architecture, build, launch and the operational reality afterwards. What that is will change as our priorities do; the level at which you operate will not.
- Design platforms and integration surfaces for both the consumers we have and the ones we are gaining: human developers and AI agents. Machine-readable capability discovery, unambiguous tool definitions, MCP servers and other agent-facing interfaces where they fit, semantics an agent can reason over, predictable errors, idempotency, and rate limiting that behaves sensibly under agentic access patterns.
- Build data governance into the technology rather than into a policy handbook: entitlements and licensing enforced at the point of access, per-consumer scoping, lineage and provenance carried with the data, and full audit of which human or agent accessed what, and when.
- Make quality and trust observable — data contracts, freshness and quality signals exposed to consumers, and semantics clear enough that a consumer cannot silently misread a rating or a field.
- Care about the consumption experience end to end: self-service onboarding, keys and sandboxes, SDKs, documentation as a product, usage analytics, versioning and deprecation. Treat time to first successful call, by a person or an agent, as a metric you own.
Partner with Product to add technology value
- Act as the technical validation point for product ideas, pressure-testing feasibility, cost, risk and sequencing early, before commitments are made.
- Bring technology-led opportunities to the table: things our data, platform and AI capability make possible that Product had not thought to ask for.
- Translate between commercial intent and technical reality in both directions, without diluting either.
Guide squads and evolve the tech stack
- Guide multiple teams within your squad towards sound, well-supported technology choices, and away from novelty for its own sake.
- Own continuous improvement of the tech stack with clear, valued outcomes: every material change carries a stated benefit, a measure and a migration plan.
- Lead the architecture decisions that cross team boundaries, document them as ADRs, and keep our technical debt position honest and visible.
Be a strategic and tactical sounding board
- Act as trusted counsel to the Head of Engineering, the CTO and the wider leadership team on both long-range strategy and this week’s trade-offs.
- Represent engineering reality in commercial, regulatory and roadmap conversations.
- Stay hands-on — build, review and verify on the work that matters most.
What you'll need to succeed:
Essential requirements:
- Substantial commercial software engineering experience, including time at staff, principal or equivalent level, with a track record of technical influence well beyond your own team.
- Deep, current, hands-on engineering ability in a modern stack, with the breadth to stay credible outside your strongest language. Our core stack is a mix of.NET / C# and TypeScript on Azure, Python and PHP, with SQL and modern data tooling.
- Real, evidenced experience leading agentic and AI-assisted development in a production engineering organisation — not just personal use of an assistant. You can show how you changed a team’s practices, what you measured, and how you kept quality and accountability intact.
- A clear point of view on the engineering practices that make AI-led delivery work: specification and context engineering, test-first contracts, agent-readable codebases, and review as a first-class discipline.
- Demonstrable ownership of engineering standards and practices across multiple teams: you have written them, embedded them in tooling, and actually changed behaviour with them.
- Strong API and integration engineering: designing, versioning, securing and operating interfaces consumed by other people’s systems — and increasingly by their agents — with real care for the consumer experience around them.
- Treats data governance as an engineering problem: entitlements, licensing, lineage, provenance and auditability enforced in the technology rather than asserted in a policy document.
- Sound distributed systems and cloud architecture judgement — resilience, observability, performance, cost and operability, not just diagrams.
- Excellent influencing and communication skills: you build consensus across teams and can hold your own with product, commercial and executive audiences.
- Commercial instinct — you tie technical work to outcomes the business recognises and can measure.
- A mentoring track record: senior engineers have become materially better because they worked with you.
- Comfort with a moving remit. You are motivated by owning whichever problem is hardest right now, not by owning one system indefinitely.
Get help with your application
Your very own career expert that helps elevate your application to the next level.
Desirable requirements:
- Experience building or operating agent-facing integration surfaces — MCP servers, tool-calling interfaces or similar.
- Financial services, fintech or regulated data experience, and comfort treating FCA and UK GDPR / ICO expectations as design constraints rather than afterthoughts.
- Experience with data products, business intelligence or analytics platforms — data modelling, contracts, quality, lineage and entitlements.
- Experience of a developer portal, API marketplace or platform-as-a-product.
- Platform engineering and developer experience work: CI/CD, internal developer platforms, golden paths, policy-as-code and self-service tooling.
- Event-driven architecture, and experience of legacy modernisation or migration programmes.
- Contribution to the wider engineering community — open source, writing, speaking or standards work.
Your approach to work:
- Pragmatic. You optimise for outcomes and maintainability, not for elegance or novelty.
- Generous. You make other engineers better, and you take real pleasure in it.
- Evidence-led. You hold strong opinions loosely and change your mind when the data says so.
- Direct and kind. You disagree well, in the open, and commit fully once a decision is made.
- Curious and current. You keep learning fast in a field that is moving fast, and you bring what you learn back to the organisation.
Trusted by 25,000+ job seekers
“It took my CV and asked me questions relevant to understanding what kind of jobs to suggest for me. Suggestions were almost perfect. Jobs were exactly what I’ve been looking for.”
Jessica, London