Here’s an unavoidable fact: the software project you’re working on has some flaws that no one knows about. Not you, your users, nor anyone in your team. These could be anything from faulty assumptions in the UI to leaky abstractions in the architecture or an error-prone release process.
Given enough time, these flaws will be discovered. But time is money. The sooner you discover them, the cheaper they are to fix. So how do you find out about them sooner?
The good news is that there are some things you can do to force issues up to the surface. You might already be doing some of them.
Here are some examples:
- Dig out an old or cheap phone and try to run your app on it. Any major performance bottlenecks will suddenly become obvious
- Pretend you’re a new developer in the team1. Delete the project from your development machine, clone the source code and set it up from scratch. Gaps in the Readme file and outdated setup scripts will soon become obvious
- Try to add support for a completely different database. Details of your current database that have leaked into your data layer abstractions will soon become obvious
- Port a few screens from your front-end app to a different platform. For example, write a command-line interface that reuses the business and data layers untouched. “Platform-agnostic” parts of the architecture might soon be shown up as anything-but
- Start releasing beta versions of your mobile app every week. The painful parts of your monthly release process will start to become less painful
- Put your software into the hands of a real user without telling them how to use it. Then carefully watch how they actually use it
To borrow a term from interaction design, these are all examples of Forcing Functions. They raise hidden problems up to consciousness in such a way that they are difficult to ignore and therefore likely to be fixed.
Of course, the same is true of having an issue show up in production or during a live demo. The difference is that Forcing Functions are applied voluntarily. It’s less stressful, not to mention cheaper, to find out about problems on your own terms.
If you imagine your software as something evolving over time, strategically applying forcing functions is a way of accelerating this evolutionary process.
Are there any risks in doing this? A forcing function is like an intensive training environment. And while training is important, it’s not quite the real world (“The Map Is Not the Territory“). Forcing functions typically take one criteria for success and intensify it in order to force an adaptation. Since they focus on one criteria and ignore everything else, there’s a risk of investing too much on optimizing for that one thing at the expense of the bigger picture.
In other words, you don’t want to spend months getting your mobile game to run buttery-smooth on a 7 year old phone only to find out that no one finds the game fun and you’ve run out of money.
Forcing functions are a tool; knowing which of them to apply in your team and how often to apply them is a topic for another time.
However, to give a partial answer: I have a feeling that regular in-person tests with potential customers might be the ultimate forcing function. Why? Not only do they unearth a wealth of unexpected issues like nothing else, they also give you an idea of which other forcing functions you might want to apply. They’re like a “forcing function for forcing functions”.
Or to quote Paul Graham:
The only way to make something customers want is to get a prototype in front of them and refine it based on their reactions.
Paul Graham – How to Start a Startup
If you found this article useful, please drop me a comment or consider sharing it with your friends and colleagues using one of the buttons below – Matt (@kiwiandroiddev)
1 Thanks to Alix for this example. New starters have a way of unearthing problems not only in project setup, but in the architecture, product design and onboarding process at your company, to give a few examples.
Cover Photo by Victor Freitas on Unsplash
Nice write up man, those are all useful tips and wholeheartedly agree that in-person tests with potential users are the ultimate forcing function, as you call it. I find that doing this is like hearing a new perspective on a subject you’ve been thinking about for long, that makes you re-think and go through all your thought process again to come to a new, hopefully enhanced, conclusion.
I may add another example to the list:
– Test your app using large font. This will most likely break a few of your UI components or even screens altogether.
And the amount of people that actually uses larger font sizes is bigger than we usually think.
Hope you’re doing well!
Thanks Daniel, I always appreciate your feedback on these. I’m good – hope you’re doing well too.
I like that analogy (not even an analogy – I’d say it’s the same thing) about having to revisit all of the thought-processes that lead to your faulty/incomplete conclusions. It sounds painful, and I guess it is – at least in proportion to how much of your mental model needs to be thrown out. This makes a good case for seeking out this kind of “disconfirming evidence” voluntarily and regularly. You reduce both the pain and the time you’re working under those faulty assumptions.
Testing your app with a large font is a great one. Which reminds me, I should actually do this… 😀