Learn with QMates
First we bring software and organisation into alignment, then we innovate with the outside world and transform with AI and technology.
Insights, strategies and good practice on software architecture, organisational design and scaling for development teams.
All articles
How technical debt builds up without anyone noticing
Technical debt doesn't come from bad decisions: it comes from rational decisions made one after another, with nobody watching the cumulative effect. The problem isn't any single shortcut; it's the mechanism that keeps the debt invisible until it's too late.
The signs of technical debt: in the code, the team and the business
Technical debt sends out clear signals before it turns into an emergency. Many of them get read as people or process problems. This guide translates them into what they really are: symptoms of a software structure that can no longer keep pace with the organisation running on it.
How to measure technical debt: from architecture to workflow
Measuring technical debt isn't about installing SonarQube. It's about understanding where the system resists the changes the business needs. A practical guide to the metrics that matter — and the ones that distract.
How to reduce technical debt: strategies that work
Reducing technical debt doesn't mean rewriting everything from scratch, or stopping delivery for months. It means stepping in at the right points, in the right order, while keeping the ability to ship value throughout the whole process.
Legacy software: when to live with it, when to evolve it, when to rewrite it
Not all legacy software needs rewriting, and not all of it can be left alone. The decision comes down to three variables that almost nobody measures before choosing. A guide for anyone deciding what to do with a system that works but is holding things back.
Real CI/CD: why your pipeline probably isn't
Having Jenkins or GitHub Actions doesn't mean you're doing continuous delivery. The difference between a pipeline that merely automates the show and one that actually ships, continuously and safely.
Strategic refactoring: when to act and how to justify the investment
Refactoring isn't a technical whim: it's a business decision. How to quantify the cost of doing nothing, choose where to act and win leadership's backing.
Technical debt: an introduction for the C-suite
A step-by-step series on understanding, measuring and reducing technical debt in software organisations. For CTOs, VPs of Engineering and CEOs who need to make decisions without getting lost in technical detail.
Technical debt: what it is and what it isn't
Technical debt isn't old code or outdated technology. It's a structural constraint that slows down your ability to change the system. A guide to recognising it, measuring it and telling it apart from what it isn't.
Team Topologies for people running a software company
Team Topologies principles translated into concrete decisions for CEOs and CTOs. How team structure determines the speed of your software, and what to do when groups start blocking each other.
From monolith to microservices: when it makes sense and how to get it right
Moving to microservices isn't always the right answer. A practical roadmap for deciding when to extract, what to isolate and how to keep delivery moving along the way.
Evolutionary architecture: how to evolve your software without rewriting everything
Software architecture isn't designed once and left alone. It evolves alongside the business, incrementally. A guide for anyone who wants to modernise without stopping delivery.
Mandatory AI training at work: compliance obligation or competitive advantage?
Since 2 February 2025, every company using AI tools has had to provide adequate training. Treat it as a compliance box to tick and it's a cost. Treat it as an investment and it's the first step towards adopting AI with real results.
AI in business: what actually works and where to start
AI isn't a tool you buy. It's change you have to manage. A practical guide for anyone running a business: where to start, what to avoid and when it actually works.
Software roadmap delays: why roadmaps become unstable
As a software organisation grows, roadmaps become steadily less reliable. The problem is often not estimation itself, but the complexity of the system that produces delivery.
Why your engineering team feels slow (even after hiring senior developers)
Many scale-ups hire senior developers to speed up delivery, but velocity doesn't improve. The problem isn't talent: it's the system the team operates in.
What team autonomy actually means (and why it's often an illusion)
Many companies claim to have autonomous teams, but in practice they depend on other teams constantly. This misalignment is one of the main reasons software scale-ups slow down.
Cost of change in software development: why it keeps growing
As software grows, changing the product gets harder and harder. The cost of change is one of the clearest signs that architecture, organisation and delivery have stopped evolving together.
Startup delivery slowdown: why speed drops as you grow
Many startups find that growing the team doesn't speed up delivery. The slowdown is often the result of architecture, organisation and dependencies that stop evolving together.
Team dependencies in software development: the real bottleneck
In software scale-ups, delivery slowdown rarely comes down to how talented the teams are. More often, the real bottleneck is the dependencies between teams, which multiply as the organisation grows.
Technical debt in startups: why it slows growth
Many startups blame slowing product development on technical debt. The real problem runs deeper: it's about how software, organisation and strategy grow together.
The moment a startup starts to slow down (and no one knows why)
Many startups slow down as they grow. It isn't a people problem. It's a systems problem. Here's why it happens and how to avoid it.
Tell us where you're stuck
A fragile prototype, a burdensome legacy codebase or unpredictable delivery: that's where we start