Commissioning software for the first time can feel strange. You know what you need the thing to do, at least roughly, and you might even have a list. But sitting across from a development team, being asked questions you weren't expecting, it can be difficult to explain a process that mostly lives in your head and your team's shared way of working.

Most people leave that first meeting wondering if they said the right things. The honest answer is that it doesn't matter as much as you might think, as long as the right questions get asked afterwards. And that part is on us, not you.

What we are actually trying to find out

The brief is a starting point, and often a useful one, but it's still only a starting point. What it rarely captures is the texture of how a business actually runs day to day: the step everyone takes before sending a report because something went wrong once and nobody wants it to happen again, the approval that exists because someone decided it should years ago and it's simply stayed in place.

Then there are the parts of the process that work perfectly well on a quiet morning but start to bend by Thursday afternoon when three things are happening at once. That's not something most people think to write down. Why would they? It's just how things work. But those details are often the most important things for us to understand. Industry research has found that the large majority of software project failures come down to requirements issues, and in our experience the problem is rarely that the original spec was wrong in an obvious way. More often, something important never made it into the spec at all, because nobody thought to ask, or nobody realised it needed saying.

The thing about workarounds

Most businesses have workarounds. A spreadsheet that runs alongside the main system because the main system doesn't quite handle one particular thing. A manual check that happens before anything gets signed off. A way of doing something that began as a temporary fix and slowly became part of the process.

None of this is a problem in itself. Teams are resourceful, and they find ways to make things work. The issue comes when software is built around the official version of the process rather than the real one, which often just creates another layer of workarounds on top of the old ones. The team then has to adapt all over again, which is exactly what the software was meant to avoid.

What this looks like in a room

The first proper conversation we have with a client isn't really about what they want built. It's about what life looks like right now, what's working, what isn't, and where the team has learned to work around the system rather than with it. Fixing something at this stage costs a fraction of fixing it once it's already been built around, and we've found that to be true, consistently, across every kind of project we've worked on.

It can feel like a slow start, especially when you came in with a clear list and expected to be talking about timelines. But the questions aren't a delay. They're how we make sure that what gets built actually fits the business, not just the document you arrived with. Begin with what the business needs to achieve, really understand it, and let everything else follow from there. Including, eventually, the software.