Last month, our company hackathon became a vivid illustration of a broader shift in how software gets built. Across teams, from sales to support, product to engineering, domain experts huddled around laptops, experimenting with AI powered platforms such as V0, Lovable and Bolt. Within hours, they'd fashioned interactive prototypes complete with navigation flows and validation rules, all without writing a single line of traditional code.
Although these early demos relied on mock data, the fact that non-engineers could conjure usable software unaided was striking.
As a full-stack engineer accustomed to crafting CRUD apps from the ground up, I found myself asking a new question: How might we empower these citizen developers to build more often, more securely, and with live data? Their deep problem domain knowledge meant they moved swiftly, iterated boldly and learned faster than any handoff laden process could permit.
Over my two decades in software, I've discovered my highest leverage isn't in writing every screen or endpoint myself, but in architecting robust APIs, infrastructure and tooling so that others can deliver user value. In this two-part series, I'll share how engineers can transition from gatekeeping code to enabling creation at scale. In this first instalment, we'll explore the mindset shifts and guiding principles. Part 2 will dive into concrete patterns and architectural strategies for secure, sustainable enablement.
02 Jun 2025
If you've ever tried to update a bank account balance or process a payment in a distributed system, you know the pain: two users act at once, and suddenly your data is wrong. Race conditions aren't just a theoretical risk—they're a source of real-world bugs, lost money, and late-night incident calls.
Read More →
In my career, I have realised that the best companies celebrate each success in a genuine, informal way. They avoid contrived rituals that can feel like an artificial façade.
In these organisations, individuals willingly help colleagues reach shared goals.
Take Janet from my local Parkrun, for example.
Although she does not compete, she choose to find the time to cheer on each participant to achieve their goals... even on cold Saturday mornings.
MCP standardises how AI applications communicate with external systems using JSON‑RPC 2.0 over stateful, bidirectional connections. Unlike standard JSON‑RPC, which treats every request independently, MCP augments the protocol by embedding session tokens and context IDs into each message.
This enhancement provides state, enabling advanced, multi‑step interactions and dynamic module loading at runtime. Such a stateful design is essential for modern, agile AI systems.
Imagine an AI‑powered payments system that dynamically integrates a new fraud detection module during operation. MCP allows the system to load this module on the fly without a full redeployment, provided the server supports dynamic module loading.
In this post, we'll explore the MCP protocol, its core components, and how it compares to traditional REST and GraphQL APIs.
AI applications are shifting from monolithic large language models to modular, multi-agent systems—a transformation that enhances performance, flexibility, and maintainability.
In my talk about AI Agents last September, I said AI agents would become increasingly popular, and today, we see this shift happening across industries. By breaking down complex tasks into specialized components, engineers can design smarter, more scalable AI workflows.
In this guide, we'll explore four key multi-agent patterns, using travel booking as an example. You'll learn how to choose the right pattern for your application, implementation strategies, and error-handling techniques to build robust multi-agent AI systems.
Agentic systems, where multiple AI agents collaborate through decision-making and handoffs, shine in specific scenarios but add operational complexity.
In this post, we'll explore the scenarios where agentic systems are most effective and the challenges you may face when using them.
Imagine: you run a busy online shop where every moment matters.
Your customers expect the fastest page loads, yet you still require dependable analytics to understand user behaviour and drive informed business decisions.
Relying solely on client-side tracking with tools like PostHog can be fraught with challenges. Many users have ad blockers or privacy extensions that prevent tracking scripts from running, and even when these scripts do execute, they can slow down page rendering and affect conversion rates.
In this post I'll go over how you can use Next.js 15’s next/after API to handle analytics and events without slowing down your site.
Getting event names right in event-driven architecture and Domain-Driven Design (DDD) is essential for clarity, consistency, and scalability. A key decision is using singular or plural terms in event names.
Here's how I approach it, with examples and reasoning to help you make the best choice.
Building a TypeScript library that is both maintainable and optimised for modern bundlers requires careful consideration of exporting functions, types, and other constructs from your modules.
With several strategies available, from wildcard re-exports to namespaced exports, explicitly named re-exports have emerged as the clear winner. This post explores the alternatives with examples based on an order management system.
We'll discuss the benefits of exporting types, how to organise multiple entry routes (such as in /src/orders and /src/users), and review the necessary TypeScript configuration options (such as verbatimModuleSyntax) and package.json tweaks. Additionally, we'll explain how this approach helps prevent circular dependency challenges by enforcing a clear dependency graph.
I love Next.js. It's been my framework of choice since my first tiny contribution in 2017.
Yesterday, I joined a team discussion about which React framework to choose. In 2025, that decision is harder than ever, with so many excellent alternatives available.
While Next.js is recommended by React themselves, and is a very popular choice, the not-so-good parts are often left out on platforms like LinkedIn and YouTube.
I plan to write about the good things about Next.js 15 in the future, but here are some challenges I still face using it today.
31 Jan 2025
Designing a payment system is like any other software solution I've worked on.
At first, it appears straightforward, but real-world factors like currency conversions, fees, payee validations and external APIs quickly add complexity.
Read More →
It's like a new diet pill has hit the market, promising instant weight loss with no effort, and now everyone's scrambling to get their hands on it because it's all over their TikTok.
Some folks are talking about DeepSeek as if it's the second coming of AI.
The clamour might be because it's the first serious open non-US model with reasoning capabilities from China.
Most people are confused about which version of DeepSeek they're using.
Most providers offer a distilled, watered-down version that'll run anywhere, so you're not getting the actual full fat version people are talking as to really see its magic, you'd need a small fortune in computing power.
It's like being promised a rare vintage white wine, only to find the bottle filled with slightly grape-scented water. Same brand, same label, but all the depth and character stripped away, leaving you with a hollow imitation.
The hype suggests it can keep pace with anything OpenAI does, which might sound thrilling if you're already tired of whatever ChatGPT or its siblings spit out.
But here's where the alarm bells should start ringing.
Building AI products with stakeholders requires a fundamentally different approach than traditional software development.
From my experience working with AI, success depends not only on technical implementation but also on bridging the gap between AI capabilities and stakeholder expectations.
In this post, I’ll share lessons from guiding stakeholders through AI’s possibilities and limitations.
Defining clear boundaries is essential to building clean, scalable, and reliable architectures.
In my experience, organisational demands often override the focus on boundaries and domain-driven design. This reflects the tension between following technical best practices and delivering business outcomes quickly. While theoretical approaches are widely discussed at conferences, in books, and in videos, the practical implementation of these ideas is often shaped by cultural dynamics, resource constraints, tight deadlines, and internal politics.
In this post, we'll explore the challenges of maintaining boundaries and potential solutions, using a payment system as an example. This system facilitates transactions between clients and payment providers, such as PayPal or Stripe, highlighting the distribution of responsibilities within its architecture.
The goal of creating something "predictable," reliable, and consistent is a shared principle across all the teams I've worked with throughout my career.
Knowing that the same code would always return the same output when given the same inputs was the foundation of everything we built.
We aimed for no surprises, no matter how complex a workflow might be.
Whether implicitly or explicitly using finite state machines, this determinism enabled us to build testable, monitorable, maintainable, and, most importantly, predictable workflows.
We read and shared ideas at conferences, promoting patterns and principles like SOLID and DRY to create functional, composable, and extensible software.
Having lived through the era of a "new JavaScript framework every week," we now find ourselves in the gold rush of the AI agent framework space.
New frameworks appear daily, each claiming to be the 'ultimate' solution for building AI agents, often backed by YouTubers enthusiastically promoting demoware and usually their own library, framework, or SaaS offering. Unfortunately, this enthusiasm can lead companies to uncritically adopt these tools without considering the long-term implications.
This is my AWS Step Functions Mapping and Patterns and cookbook covering data manipulation, concurrency patterns, error handling, and advanced workflows.
As I stood in the rain as a volunteer race marshal at my local park run, it occurred to me that I wanted the same thing when running applications in production, and that's absolutely nothing to happen.
The last thing I wanted to do was be a hero.
🎸 "Always keep on the right side of the path" – the Parkrun version of Monty Python's song.
I'd rather everyone enjoy a safe, smooth race where I can cheer and encourage people on as they pass, reminding them to keep to the right so they don't collide with runners coming the other way.
It's the same in the land of IT. The only thing I want to see when viewing Grafana dashboards is a sea of green, 200 status codes and steady traffic patterns.
Saturday's Oasis ticket sales left thousands of fans disheartened after spending hours in virtual queues. As reported by the BBC and echoed by fans on X (formerly Twitter) and Reddit, the experience could be aptly described using a quote from Liam Gallagher himself:
Like many others, I have long been frustrated with platforms like Ticketmaster, See Tickets, and Gigs and Tours. This weekend, their reputations took another hit as fans faced inflated prices and technical glitches.
This made me think if I could design a better, more reliable ticketing system that prioritises fairness and user experience.
Let's not make Sally wait any longer than she has to.
I've been fortunate to work with some incredible leaders throughout my career.
These individuals have inspired and challenged their teams and driven them to achieve their full potential.
What truly sets a leader apart, however, is their ability to motivate and their willingness to fight for their team.
There's something special about a leader who fights for their team.
In this post, I'll explain what happens when a leader truly stands up for their team, sharing my firsthand experiences from a transformative project at Cambridge Assessment in 2007.
As an England football fan, I know the feeling all too well. The heartbreak of watching your team come so close, only to fall short at the final hurdle once again. It's now 58 years of hurt.
It's a mixture of emotions – frustration, disappointment, and knowing the team could have done more.
I've experienced a similar feeling in my work as a consultant.
As the English Football League nears the climax of another demanding season, leaders are confronted with the challenge of motivating weary players and handling the intense mental and physical pressures of chasing titles, securing promotions, or avoiding relegation.
As a Barcelona supporter, it might come as a surprise that I using Jose Mourinho, a figure often mired in controversy, who exemplified empathetic leadership during his reign at Inter Milan, leading to their historic treble win.
Inspect and adapt loops are the heart of agile development. They enable continuous learning, improvement, and evolution.
In this post, I discuss the limitations of the "fail fast" approach and propose a more impactful alternative: "learn Fast". This mindset embraces the inevitability of failure in innovation and transforms every challenge into a learning opportunity.
Structured logging focuses on capturing data in a consistent and machine-readable format.
Unlike traditional text-based logs, structured logs are more straightforward to query and analyse, making extracting insights and debugging issues simpler.
In this post, we'll take a look at an example of how structured logging with Pino.
This post celebrates and thanks Joe Parry as he takes a well-deserved bow and steps down from his role as the head of the JavaScript & NodeJS Cambridge Meetup Group.
He has been an extraordinary leader who has dedicated the past ten years to fostering a vibrant community of Javascriptors in Cambridge.
Companies must be agile and respond quickly to changing customer needs in today's fast-paced and constantly evolving technology landscape. That's why DevOps practices that emphasise collaboration and communication between development and operations teams to deliver software rapidly, reliably, and at scale have become increasingly popular.
Shifting left, a core principle of DevOps can significantly benefit companies of all sizes. By empowering engineers to take on more operations responsibilities and promoting a culture of experimentation and innovation, companies can improve collaboration, increase reliability, and deliver high-quality software at scale.
In this post, I'll discuss how and why Cambridge University Press adopted a shift left culture.
Pino is a popular and fast Node.js logging library that is designed for high-performance and low-overhead logging. It has many useful features, including support for structured logging, log levels, and log redaction.
Pino logging redaction allows you easily redact sensitive information logs, ensuring applications remain secure and compliant with regulations.
Logging is an essential part of any application, providing insight into the what's happening behind the scenes. However, as your codebase grows, it can be challenging to keep track of all the different log statements and where they're coming from. This is where child loggers come in.
Child loggers are a feature of many of the Node.js logging libraries such as Pino, Bunyan and winston have that allow you to create a new logger that inherits the configuration of its parent logger.
This means you can create child loggers that are pre-configured with specific options, making it easier to log messages without repeating the same configuration over and over again.
In this blog post, we'll take a look at an example of how child loggers can help cut down on repetition in TypeScript and Pino.
Engineers are responsible for designing and building complex systems that are expected to perform optimally under different conditions. However, without a deep understanding of how these systems behave, they risk making assumptions that can result in inefficiencies or even system failures.
In this post, we'll discuss why understanding a system like a doctor helping a patient is essential for engineers and by taking a proactive and data-driven approach, engineers can ensure that their systems are performing optimally and can make informed decisions that result in improved performance and reliability.
As engineers, one of our primary responsibilities is to ensure that the systems we build are stable and reliable.
However, despite our best efforts, issues and issues will inevitably arise in production environments. When this happens, it can be tempting to try and patch the problem and move on quickly.
However, recreating production issues locally is a critical step in the debugging and resolution process.
In this post, I'll explain the benefits of reproducing production issues locally.
When working with clients, how teams communicate tells me more about the culture than anything else.
Successful teams should communicate like a team fielding in a game of cricket who work together towards the same goal giving each other support and encouragement.
By sharing information about the batters, pitch, conditions and strategy, a feilding team agree on a plan on how to bowl and position themselves.
A good facilitator seamlessly keeps the flow of conversations fluent and relevant, encouraging people to engage and have equal participation while remaining impartial and patient.
It's a role similar to a conductor orchestrating a choir.
Should you build UI components and then add them to a page or build the page first then break it down into UI components is the chicken and egg of software development?
You've probably heard someone quote Norm Kerths' Prime Directive during a retrospective
Regardless of what we discover, we understand and truly believe that everyone did the best job they could, given what they knew at the time, their skills and abilities, the resources available, and the situation at hand.
In my experience, engineering teams doing their best at that time inevitably end up having to shoehorn features as requirements change or new information becomes available.
In this post, I'll discuss why great products need strong foundations.
Having worked with many clients who struggled to maintain Javascript projects, Typescript was a no brainer when choosing what to use for the project I was leading.
In this post, I'll share what and how I managed the challenges of introducing and using Typescript.
Having used Tailwind in my personal projects, I was already a convert of the utility first approach. When I was given the opportunity to lead a new project at Cambridge University Press, Tailwind was the first tool I reached for.
In this post, I'll discuss why and how using Tailwind worked out for us.
Stencil is a compiler for creating web components that work alone or with web applications written in React, Vue, Angular, Svelte, Ember or anything else you can think of.
Tailwind CSS deserves all praise love it's getting right now as the developer experience is incredible.
In this post I'll show how to create a Stencil web app using Tailwind CSS.
In 2008 the media were reporting on mistakes and delays in marking examination scripts. To ensure they never made the front page of newspapers for the wrong reasons, Cambridge Assessment decided to rethink how they electronically marked examination scripts for millions of students worldwide.
In 2015 I was hired by Cambridge University Press to develop a web application providing digital access to over 35,000 books and 1.5 million journal articles, consolidating several smaller sites. The application would go onto have over 2 million users a day and generate £65 million in revenue per year.
It was a fantastic technical learning opportunity, but it was our culture and approach to product development that would teach me the most important lesson of all.
