Why I Built TallyPal: The Story Behind the App

There's a moment that happens in almost every friend group. Someone says "let's split this" and suddenly everyone's pulling out their phones, trying to figure out who owes what. Notes are scratched down. Numbers get recalculated. Someone inevitably gets confused.

That moment frustrated me enough to build something.

The Problem Was Personal

I wasn't thinking about building a startup or creating the next big thing. I was just tired. Tired of calculator apps that were clunky. Tired of spreadsheets that went out of sync. Tired of screenshots of receipts that got lost. But more than anything, I was tired of feeling like I couldn't trust where my expense data was going.

I'd look at other bill-splitting apps and think: "They're storing this on their servers somewhere." That shouldn't require a leap of faith. Why should tracking who owes what for pizza require giving a company access to all those personal details?

That's where TallyPal started. Not as an idea for an app. Just as a question: What if nobody had to store this data anywhere except their own phone?

Building Around Privacy

That single constraint—"keep data local"—shaped everything that came after. It meant using IndexedDB instead of cloud storage. It meant no login system, no accounts, no company database tracking your expenses.

At first, I worried this would feel limited. But the opposite happened. It felt liberating. I could build something that was genuinely just for the user. Not something optimized for data collection or future monetization. Just an app that did one job well: help you split bills.

The privacy part also meant I didn't have to worry about building a backend infrastructure. No servers to maintain. No database to secure. That sounds like a small thing, but it changes how you think about a product. You're not managing infrastructure. You're solving a real problem.

The Design Journey

I wanted TallyPal to look clean. Not minimalist in a pretentious way, but minimal in the way that lets you actually use it without friction. The soft purple, mint green, and coral colors came from wanting something that felt modern but wasn't cold. I spent a lot of time thinking about how someone would actually use this on their phone during a meal with friends.

Every button, every form, every calculation had to earn its place. I didn't want to build something that had every feature imaginable. I wanted to build something that made the most common use case—five friends at dinner splitting a bill—feel natural.

The split methods took time too. Supporting equal splits seemed obvious. But then you realize some people split by percentage. Some people want to say "this person had a more expensive meal." Some groups need to account for someone who doesn't eat. So instead of hardcoding one way, I built it to be flexible enough to handle however your group actually splits things.

The Small Decisions That Mattered

There were so many small choices that ended up mattering more than I expected. Like, how do you settle debts efficiently? If Alice owes Bob $20 and Carol $10, and Bob owes Carol $15, what's the minimum number of actual payments needed? That's a real problem, not just a nice-to-have.

Or timestamps. Should I include them? Most bill-splitting apps do. But for local data on someone's personal phone, I realized timestamps were actually noise for most people. So I included them for data integrity but kept them out of the interface. The data's still there if you need it. It's just not cluttering the view.

The export feature came from thinking about what happens if something goes wrong. Your phone breaks. You switch devices. You want to move your data somewhere else. I wanted to give people actual control over their information. Not "email us and we'll see what we can do," but "download your data right now as JSON and use it however you want."

Why It's Open Source

Midway through building, I realized something: if this app is doing the right thing by keeping data private, why would I lock people into using my version of it? If the code is sound, it should be fine to show it. If there's a security issue, people should be able to see it and help fix it.

So I open-sourced it. Not for the clout. Because it made sense. If you're using this to track money between you and your friends, you deserve to know exactly what's happening with that data.

What I'm Proud Of

I'm proud that TallyPal works offline. You can be in the middle of nowhere with no signal and still add expenses and figure out who owes what. That's not a coincidence—that's by design.

I'm proud that you don't need an account. No email verification. No password recovery. You just open the app and start using it. That simplicity comes from months of thinking about what was actually necessary and what was just habit.

I'm proud of the settlement algorithm. It's not fancy, but it works. It minimizes the number of payments needed to settle up. In a group of four people with complicated debts, that means fewer transactions, less confusion, less back-and-forth.

And honestly? I'm proud that it's fast. That might sound weird to mention, but it matters. The app loads instantly. It responds immediately. There's no waiting for a server. That responsiveness makes it feel less like an app and more like a native tool.

The Thing Nobody Talks About

When you build something open source and free, there's this constant question that creeps in: "Is this crazy?" You're spending your time building something that makes zero money and requires zero commitment from users.

But here's what I realized: that's exactly why I wanted to build it. There are no compromises. There's no team trying to figure out monetization strategies. There's no pressure to add features that make the product worse so you have incentive to upgrade to a paid tier.

It's just me, trying to make something useful. And whether one person uses it or a thousand people use it, that doesn't change the goal.

Where It's Going

TallyPal isn't trying to be everything. It won't have AI features. It won't have social capabilities. It won't try to become a financial platform.

What it will do is stay simple, stay private, and stay useful. If you and your friends need to split a bill, it should just work. If you want to export your data, great. If you want to use it offline, perfect. If you want to look at the code and understand exactly what it's doing, the option is there.

Those aren't revolutionary features. But they're built on a pretty straightforward philosophy: make something useful, keep it simple, respect your data.

And that's worth building.

---

*TallyPal is free and open source. No login required. All data stays on your device.*