Staff Software Engineer (User Experiences)

Level: 5
Minimum 3 days per week on site at our office in Angel, London

At Automata, we're on a mission to transform how scientists work by making automation accessible to every lab in the world. We believe that by giving labs the power to automate, we can unlock discoveries that will shape the future of life sciences—from diagnostics and drug discovery to synthetic biology.

But we’re more than just a company disrupting the industry—we're a team of innovators, problem-solvers, and creators passionate about empowering scientists. Our LINQ platform combines hardware and software to streamline workflows, making lab automation fast, flexible, and affordable. This means our customers can focus on groundbreaking research, while we take care of the rest.

Why Work at Automata?

• Impact: Your work will directly contribute to advancements in science and medicine, supporting labs around the globe as they push boundaries in research and innovation.

• Innovation: You’ll be part of a team solving complex problems (seriously, no one else has figured out how to do this yet), using cutting-edge technology (we have robots).

• Growth: We invest in our people. Whether through hands-on experience, professional development, or collaborative projects, you’ll grow both professionally and personally.

• Community: Join a diverse, passionate team that values collaboration.

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, and synthetic biology.
The stakes are physical: a bug in our code means a robot arm puts a plate of samples in the wrong place and a week of science is lost.
The prize is big: labs that run overnight and unattended, and scientists who get answers in days instead of months.

We're building the next generation of our core execution engine — one that recovers from anything a lab throws at it, with AI in and out of the loop, always opt-in: the deterministic core runs the lab on its own; models make it smarter. And that's just the start — vision that verifies the physical world, scientific models that design the next experiment.

The problems you'd be working on

Scheduling that never stops. A scientist designing an experiment should never have to think about robots deadlocking — that's our problem, and it's a hard one. The science sets hard deadlines (cells must be fed, passaged, and imaged on time or they die), instruments overrun, and one cell-line maintenance process runs for months with hundreds of plates in flight. New work has to join a live schedule without stopping it — but whether a lab can deadlock depends on everything in it at once, so admitting a single plate means proving the whole world still holds. Get it subtly wrong and nothing crashes: two robot arms just wait on each other forever.

Throughput is the point. A safe schedule that leaves instruments idle wastes the lab. The engine has to execute as tightly as the constraints allow — overlapping steps, batching plates, keeping every instrument busy — because an idle instrument is science not happening. Safe-but-slow is easy; safe at maximum speed is the problem.

Recovery is the product. Anyone can execute the happy path. Labs pay us for what happens when a plate goes missing, an instrument fails mid-run, or a process has to resume after a restart. That means durable, replayable execution state, and recovery that reads the actual state of the physical world and replans dynamically — never follows a stale plan.

AI that's allowed to touch robots. Agents in the loop for error recovery, analysis, and designing the next experiment — exposed over MCP, grounded on the world model, gated by simulation. Our rule: AI proposes, the deterministic core disposes. An unverified model output never commands an instrument. Building the harness that makes that guarantee real is the interesting part.

The direction of travel: The Loop — hypothesis, execute, capture, analyse, decide, next experiment — closes with less and less manual glue, with human judgment applied where it matters most. Scientists focus on the science; LINQ runs the Lab.

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

• Partner with PEDDA, Customer Success, and Sales leadership to align on challenges, initiatives, and roadmap

• 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

• Embed AI-native and automation-first ways of working—unlocking step-change improvements in productivity and throughput

• 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.
Our stack runs on Kubernetes edge clusters deployed in customer labs

• Go and Python services

• NATS JetStream is our event bus

• OR-Tools CP-SAT for constraint solving

• OpenTelemetry tracing end to end

• MCP for the agent surface, gRPC for driver surface, gRPC APIs, SDKs, CLIS

• Large fleet of robots and hundreds of lab instruments at the end of every code path.

You

• You've architected and shipped a genuinely complex realtime or streaming system — and can talk about its failure modes for an hour.

• You want the whole stack, not a layer: the UI a scientist touches, the backend behind it, the engine, down to the drivers that move the machines — and you judge every layer by what it does for the user.

• 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, push back when something doesn't feel right, and care about the speed and polish of what ships.

• Strong Go; Rust 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.

• You default to ownership: ambiguity is something you resolve, not escalate.

• 12+ years engineering, 7+ 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 the way that made you become an engineer: constraint solving, distributed state, realtime execution, physical 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 the next-generation engine is being designed now — you'd shape it, not inherit it.

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

We are an equal-opportunity employer. We celebrate diversity and are committed to creating an inclusive environment for all employees. Discrimination of any kind based on race, colour, religion, gender, sexual orientation, gender identity or expression, national origin, age, genetic information, disability, or veteran status is strictly prohibited.