Fullstack Engineer
About Berkeley Myles
We build software for UK manufacturers who can't afford to get things wrong: aerospace, medical
devices, oil and gas, motorsport. Our product, ProgressPlus, runs the whole job from first enquiry
through to final invoice. Hundreds of manufacturers run on it every day, and when one of them has to
prove what went into a part, it's where the answer comes from. We're now building a new product with
AI on every stage of that flow.
We're part of Banyan Software, the best permanent home for software businesses that serve
specialised industries, their employees, and their customers. Banyan is a Great Place to Work Certified
company, a five-time Inc. 5000 honoree, and a top-10 company on the Deloitte Technology Fast 500.
Founded in 2016 and headquartered in Atlanta, Banyan operates more than 100 portfolio companies
across North America, the UK, the EU, and APAC.
About the Role
ProgressPlus has been running factories since 1999. Every rule inside it is a decision someone once
made about how a manufacturer works: when a quote becomes an order, what commits stock, what
has to be true before a part can ship. Hundreds of businesses have built their working day on those
decisions.
We're building the replacement. Feature by feature, that means understanding why each of those rules
exists, building what the product manager decides it should become on a cloud platform with AI on
every stage, and speaking up when what you find in the old system changes the answer.
You'll work across the whole flow: enquiry, quote, order, jobs, scheduling, tracking, quality, shipping,
invoice. One month that's purchasing, the next it's shop-floor tracking, and each feature runs from the
data model through the .NET service to the part a planner or an inspector uses all day. The features
that matter most span several stages, because a change to an order ripples through jobs, stock and
invoicing, and the customer expects all of it to agree. That's why every engineer here works across the
whole flow.
The platform is built and running: five .NET services on Azure with architecture boundaries enforced in
CI, a database per customer company, and a Next.js frontend. A platform engineer owns that estate and
the path to production. An AI engineer owns the agent layer. You build the product on top of both, and
canvas
once the agent layer exists, you'll be among the first to put AI into the flow. The team you'd join is small:
five engineers and a lead.
We build with AI coding agents, wired into our issue tracking and version control. The repo already
holds what they need: project instructions, coding rules per area, specialised agents for tests,
documentation and architecture review, and a learnings log the team maintains. You'll direct the agents,
review what they produce, and answer for everything you merge.
Key Responsibilities
The kind of work on the board: an operator books on and off a job from a tablet on the shop floor and
the planner's schedule moves before they refresh. A delivery arrives against a purchase order, gets
allocated to the jobs waiting on it, and leaves behind the certificate an aerospace customer will ask for a
year later. A quantity changes on a sales order and the works orders, material demand and invoice
downstream all agree with it. A stock grid holds every part a customer owns, with filters that compile to
SQL and stay fast. And, once the agent layer lands, the first AI on a stage: an agent that drafts a job's
audit pack from its real records, with a person approving every page.
Building the product
Take features end to end across any stage of the flow, from the data model to what the user touches,
with tests at each layer
Get the cross-stage behaviour right: when an order, a job and an invoice have to agree, make sure
they do
Get authorisation and validation right on every feature, and never be the reason data crosses
between customers
Write schema changes as migrations that run safely across every customer's database
Keep it fast at real volumes: a customer's full parts list, years of jobs, and a shop floor writing to it all
day. Instrument it so we can see when it isn't
Prototype when you see a better way. The product manager leads the design and there is no
designer in between, so engineers build prototypes against the product's patterns and bring them to
the product manager
Build the integrations customers depend on: APIs for the systems that read from ProgressPlus,
connectors into the ones it reads from, and versioning so neither breaks when we change something
Working with agents
Direct coding agents on production work: break work into tasks they can execute reliably, supervise
them to a merged and tested result, and intervene when their output is wrong. You know which work
to hand an agent and which to do yourself
Maintain the agent context: project instructions, per-area rules, reusable skills, and the learnings log,
so the next person or agent working in that area starts from what you learned
The team and the customer
Review others' work across the flow with the same rigour as your own, and take review from them
the same way
canvas
Take your turn on the application team's support rota: triage what comes in, fix what's yours, and
write up anything that should never happen twice
Spend time with the people who use the product, customers and our own support team, and turn
what you learn into what gets built
Support UAT and resolve defects before and after release, and build the features customers need
before they can move off the legacy product
How We Work
Linear as the single board: work traced from issue to acceptance criteria to PR, reporting as a by-
product of the work
A small team: full stack engineers with a lead, plus AI and platform specialists, on a .NET and Next.js
platform on Azure
Prototype-led: we design the flow before we build it, against a shared design system
AI in daily use across the team: coding agents in the repo with the context they need, and AI tooling
for research, prototyping and analysis
A customer base we can pick up the phone to, and an implementation team on their sites every week
Tech Stack You'll Use
Backend: C#, .NET 10, Rebus messaging, SQL Server (database per company), EF Core
Frontend: Next.js, React, TypeScript, TanStack Table, Tailwind
Testing: xUnit, Vitest and Testing Library, Playwright
Cloud: Azure (Container Apps, Azure SQL, Service Bus), GitHub Actions
Tooling: Claude Code, Linear, GitHub
What We're Looking For
5+ years building customer-facing web products across the full stack, and a track record of driving
complex, end-to-end features, not incremental improvements, with visible impact on the product
Hands-on experience directing agentic coding tools (Claude Code, Cursor, Copilot agents or
equivalent) on production code. You can walk us through specific work you shipped this way, how
you structured it, and where you had to step in
Deep enough in C# / .NET and TypeScript / React to know when the code is wrong, whoever wrote it
Solid relational database skills: you can design a schema within an existing model, write a migration
you'd run against live data, and find the slow query
You treat tests as part of the definition of done, and you can prove a test works by breaking it on
purpose
Product sensibility: you care about UX, speed and polish, you'd rather ask the person using it for
eight hours a day than guess, and you push back when something doesn't feel right
canvas
High ownership: a self-directed, full-lifecycle builder who takes a feature from a conversation with a
user to production, and helps shape the problem rather than waiting for a spec
Comfortable in a large product you didn't build: you read before you write, you find the existing
pattern before inventing one, and you know when to ask for a second opinion
You can explain a technical decision and its trade-offs to someone who doesn't write code, and
change your mind when they're right
Strong written communication: you'll work with a team split across time zones
This isn't the role if you want a finished spec before you start, if you'd rather stay on one side of the
stack, if you see coding agents as either a threat or a toy, or if a product with twenty-five years of
customers behind it sounds like baggage rather than material.
Preferred Experience
Manufacturing, ERP, MRP or supply chain systems, or genuine curiosity about how factories run
Multi-tenant SaaS, especially database-per-tenant
Azure services and cloud-hosted applications
Building product features on top of an internal agent or tool layer
Authoring agent skills, prompt libraries or project instructions that other engineers relied on
Accessibility (WCAG) and offline-first or PWA work for the shop floor
Replacing a system people already depend on, where "how it works today" is both the spec and the
problem
What We Offer
A team that builds with agents as standard, and a repo that already carries the context they need
What you ship goes into factories that can't run without it
The backing of Banyan Software, a permanent home for software businesses, with the pace of a
small product team
Pension, holiday entitlement, remote working and a learning budget
A direct line into product and architecture decisions