Senior Software Engineer - Solution & Data Architecture - B2B SaaS Fintech

Landytech; Paris; Hybrid; EUR 90,000 - 140,000; Full time

Benefits offered by this job

Hybrid work arrangement

Stock options

Mutuelle insurance

Travel reimbursement

Edenred food vouchers

Job summary

Landytech is building the intelligent operating platform for modern investment management. We’re seeking a senior backend engineer to drive Kotlin/Java backend design inside a Spring microservices environment, with Python for analytics and AI work.

You’ll work closely with Product Managers, own architectural decisions, ensure security, scalability and performance, and mentor teammates while staying hands-on with code and AI-assisted development. Hybrid in Paris, with global collaboration.

Qualifications

• 5+ years building backend systems in production with Kotlin/Java (17+).
• Architecting systems in a distributed or microservices environment.
• Strong data modeling and SQL skills; experience with ETL pipelines.
• Some Python for analytics, metrics or AI work.
• Comfortable with Docker, Git, CI/CD and Kubernetes.
• Fluent English; finance or fintech exposure is a bonus.

Responsibilities

• Collaborate with Product to shape requirements and design specs.
• Own end-to-end designs across Kotlin/Java services and React frontend boundary.
• Ensure security, tenancy isolation, data protection and auditability.
• Mentor engineers and contribute to engineering conventions.

Skills

Kotlin

Java 17+

Spring

System design

Data modeling

SQL

Python

Docker

Git

Kubernetes

Azure

CI/CD

Education

Degree in Computer Science, Mathematics or STEM

Tools

Elasticsearch

SQL/NoSQL

Gradle

Job description

Landytech is building the intelligent operating platform for modern investment management. Our AI-powered platform, Sesame, brings together investment, corporate and accounting data across asset classes, custodians, currencies and legal entities, creating one secure, trusted source of truth from which our clients can understand their wealth and act with confidence.

Sesame is much more than a reporting tool. We build technology that helps asset owners, asset managers, private banks and trust and company service providers run their entire investment ecosystem: automating complex data and document ingestion, surfacing portfolio and risk insights, anticipating liquidity needs, supporting investment decisions and deal flow, streamlining collaboration and turning intelligence into action through AI.

From family offices managing multigenerational wealth to financial institutions serving clients at scale, Sesame replaces fragmented data and manual processes with clarity, control and smarter decisions.

Why this role exists

Our domain is a healthy challenge: multi-custodian, multi-currency, multi-entity financial data, modelled thoughtfully and available at scale. The platform is Kotlin and Spring microservices, with Python where it pays off: metrics, analytics and our AI work. Good features start well before any code gets written, with clear communication about the outcomes to be delivered, followed by planning, prototyping when it helps, and a design the team agrees on.

Inside an R&D team, you'll work closely with a Product Manager on initiatives, improvements and bugs: shaping the work, breaking it down with the team, and owning what you ship.

You go deep enough into the requirement to push back on it, ask the questions that need asking, and tell apart what the client needs from what the requirement says.

Then you work out how it fits. Usually the right answer is the simple one built on architecture we already have, and defending that is part of the job. Sometimes it isn't, and you're the one who flags that this is a truly new capability, writes the spec and plan, and takes it to our other architects to poke holes in before we commit.

You'll do all this in a team that uses coding agents every day, and you'll help shape how we do that well.

What you'll own

You're the engineer Product works with most closely. You sit with product and domain experts before the ticket exists, understand the business problem, push back on the requirement where it needs it, and come back with honest trade-offs on cost, risk and time. You help plan and size the work, and you keep it moving once it starts.

Security, scalability, availability and performance are design inputs on every initiative, not a hardening phase at the end. You cover tenant isolation, auth, data protection and auditability, because our clients' data is about as sensitive as it gets. You know how the system behaves under load and at month-end when everyone runs reports at once, you design to our SLOs and help set them, and you make sure we can see whether we're meeting them. When the team hits something genuinely hard, you're one of the people who goes in and solves it.

For every significant initiative you produce the design: what changes, in which services, what the contracts and data flows look like, what we reuse and what we leave alone. You write it down, take the challenge from our other architects, and improve it. When a requirement exposes a gap in the platform, you name it and propose what should exist.

You think about features end to end, from the React frontend through our Kotlin and Spring services, across data stores and events, down to Azure. You propose what goes where, and push hard for the simplest solution the existing architecture can carry.

You hold the line on coding standards, API design, testing, quality gates, and security and dependency hygiene, and you help shape them. That now covers how we work with coding agents: the rules they follow, the skills and MCP integrations we build over our own systems, and the review process that holds quality as more code gets generated. You're the one who challenges what an agent proposed, because plausible code that passes its tests can still be wrong about concurrency, a data model or a failure mode.

