Why We're Building SharedGroceryList

SharedGroceryList is a shared grocery list app built on the premise that the household — not the individual user — is the first-class object. We started building it after recognising that shared grocery management is a coordination problem, not just a list problem — and that most existing tools treat sharing as an afterthought rather than the core design constraint. This is the honest story of how we got here and what we're building.

The starting point

Every product starts somewhere specific. Not a market analysis. Not a gap in the competitive landscape. A moment where you're standing somewhere, frustrated, thinking: this should not be this hard.

For us, that moment was household coordination — specifically, the recurring experience of grocery shopping with another person using tools that were never designed for two people to use simultaneously. The list lived in WhatsApp. One person was at the store. The other was at home, remembered something, and sent a message. The person at the store didn't see it in time. Something got missed. There was friction that had no good reason to exist.

It happened once, then again, then so regularly that it started to feel like the kind of problem someone should have solved. We looked for apps that had. We found some that came close. None that fully solved it.

The obvious question

Why didn't we just use a grocery list app?

We'd tried. Apple Reminders, at the time, required both people to be on iOS for sharing to work properly. One of us was on Android. Google Keep worked, but it didn't have real-time check-off visibility — you couldn't see what was already in the basket while someone else was shopping. We'd tried AnyList. It was solid, but the free tier limited sync across more than a couple of devices, and we resented paying a subscription for something this basic.

The WhatsApp thread was the path of least resistance. We kept using it. We kept missing things.

Why this problem is underestimated

Grocery coordination looks trivial from the outside. It's just a list. People have been managing lists for as long as there have been lists.

But shared grocery management is a coordination problem, not a list problem. It requires:

• Both people to have access to the same list at the same time
• The list to update live, not on a sync cycle
• A way to signal in-progress state (this item is already in the basket)
• Cross-platform support, because households don't all run the same OS
• Notification logic that's signal, not noise — you want to know when something was added, not be pinged every thirty seconds

That's a lot of requirements for something people call "just a list." And it's why so many households end up back in WhatsApp within a week of trying an app that doesn't meet all of them.

What we looked for

Before building anything, we spent time with the apps that already exist. We have a lot of respect for what AnyList and Bring! have built. They've solved real parts of this problem.

What we kept noticing: most apps are built primarily for the individual user managing their own list, with sharing bolted on. The shared experience — what it's like when two people are both actively using the same list at the same time — is often an afterthought.

The in-store check-off moment is a good example. When you check an item off a list, that action needs to propagate to everyone else looking at the list right now — whether they're at home or in the next aisle. In several apps we tested, there was a noticeable lag. In others, you had to manually refresh. In one, checked-off items disappeared for one user but stayed visible for another.

These aren't catastrophic failures. They're small frictions that accumulate. They're the reason households end up texting anyway.

The product we decided to build

SharedGroceryList starts from a different premise: the household is the first-class object, not the individual user.

When you sign up, you don't create a personal account and then optionally share lists. You create a household. A shared space. Everyone you shop with gets invited into that household, and every list inside it is automatically visible to all of them. No per-list permission management. No "did you share this one with me?" confusion.

Inside the household, the list behaves as a live document. Items appear immediately across all devices. Check-offs propagate in real time. When your partner adds something from home while you're in the store, it shows up on your phone without you having to do anything. When you cross something off, they know.

We're building on Android, iOS, and web from day one. A shared household app that only works on one operating system is not really a shared household app.

What we're not building

We want to be honest about scope.

We are not building a meal planner. Recipe integration is genuinely useful, and apps like AnyList have done it well. It is not what we're building right now. We made a decision early on: do the shared grocery list better than anyone else, and do nothing else until that's true.

We're not building a household management platform — calendars, chores, budgets. There are apps for that. We're building the app that makes grocery shopping better for households who shop together.

Narrow focus is a deliberate choice, not a roadmap gap.

Where we are now

SharedGroceryList is in closed beta. A handful of households are using a pre-release build. The feedback has been encouraging — specifically around the real-time sync and the aisle-organization features, which were the two things most users told us were missing from whatever they'd tried before.

We're not shipping to the public yet because we want to get the core experience right before we scale it. There's a version of this where we rush a launch, the sync is flaky, a few households have a bad experience, and we spend months recovering trust. We're not doing that.

The waitlist exists to find the households who want to be first — people who will tell us honestly when something isn't working, and who will feel the difference when it is.

The honest version of why we're doing this

There are more important problems in the world than household grocery coordination.

But shared domestic coordination is something that millions of households manage with tools that weren't designed for it. The friction is real. The time it wastes is real. The low-grade annoyance of a "can you also grab..." text arriving at exactly the wrong moment is real.

And the opportunity to build something that genuinely fixes this — that a household adopts and then never thinks about again because it just works — is one of those unsexy, unambiguous, permanently useful things.

That's what we're trying to build.