System Design and Domain Modeling

• Design services and system boundaries that reflect the business domain rather than the current org chart or the shape of last year’s database.
• Apply domain-driven design in practice: bounded contexts, aggregates, ubiquitous language, and context mapping between teams. We expect you to have used it, not just read about it.
• Model the private capital domain carefully — funds, portfolio companies, positions, valuations, as-of dates, restatements — and keep the model honest as the product grows.
• Own your services end to end: implementation, tests, CI/CD, deployment, observability, and the on-call that comes with them.

Collaboration and Technical Leadership

• Work directly with product leadership to shape what gets built, challenge assumptions, and turn a vague opportunity into a scoped, shippable feature.
• Partner with Data Engineering, ML, and other product verticals on contracts and interfaces so the same problem doesn’t get solved three times.
• Drive technical initiatives across the domain, not just within your team: shared patterns for AI features, evaluation tooling, domain models, or the standards that keep our services consistent.
• Raise the bar around you through design review, code review, and mentorship. Senior engineers here are expected to make other engineers better.
• Write clearly. A design doc that survives review is part of the job.

What You Bring

• Strong software engineering experience with production ownership of what you build. We hire at mid-level and senior; what differs is scope and the breadth of what you’ve led, not the standard of craft.
• Full-stack capability with real depth on the backend. You can design a service, reason about its failure modes, and still build the interface where the feature lands.
• Demonstrated system design ability: you can take an ambiguous problem, propose two or three viable architectures, and explain the trade-offs without hiding behind diagrams.
• Strong practical understanding of domain-driven design, and the judgement to know when a lighter approach is the right call.
• Language-agnostic engineering strength. We use TypeScript, Java, and Python, and you should be productive in at least one of them and willing to work across all three. We care that you understand systems, not that you’ve specialised in our stack.
• Hands-on experience building with LLMs or other probabilistic components in a product context: prompting and context design, retrieval, structured output, tool and function calling, agent orchestration, and evaluation.
• A clear point of view on where AI belongs in a system and where it doesn’t, formed by having shipped something and watched it behave in production.
• Comfort with modern delivery practice: automated testing, CI/CD, containers and Kubernetes, and observability as a first-class concern.
• Strong business sense. You understand who uses what you build and why it matters to them, and you make trade-offs accordingly. SaaS or FinTech experience is not required; curiosity about the domain and the discipline to learn it is.
• Self-direction. You find the important work, scope it, and drive it without waiting for a ticket.
• Experience in a fast-growing company where the roadmap, the team, and the requirements all change at once is a strong plus.

How You Work With AI

We’re an AI-first company, and that has to mean something more than having a coding assistant installed. We expect engineers here to have genuinely changed how they work.

• You use AI as a working tool across the job, not just in the editor: exploring unfamiliar code and data, generating test cases and edge-case inputs, drafting and reviewing designs, triaging production issues, and writing the documentation nobody else wants to write.
• You go beyond prompt-and-paste. You’ve built or configured something (agentic workflows, evaluation harnesses, custom tooling, MCP integrations, automated review or triage) that made a repeatable part of engineering measurably faster or more reliable.
• You know where AI output cannot be trusted. Generated code that handles the happy path and silently drops errors is worse than no code at all. You verify, you test, and you can explain how you verified.
• You apply the same judgement to AI-generated code that you’d apply to a junior engineer’s pull request: read it, challenge it, own it once you ship it.
• You share what works. A technique you discovered that stays on your machine is worth a fraction of one the whole team adopts.

If your answer to “how do you use AI” is autocomplete and the occasional chat window, this role will feel like a stretch — and we’d rather tell you that now.

You Will Excel If You…

• Question everything. A prompt standing in for business logic, a metric nobody can define, an agent added because agents are interesting: you raise it rather than build it.
• Believe a feature isn’t done until someone can trust its output without checking every row.
• Are comfortable holding both the domain model and this sprint’s delivery reality in your head at the same time.
• Enjoy working with product leadership rather than waiting for a finished spec.
• Care that the numbers are right, because in our business a wrong number reaches an investment committee.
• Know the difference between pragmatic and sloppy, and won’t compromise on the former to avoid the latter.