You model the financial domain: positions, transactions, instruments, valuations, entities and hierarchies, so it holds up as new asset classes, custodians and jurisdictions arrive. You build pipelines that stay correct when the source data is messy, late or wrong, and fast enough to run over long histories on demand.

You make the engineers around you better: mentoring, onboarding new joiners, code reviews people learn from, and a hand in our hiring. You bring back what's new and make sure it lands with the team rather than staying in your head.

You stay hands-on throughout — this is not a role where you stop writing code.

Where this role goes

We're hiring a senior engineer, and we're hiring with the next step in mind. The work described above is deliberately broad: owning designs, working directly with Product, setting the bar on quality and growing the engineers around you. Do that well and the mandate widens, up to and including leading a team of your own.

We'd rather say that out loud than pretend the scope stops at the job title.

What we're looking for

• 5+ years building backend systems in production, with real depth in Kotlin and/or Java (17+) and the Spring ecosystem (Boot, Web, Security, Data).
• A track record of architecting systems, not just services: you've owned significant design decisions in a distributed or microservices platform and lived with the consequences.
• Strong data modelling and SQL skills, plus experience designing data ingestion, transformation or ETL pipelines. You've dealt with data you couldn't trust.
• Enough Python to design and review it. Our metrics, analytics and AI services are written in it, so you need to be able to reason about them, not to be a Python specialist.
• Fluency across the boundary: you can read and reason about a React/TypeScript frontend and hold a serious conversation about Kubernetes, cloud networking and cost.
• You work well with Product. You've partnered closely with a PM, dug into complex business requirements, challenged them, and turned them into plans a team could execute.
• You write. Technical specs, design docs, ADRs. Clear enough that another architect can challenge them and an engineer can build from them.
• Comfortable with AI-assisted development. You use coding agents day to day and have a view on where they help and where they quietly cause damage. Experience writing skills, MCP integrations or agent conventions for a team is a strong plus.
• Security is instinctive for you. Secure-by-design services, authentication and authorisation done properly, tenant and data isolation, secrets and key management, dependency and supply-chain hygiene. You've worked somewhere the data mattered.
• You've built for scale and kept it up. Designing for growth in users, data volume and history; understanding availability, failure modes, graceful degradation and recovery; and being the person who owns the incident rather than watching it.
• Performance is something you measure. Profiling and load testing before optimising, query and caching strategy, sensible use of async and batch, and knowing which numbers actually matter to a client waiting on a report.
• A real testing habit, and a view on what belongs where: unit, component, integration, contract, end-to-end, and performance and scalability testing. You know which of these earns its keep on a given change, and which ones teams quietly skip until it hurts.
• Comfortable with Docker, Git, trunk-based or short-lived branching, and CI/CD as code.
• You've led work, if not people. You've been the technical lead on a project or a feature others built on, and you've mentored engineers who got better for it.
• You lead through influence and clarity. You explain a design to a junior engineer and a product director in the same afternoon, in the right words for each.
• Fluent English. Degree in Computer Science, Mathematics or another STEM subject, or equivalent experience.

Bonus points

You don't need to come from finance. You do need to be curious about it, because the domain is half the job.

Azure and Kubernetes · event-driven architectures, queues and asynchronous processing · Elasticsearch or NoSQL · observability and SRE practice · security or compliance work in a regulated environment · Python for analytics or LLM applications · financial services or fintech experience · open-source contributions.

Our stack

• Core backend: Kotlin, Java 17+, Spring Boot & Co, JPA/Hibernate, SQL and NoSQL, Elasticsearch, Gradle,
• Metrics, analytics and AI: Python, FastAPI, Polars, LangChain
• Frontend: React, TypeScript, TanStack Query, Tailwind CSS and shadcn/ui, Vite, nx.dev
• Platform: Azure, Azure DevOps, Kubernetes, Docker, messaging and events, Git
• AI in our workflow: Claude Code and Codex day to day, custom skills and MCP servers over our own platform

What the first year looks like

• Month 1: you know the platform, the domain and the team, and you've shipped something real.
• Month 3: you and your PM are running your initiatives together, and you've written the spec for a significant cross-service feature.
• Month 6: your fingerprints are on our engineering conventions and on how the team plans, designs and reviews work.
• Month 12: you own a domain area, you're the person others come to on it, and the decisions you made are holding up under load.

Why join now

You're joining early enough to shape the platform and late enough that it has real clients, real scale and real revenue behind it. The problems are hard, the domain is deep, and the industry is genuinely ready for what we're building. You'll work with an international team across London, Paris, Pune and beyond, and you'll have a real voice in what we build.

Benefits

• An opportunity to work in a fast growing fintech revolutionizing investment reporting
• Hybrid style of work/WFH allowed depending on role
• Competitive salary & stock options package
• Budget for the AI tooling, hardware and learning you need to do your best work
• Mutuelle insurance
• Travel reimbursement
• Edenred food vouchers, regular socials