Staff Software Engineer

Our LINQ platform is the software that plans, schedules, and drives life-science labs. Our clients run labs for cancer diagnostics, drug discovery, cell manufacturing, synthetic biology and more.
This role owns the interface to the lab — not just the UI, but every surface someone builds on or acts through: the app a scientist touches, the APIs and SDK an integrator builds on, the CLI an engineer scripts with, the agent surface a model acts through. Most product interfaces are forms over a database. Ours front a physical world that changes by itself — robots act, schedules change, instruments fail — and every one of those surfaces has to keep its user genuinely in control.

We're building the next generation of our interfaces — AI-native from the ground up: personalised to role and behaviour, UI generated on the fly where it earns its place, and agents working in the product alongside the people using it. This is a role for someone user-obsessed — the platform underneath is enormously capable and enormously complex, and the product wins by how much of that complexity users never have to see. And the stakes only grow: the more autonomous the lab becomes, the more the interface matters, because it's where human judgment enters the system.

The problems you'd be working on:

Explaining automation to a scientist. When the plan changes underneath the user, the interface has to show what moved and why. When a workflow can't run, 500 is not an answer a human can act on — turning our engine's output into something a scientist can fix is an unsolved design problem. And the timeline it lives on is long: processes that run for months, hundreds of plates in flight.

The worst moment is the main event. Users arrive precisely when something has gone wrong: a plate misplaced, a task failed, retry-or-failover decisions with live samples degrading while they think. The interface has to put the right context in front of them — not a wall of state — at the exact moment the stakes are highest.

Authoring is programming, whether we admit it or not. Scientists design workflows on a canvas today, and it's static: you express an intent, submit it, and find out later whether it actually runs. It should feel like an IDE — validation as you type, the constraints visible while you're authoring, simulate the run you're designing and watch it execute before a single robot moves. Design and execution are disconnected today, and closing that gap is one of the biggest wins available to us.

Interfaces that build themselves. An operator, a scientist, and a lab manager should not see the same screen. Surfaces personalised to role and behaviour, generated where it helps — and the open question you'd own: where does generated UI aid discoverability, and where does it erode trust?

Four front doors, one lab. A scientist in the browser, an integrator on the API and SDK, an engineer scripting the CLI, an agent acting over MCP — the same capabilities have to show up on every surface, each one idiomatic to its user. An API that is hard to use correctly is wrong, and DX is UX: the developer and the agent are users too.

The role:

• Own end-to-end squad delivery within Product Engineering (Software), in a department with Product, Engineering, Design, Data & AI (PEDDA)—turning challenges into predictable, high-quality product delivery
• Hands-on squad leader–set the bar of what high-quality looks like at pace
• Own part of the technical architecture–set the direction of our product
• Work as one unit with Product and Design — you help decide what we build, not just build it
• Be the squad's force multiplier — the patterns, components, and tooling you build make everyone ship better and faster
• Lead, and level-up high-performing Product Engineers that report to you—hiring, mentoring, and setting an uncompromising bar for execution
• Architect, and continuously evolve operating systems that scale—eliminating bottlenecks, increasing velocity, and enabling the squad to move autonomously
• Shape the future of how we deliver — our AI-native, automation-first way of building is being defined right now, and you'd set the pattern for the team rather than inherit one
• Bridge strategy and execution—ensuring we build what we defined; that what we build, ships fast; and what we ship, delivers results with high quality

The stack:

We use the right tool for the job.

• React (TS) single paged app
• Public GraphQL APIs, MCP for the agent surface, gRPC for driver surface, SDKs, CLIS
• Kubernetes hosted on our own hardware clusters
• Live lab state streamed from NATS JetStream into the browser
• Go and Python services behind the contracts
• Large fleet of robots and hundreds of lab instruments on the other side of every scree

You:

• You've built genuinely complex, dynamic user interfaces — realtime data, live state, visualisation at scale — and can talk about their failure modes for an hour.
• You're fullstack by instinct: the UI a scientist touches, the API an integrator builds on, the BFF behind them, down to the events streaming off the machines — and you judge every layer by what it does for the user.
• You're user-obsessed: you watch people use what you built, feel their friction personally, and measure success by their outcomes — not by features shipped.
• You run at complex domains: you want to understand how a lab actually works — the science, the robots, the constraints — because you can't distill what you don't understand.
• You've taken complex features from idea to shipped, end to end — not incremental improvements to someone else's design — and you can point at the product impact.
• You don't wait for a PM to hand you a spec: you help shape the problem, resolve ambiguity rather than escalate it, push back when something doesn't feel right, and care about the speed and polish of what ships.
• Strong JavaScript/TypeScript; Go a bonus. You've integrated AI into products.
• You've led senior engineers before and know the difference between leading and managing — you do the former from inside the code.
• 10+ years engineering, 6+ building products, in environments where both speed and quality were non-negotiable.

Logistics:

London, 3 days a week in office (near Angel).

Why this, why now:

• The problems are hard in a way user-experience work rarely gets to be: live state from a physical world, high-stakes decision surfaces, and users who are scientists, developers, and agents — with real consequences.
• The outcomes are real: our platform runs in labs working on cancer diagnostics, drug discovery, and synthetic biology. Faster labs mean faster science.
• The team is small and senior, ownership is high, and both the next generation of the interface and the AI-native way we'll build it are being designed now — you'd shape them, not inherit them.

UK Team Benefits:

🍎 Vitality Health Insurance

👀 Eye Care

🚗 Salary Sacrifice - EV

🚲 Salary Sacrifice - Bike & Tech

🧘🏼‍♀️ Wellbeing & Support

☀️ Wellbeing & Development Allowance

💙 Spill & Employee Assistance Programme

😊 Additional Leave

👵🏼 Pension Scheme

🫂 Group Life & Critical Illness cover