I'm Increasingly Drawn to Apps That Do One Thing Really Well
A program doesn't need two hundred features to justify its existence. On focus, speed, privacy, local processing, ownership instead of subscription, and why a small scope is harder than it looks.
On my computer I have a few programs that I open, use and close. They do one thing. They don't ask for an account, they don't send notifications, they don't suggest an upgrade to an annual subscription. When I need them, they're there; when I don't, they aren't.
I keep finding that I like these programs more and more. Not out of nostalgia, but because at work I notice how much time tools that want to be everything at once take from me. Every feature I don't need is one more button, one more menu, one more setting I have to understand to get to the one thing I opened the program for.
This is a personal post about why a small, focused program is often worth more to me than a big one.
A program doesn't need two hundred features to justify its existence
Somewhere the idea took hold that a program has to grow. Every version more features, every month a new option, or else it looks as though development has stopped. I understand where that comes from: a list of what's new is the easiest way to show work.
But a user doesn't buy a program for the list. They buy it for the one or two things they need. Everything else is noise to them: it slows loading, complicates the interface and increases the chance that something won't work. A program that does one thing very well doesn't need an excuse. It only needs enough people who need that one thing.
On my own projects I find it harder and harder to add a feature that doesn't solve a clear problem. Not because I couldn't build it, but because I know what it costs afterwards: maintenance, support, explanation, testing, and an interface that gets a little fuller every time.
Open, do, close
My favourite pattern of use is simple. I open the program, do what I need, and close it. No introductory tour, no sign-in, no waiting for something to load that I won't use.
This pattern demands something of a program that's harder than it looks. It has to be fast, because it will be open only briefly. It has to be clear, because the user won't read instructions. It has to do what it promises, without surprises. And it has to know when to stop; it mustn't hold me back with questions about whether I'd like this and that as well.
Programs that manage this seem almost invisible. That's a compliment. A tool I don't notice is a tool that didn't get in my way.
Why focus matters more to me than options
Focus isn't just an aesthetic choice. It has very practical consequences that I notice both as a user and as someone who builds programs.
Speed. A program that loads only what it needs opens immediately. That sounds trivial until I compare a tool that takes five seconds to open with one that opens in half a second, and notice which one I use more often.
Reliability. Less code means fewer places where something can break. A program with one feature can be tested to the end. A program with a hundred features has combinations nobody has tested.
Clarity. When a program does one thing, the user needs no explanation. They know what will happen when they press the button, because there's only one button.
Privacy and local processing
With small programs, one more thing matters to me that's rare on big platforms: the data stays with me. If a program processes an image, a document or a text on my device, I don't need an account, a connection, or trust in what happens to the data on the other side.
Local processing isn't always possible and isn't always sensible. For collaboration with others or for large data, a server is needed. But for a tool that does one thing with my file, I see no reason why the file should travel anywhere. A program that works offline also tells me something about how it's designed: it doesn't need me as a source of data; it needs me as a user.
Ownership instead of renting
Subscriptions have their place. For a service that keeps developing and is maintained by a team, they're a fair model. But for a tool that does one thing, and did it the same way two years ago, a monthly subscription sounds to me like rent for something I could own.
I increasingly value programs I pay for once and that are mine. Not because I want to shortchange developers, but because I want a relationship that's clear. I bought a tool. If a new version is substantially better, I'll buy it again. In between, the tool doesn't need my account, my data or my attention.
SmallLynx as a way of thinking
SmallLynx is the brand under which I build small Mac tools, and it's where I try to put this way of thinking into practice: small tools, thoughtfully made. I won't present it here; this isn't an article about a product. I mention it because it's the place where I test this way of thinking on myself.
Every time I plan a new tool, I ask the same thing: what is the one thing it has to do? What can I leave out so that this one thing gets better? Can it work locally? Does the user have to create an account, and if not, why would I force them to? The answers are often more uncomfortable for me than for the user, because they mean fewer features to show off.
The first tool in the making converts and optimises images, and does so locally on the computer, without uploading files to a server. The same thing shows up with it again and again: the user wants to convert or shrink an image and get on with their work. They don't want an editor with three hundred options. They want a button that does what it says.
A small scope isn't laziness
A small scope is easily mistaken for a lack of ambition. For me it's the opposite. Doing one thing so well that the user doesn't notice it is harder than doing ten things averagely. Every edge has to be smoothed, every case anticipated, every error message made understandable.
In a big program the weaknesses hide in the crowd. In a small one they're in plain sight. That's why good small programs are rare, and why I remember them when I find them.
How I choose tools for myself
When I look for a new program, I have a few simple criteria I apply before I even look at the feature list.
Does it do the one thing I need, without detours? Does it open quickly and work offline, when there's no real reason it shouldn't? Does it require an account, and if so, why? Where is my data and who sees it? Can I buy it once, or do I pay for as long as I use it? Is it developed by someone who'll still be around in three years, and can I take my files with me if they aren't?
These criteria rule out a surprising number of tools, including ones everyone recommends. What's left are usually smaller programs made by a small team or an individual, not designed to grow into a platform. Some of them have been on my computer for years, and I've never replaced them because there was no reason to. I tried to keep to the same principle in a project of my own; I write about it in What I Learned Building FitBlizu.
I look at the things I build myself the same way. If a tool doesn't pass these questions, I probably wouldn't use it either. And that's a fairly good test.
What this means for product decisions
This way of thinking isn't limited to tools for personal use. I ask the same question of every digital product: does a new feature simplify something for the user, or does it just make the list longer? The answer is often that it would be better to improve one existing feature than to add a new one.
I'm not claiming that a small program is always the right answer. Some tasks are complex and need complex tools. But many tools are complex not because the task is complex, but because nobody had the courage to say that enough is enough.
Enough is a good word
If I had to describe what I look for in the programs that stay on my computer, I'd say: they do what I need and leave me alone. They don't grow because they're supposed to. They don't ask for attention. They don't change the deal every few months.
That sounds modest. In fact it's a high bar that few programs clear. Which is why the ones that do keep growing on me.
