My partner and I had a very sophisticated grocery-shopping system: one of us would text the other a list, remember something five minutes later, send another message, then probably remember one more thing after that. By the time one of us actually went shopping, the list was spread across half a conversation and there was a decent chance something would get missed.
I figured there had to be an easy shared shopping-list app, so I went looking for one. A few of the obvious options let you make lists for free but wanted a subscription if you wanted to share them with another person. Around $5 a month.
Five dollars isn’t much, but paying every month so two people can look at the same shopping list felt ridiculous. I’m a developer. I was fairly sure I could build the thing in ten or fifteen minutes.
So I did.
The first version only needed to solve one problem
Pantrify started with a very small requirement: Bree and I should both be able to add something to the same shopping list and see what the other person added.
There was no roadmap, no product strategy and no attempt to turn grocery shopping into a startup. I just wanted to stop sending follow-up messages saying “also eggs”.
The first version split the list into a few useful categories such as Staples, Fruit & Vege, Snacks, Household and Drinks. Items could have a quantity or note, and either of us could check them off while shopping.
For sharing, the app refreshes every five seconds. WebSockets would make it properly realtime, but five seconds is more than fast enough for deciding whether someone has already added bananas.
Developers can get carried away building the technically nicest version of something when a much simpler version already solves the actual problem. Pantrify didn’t need impressive infrastructure. It needed to stop us using text messages as a grocery database.
Using it created the next features
The first version worked, but actually using it made the next few improvements obvious.
Checked items now go into purchase history, which powers a Last time view. Things we regularly buy can be added back to the current list with one tap, and familiar products show when they were last purchased.
Categories can also be renamed, added and colour-coded, and items can be edited after they’re on the list. Starting a new list gives us the option to carry unchecked items across rather than clearing everything and forgetting about them.
None of those features came from sitting down beforehand and trying to imagine what a grocery-list product should contain. They came from using Pantrify and noticing small bits of friction.
I like building software that way. Start with the annoying part, build the smallest thing that fixes it, then let real use tell you what should come next.
The stack is deliberately boring
Pantrify is a small Python application backed by PostgreSQL, with a plain HTML, CSS and JavaScript frontend. PostgreSQL stores the active list, categories and purchase history, while the Python backend handles the API and serves the app.
The setup is simple because the problem is simple. I could add more infrastructure, more abstraction and a more elaborate frontend stack, but none of it would make the shopping list meaningfully better for the two people using it.
Personal tools are nice for exactly that reason. Nobody is grading the architecture. The only real question is whether the thing works.
Pantrify also contains a table-tennis game because I was too lazy to deploy it somewhere else. Software architecture sometimes has very sophisticated explanations. Sometimes the explanation is just “I couldn’t be bothered setting up another server.”
Tiny personal software is becoming much easier to justify
Pantrify itself isn’t especially complicated, but building it made me think about how much the economics of small software have changed.
A few years ago, the practical choices would probably have been to keep texting lists, settle for whatever free app came closest, or pay the subscription and move on. Building a custom application for such a minor annoyance would have felt like more effort than the problem deserved.
The effort threshold is much lower now. Small tools can be built quickly enough that “I’ll just make my own” is sometimes a perfectly sensible answer.
I don’t think every subscription should be replaced with home-built software. Plenty of paid tools solve difficult problems far better than I ever could, and I’m happy to pay for them. A different category exists at the other end of the scale, though: tiny recurring annoyances where the commercial product has become more complicated, or more expensive, than the problem feels worth.
Pantrify lives firmly in that category.
We needed a shared grocery list. I built one. Now we put things into Pantrify instead of texting shopping lists back and forth, and the problem has basically disappeared.
For a ten-minute side project, that’s enough.