Building Fortuna: How I used AI to speed up the development
Behind Fortuna: How I used AI
In the first post, I shared why I built Fortuna. This post is about how - the technology decisions that made it possible to build a secure, finance app in four months of weekend work.
This isn’t a developer tutorial, but it’s also not hand-waving. I want to share the actual tools and tradeoffs that turned an idea into software that now tracks thousands of transactions across 4 bank accounts, with zero infrastructure costs.
Guiding Principles
Every decision was measured against a few core principles:
- Build Fast, but Build Right: With limited time, development had to be efficient. This meant choosing tools that accelerate progress without sacrificing quality or creating future problems.
- Keep It Simple: The application needed to be easy for me to build and, more importantly, easy for me and my family to use. Complexity was the enemy.
- Security and Privacy First: Since the app handles sensitive financial data, every choice had to reinforce user privacy and data security.
These principles led to concrete outcomes: 4 months from first line of code to production. The app now handles thousands of transactions across 4 bank accounts from April - December 2025, 60 plus personal documents with no infrastructure costs thanks to the local-first architecture. Finally, most importantly, user delight too.
The Technology Philosophy: Simple, Powerful, and Secure
Choosing the right technology wasn’t about picking the most popular new thing. It was about finding a set of tools that worked together to meet the guiding principles.
The Backend: Python + FastAPI
The backend handles all data processing, calculations, and business logic. I chose Python with FastAPI for three specific reasons:
-
Built for Financial Data: Python’s data analysis libraries (pandas, numpy) are industry-standard. Calculating investment returns, analyzing spending patterns, generating reports—these are all tasks Python was designed for. It’s the same reason Bloomberg, hedge funds, and fintech companies use it.
-
Future-Ready for Machine Learning: I want Fortuna to learn from my categorization habits and auto-categorize transactions. Python’s machine learning ecosystem makes this a weekend project instead of a month-long rebuild.
-
Readable and Maintainable: As a weekend project, I might not touch the code for weeks. Python’s syntax is clear enough that I can pick up exactly where I left off without wasting hours deciphering what past-me was thinking.
FastAPI specifically accelerates development—it auto-generates API documentation and validates data automatically. Less boilerplate code means more time building features that matter.
The Frontend: React + Tailwind + shadcn/ui
The frontend is everything you see and interact with. I chose React with Tailwind CSS and shadcn/ui components.
Why this stack specifically?
React is the safe choice—it’s used by Facebook, Airbnb, Netflix, and millions of production applications. It’s mature, well-documented, and has an enormous community.
shadcn/ui deserves special mention. It’s a collection of accessible, well-designed components you can copy into your project. Need a dropdown? A modal? A date picker? They’re already built, accessible (screen reader support, keyboard navigation), and professionally styled. This gave Fortuna a polished look in days instead of months.
On using AI: I validated these technology choices with Claude. I described what I was building and asked for recommendations. The AI suggested this exact stack. I researched each recommendation—they aligned with what the industry uses. This approach saved weeks of research while ensuring I wasn’t adopting experimental frameworks that might be abandoned in six months.
Technology Stack at a Glance
For the business-minded readers, here’s the quick reference:
| Component | Technology | Why It Matters |
|---|---|---|
| Backend | Python + FastAPI | Fast development, powerful financial calculations, easy to maintain |
| Frontend | React + Tailwind CSS + shadcn/ui | Industry standard, professional UI in days not months, accessible |
| Database | SQLite (single file) | No server setup needed, portable, proven technology |
| Authentication | bcrypt password hashing | Industry-standard security, same approach as major apps |
| Storage | Local-first (single file) | Your data stays on your computer, no costs |
Putting my Privacy and Security First
When dealing with financial information, trust is everything. Fortuna is designed to be local-first. Your financial data is stored in a single file on your own computer, not on a remote server in the cloud. This was very important for me and was a deliberate choice I made.
This has several key benefits:
- Total Privacy: Your data never leaves your control.
- No Hosting Costs: There’s no need for expensive cloud databases.
- Simplicity: The app works without any complex database installation or configuration.
This approach is perfect for a personal or single-household application where massive, multi-user scale isn’t a requirement.
The technical detail: Fortuna stores everything in a SQLite database file. SQLite is proven technology—it’s used in iPhone apps, web browsers, Android, and even aircraft software. It’s literally the most deployed database engine in the world. For you, this means Fortuna is a single file you can back up to Dropbox, copy to a USB drive, or store wherever you keep important documents.
Secure Login and Document Protection
Security was integrated at every level:
- Secure Authentication: User passwords are not stored directly. Instead, the system uses bcrypt, an industry-standard hashing algorithm, to protect credentials. The login system is designed to be “stateless,” a modern approach that enhances security and simplifies the architecture.
- Encrypted Document Storage: You can upload sensitive documents like bank statements or tax returns to Fortuna. To protect them, these files are encrypted. The encryption key is derived from your password and is never stored anywhere. This means that even if someone gained access to your computer and the app’s data file, your documents would remain unreadable without your password.
What this means in practice: If your laptop is stolen, your financial data is protected by encryption. Your password can’t be recovered from the system (only reset). If Fortuna’s code were somehow compromised, attackers still couldn’t decrypt your documents without your password. This is the same security model used by password managers like 1Password and Bitwarden.
What I’d Do Differently
Building Fortuna taught me where my assumptions were wrong:
More automated testing, earlier. I initially tested features manually—click through the UI, verify it works, move on. This worked fine at first but became time-consuming as features stacked up. One change would break something three screens away. Automated tests (code that verifies the app works correctly) would have caught these regressions immediately. I’m adding them now, but I should have started on day one.
Earlier user feedback from actual non-technical users. I built features I thought were important. Some were. Some weren’t. My wife kept asking for bulk transaction editing, which I thought was minor. Regular check-ins with actual users (not just my own assumptions) would have focused development better.
The Bottom Line
Build for your users, not your idea of your users. Even when your user is your spouse.
These aren’t failures - they’re calibrations. The app works. People use it. But software is never “done.” It evolves with its users. With the right tools, pragmatic choices, and weekends, one not-so-technical person can build software.
We’re entering an era where “I need an app for X” doesn’t mean “I need to hire developers.” It means “I need 4 months of weekends.” AI isn’t replacing developers - it’s making software development more accessible. The barrier isn’t technical anymore. It’s whether you start.