Worked examples
Case studies
A résumé bullet has one line to make a claim. These have the room to be checked: what the situation was, what made it hard, what I did, and what came of it.
Business processes that change without a deploy
Long-running decision flows were hard-coded per customer, so every process change was a code change. Modelling them in BPMN and running them on an embedded Flowable engine turned a redeploy into an edit.
Context
Ublique is a decision-intelligence platform: it models a customer's planning problem, runs analytics and optimization algorithms over it, and returns a decision. Each customer engagement carried its own business processes — five to ten of them — describing the order in which data was gathered, algorithms were run, and results were approved. I led the four-engineer team that owned the platform core, and later the infrastructure that ran it for more than twenty enterprise customers.
The problem
Those processes lived as bespoke Java: multi-step, long-running, full of waiting and retrying. That had two costs. Changing the order of two steps for one customer meant a code change, a release, and a redeploy of a shared service. And nobody outside the engineering team could see what a process actually did, which made every conversation about it a conversation with a developer in the room.
Constraints
- The processes had to keep running for hours or days, surviving restarts — an in-memory workflow was not an option.
- Each project plugged in its own third-party AI and optimization algorithms, roughly two per project, written by other teams and reached over the network.
- The platform was already in production for enterprise customers: no migration that required a flag day.
What I did
- Modelled each business process in BPMN, so the artefact under discussion was a diagram a domain expert could read rather than a class only its author could.
- Embedded Flowable in the Java microservices to execute those models, and owned both that engine and the editor the models were authored in.
- Put a RabbitMQ messaging layer between the engine and the algorithms, so a decision step was a message rather than a call — the engine handled state, retries, and long-running execution while the algorithm stayed a black box that answers.
- Wrote a set of Gradle plugins adopted by every project on the platform, cutting build boilerplate by half and giving every team one standard for using the shared libraries the engine depended on.
What came of it
- Changing a process became editing a model, not shipping code — the redeploy left the critical path.
- Around forty third-party algorithms were integrated across the project portfolio through the same messaging pattern.
- The BPMN models became the shared language between the engineering team and everyone else, which is what made them reviewable by people who were not going to read Java.
- I contributed the technical material for the Gartner briefing behind Ublique's listing in the 2024 Market Guide.
- Java
- Micronaut
- BPMN
- Flowable
- RabbitMQ
- Gradle
- Kubernetes
- AWS
A framework that halved the cost of the next simulator
Every new energy-efficiency simulator was being built from scratch. A composable framework, a monorepo and a shared design system cut the time to build the next one by half — and three of them now do work that was being done in spreadsheets.
Context
Greenovation builds web simulators that price energy-efficiency work: what a heat pump, a new boiler or a home charging point would cost and save. Some face homeowners directly; others are used inside Enel by the field teams who put renovation and investment offers in front of customers. I joined as tech lead of a three-person product team — frontend, backend, product — and inherited a single working simulator, Discovery.
The problem
Discovery worked, but it was one product, not a way of making products: each new vertical would have restarted the same decisions about structure, state, and components. Meanwhile the internal offers it was meant to replace were still being assembled by hand in spreadsheets, which is slow, hard to audit, and impossible to keep consistent between the people doing it.
Constraints
- A three-person team, with the legacy simulator to keep alive while the new ones were built.
- Two audiences with the same engine underneath: public users who need a simple path, and internal staff who need the details.
- Business logic that belongs to the domain, not to me — every simulator encodes rules that come from the product owner and the energy modelling behind them.
What I did
- Designed a composable framework from scratch that standardizes how a simulator is built: the parts that differ between verticals are the inputs, the rules and the outputs, and the framework is everything else.
- Put the simulators in one monorepo with a shared design system and component set, built with the design team rather than around it.
- Built three verticals on it — climate, boilers, home EV charging — alongside the inherited legacy one, taking Discovery as the reference for what the domain actually needed.
- Worked the business logic through with the product owner directly, so the rules each simulator encodes were agreed before they were coded.
What came of it
- Building a new vertical simulator takes 50% less time than building one from scratch.
- Three simulators in production on the framework, plus the legacy one still serving.
- The internal simulators replace the spreadsheets Enel's field teams used to price offers by hand — the same calculation, run the same way by everyone.
- React
- Next.js
- TypeScript
- Monorepo
- Design System
Two years from no technical background to a working developer
A colleague joined with no software background at all. My manager asked me to bring them up to speed. Two years of weekly pairing, weekly review and shared projects later, they were a working developer on the team.
Context
A colleague arrived at Horsa with no experience in technology or software development of any kind. My manager assigned me to bring them to the point of doing the work — not to run an introduction week, but to take responsibility for the outcome, alongside my own delivery.
The problem
Starting from zero means the usual onboarding does not apply: there is no gap to close, there is a foundation to build. Reading code teaches nothing before you can read the language it is written in, and a course teaches a syntax without teaching how the work is actually done.
Constraints
- My own delivery commitments continued throughout — this was in addition, not instead.
- Two years is long enough for either of us to lose patience, so the pace had to be one that could be sustained rather than one that looked fast in month one.
- Learning had to happen on work that mattered: practice projects nobody ships teach the wrong lesson about what finished means.
What I did
- Started with the fundamentals in the order the work needed them: Git first, then JavaScript, then Angular 2+.
- Paired once or twice a week — not a demonstration, but the two of us on the same problem, with the keyboard changing hands.
- Ran a code review every week, on their code, treated as review and not as correction.
- Set up dedicated projects we carried through together, so there was always something real being built rather than exercises.
What came of it
- They reached a working developer role on the team, over roughly two years.
- It set the pattern I have used since: the way to change how a team works is to do the work alongside it, not to hand down a standard. The Gradle plugins I later wrote at Ublique are the same instinct applied to tooling — the working agreements were the team's own, and the plugin made them automatic instead of imposed.
- It is also the clearest evidence I have that I can carry someone else's outcome, not only my own.
- Git
- JavaScript
- Angular
- Pair Programming
- Code Review