Get Closer
Your problem isn't speed - it's distance.
There’s an issue I come across often, particularly with internal tooling teams and B2B product teams. It’s often expressed as “our users don’t care” or “we struggle to get feedback”, but it boils down to being frustrated with a seeming lack of attention span from users.
Then you look at how that team operates: we interview people about what they need, go away, design it, build it, and launch it - by which point they’ve forgotten the conversation, their priorities have moved, and the thing we built answers a question nobody’s asking anymore. And suddenly the diagnosis is less of a mystery, but the cure is still elusive.
There are two very common responses to this.
The first is often things like “build fewer features”; “stop chasing ad-hoc needs”; “enforce stricter approvals before we build”; and so on. But this interprets your user as the problem - their needs don’t fit your way of working. And so your answer becomes filtering their needs against the kind of work that fits comfortably within your process.
The second, and much more powerful way, is to recognise that your process is the problem. Get closer to your user and try to understand their needs and how you can help.
The first seems reasonable, and a lot of sensible people land there. But it’s exactly what will leave your impact low, your team demotivated, and your work irrelevant.
The Loop Is Not the Engineering
Look at where the time actually goes. Very often, the engineering itself is fast (especially with AI) - plenty of changes ship within a single sprint once someone actually starts on them.
The slowness is everywhere else. The gap between hearing about a need and starting on it. The gap between starting and showing anyone. The gap between showing and shipping. The gap between shipping and anyone noticing.
That’s not an engineering problem. That’s a distance problem. You’re simply too far away from the people you’re building for.
“Build Faster” Means “Get Closer”
So “build faster” is often the thing you need to do, but it’s the wrong framing. The right one is “get closer”.
I recently needed to build a report for a stakeholder. Rather than interview them, go away, and come back in a month, I sat in a DM with them and iterated on the output hourly for two days. Does this format work? No - what would? Does this column help? Yes - can you add this one too?
At the end of two days I had something that did a large part of their job automatically. It wasn’t productionised. It wasn’t pretty. But it was reproducible. And most importantly it was right, because they’d been in the loop for every decision - and now I could run it again any time they asked, or spend a week turning it into a real tool, knowing that tool was the right one.
In a previous startup role I was working on a mobile app for installing and managing an IoT device. Initially, we worked in parallel against fixed plans - multithreaded waterfall. We struggled for months to keep the mobile app aligned with the web app and backend, aligned with the device firmware, aligned with the users’ needs and expectations. I was frustrated, and implored the team to change the process, but we stuck with it.
This process culminated in a very embarrassing moment where, after a month or two of hard work and polish, the hardware engineer and I visited a factory with our device and mobile app with its new, easy setup process. The setup process got stuck connecting the IoT device to the factory network - they run on fixed IPs, and we had assumed DHCP. With no way to assign the device a static IP, it couldn’t possibly connect to their network. And so we had to pack our bags and head back to the office - less than 15 minutes into our site visit.
Upon returning, I used the failure as an opportunity to demonstrate what happens when we aren’t talking to our users regularly enough. I coached the team into collaborative, all-at-once development. We worked all together in the same room, and with our executive team organised bi-weekly meetings with our customer where we would demo and chat about how things were progressing.
Not only did we correct our IP problem, but we also detected another issue - steel, concrete and water interfere with Bluetooth and Wifi signals, so in many factories the devices wouldn’t have a good Wifi signal where they needed to be placed. So we also built a “walkthrough” feature where the customer would carry their phone through the factory, the phone would scan for devices via BTLE, connect as they came into line-of-sight and had a signal, and then ask them to initiate a Wifi direct connection back to the phone so there was enough bandwidth to dump megabytes of data very quickly. The phone showed a little percentage meter filling up as the data was collected, and finally a single button press uploaded it to the cloud for analysis when they returned to their office. The customer was so impressed at the leap in simplicity that they immediately ordered a dozen more units and opened discussions with execs about expanding to larger sites.
That is the true power of collaborative, iterative engineering. No plans, no agreements, no late nights - just regular conversation.
Compare that to the interview, design, build, launch model, where the first time they’d have seen the output was three months later, and the first thing they’d have said was “oh, the devices get no Wifi signal from the office”.
Whose Problems Do You Know?
This is really an extension of something I’ve written about before: good software solves your users’ problems, not your own. It takes on their complexity, so they don’t have to.
But you can only solve problems you actually know about. And when you’re far away from your users, the problems you know best are your own - your architecture, your backlog, your tooling, your process. So that’s what you end up solving. Not out of laziness, but because it’s all you can see from where you’re standing.
If you can describe your own problems in great detail, but can’t say what your users are struggling with this week - you’re too far away from them.
“Out of the Blue” Is a Symptom
A very common complaint is that requests come “out of the blue”. They don’t, really. That’s just what it looks like when you’re not in the conversation while it’s happening. By the time it reaches you via a DM or a ticket, the stakeholder has been thinking about it or struggling with it for weeks or months. You’re joining late, and it feels sudden.
The fix for “out of the blue” isn’t to filter requests harder. It’s to be there earlier. If you’re close enough to hear the problem as it’s being discussed, there’s no surprise - there’s just a conversation you’re part of.
What Made the Fast One Fast?
If you want one practical thing to take from this: find the change your team shipped fastest, and ask what made it fast.
Usually the answer is some combination of:
- the stakeholder was close
- the scope was small
- nobody waited for a document
- someone just did it
Whatever that combination was, you need more of that, and less of whatever is not that.
The distance between you and the people you build for is the single biggest variable in whether what you build matters - and it’s almost entirely within your control to shrink.
Get closer.
Link copied!