I Wanted Better Insights Across My Bank Accounts, So I Built MyVault

Timur Shagiakhmetov — Sun, 07 Jun 2026 15:42:17 +0000

Most side projects start with a simple frustration.

Mine started with a banking app.

One of my banks had a feature I really liked. It automatically categorized transactions and showed spending breakdowns in graphs and charts. For the first time, I could easily see how much I spent on restaurants, groceries, transport, subscriptions, and other categories.

The problem was that only one of my banks offered this feature.

Like many people, I use multiple bank accounts, credit cards, and savings accounts. Two of my other banks provided little more than a long list of transactions. If I wanted a complete picture of my finances, I had to switch between apps and manually piece everything together.

As a software engineer, my first instinct was obvious:

"Why don't I just build this myself?"

That idea eventually became MyVault.

The Original Goal

The first version of the project was surprisingly simple.

I wanted users to:

Upload bank statements
Extract transaction data
Automatically categorize spending
View useful charts and reports

The goal wasn't budgeting.

It wasn't investment tracking.

It wasn't accounting.

I simply wanted a single place where I could see spending across all of my bank accounts.

Once I started building, however, I realized there was a much more interesting opportunity.

If all transaction data was already extracted and structured, why not allow users to ask questions about their finances?

Instead of searching through transactions manually, users could simply ask:

How much did I spend on restaurants last year?
What subscriptions am I paying for?
Which categories increased the most this month?
How much did I spend while traveling?

That's when MyVault started evolving from a reporting tool into an AI-powered financial assistant.

Building as a Solo Developer

One of the biggest challenges wasn't technology.

It was building everything alone.

When you're working on a side project, you don't just write code.

You become responsible for everything:

Product decisions
Backend development
Frontend development
Infrastructure
Testing
Security
Support
Marketing

At a larger company, a single feature might involve multiple engineers, designers, product managers, and QA specialists.

As a solo developer, every decision lands on your desk.

The advantage is speed.

The disadvantage is that there is nobody else to blame when something breaks.

Learning Next.js

Most of my professional experience has been backend-focused.

For MyVault, I decided to build the frontend using Next.js.

This turned out to be one of the most educational parts of the project.

Modern frontend development involves much more than rendering pages.

I spent time learning:

Server-side rendering
Static generation
SEO optimization
Metadata management
Internationalized routing
Client and server components

One lesson I learned quickly is that building a good user experience requires attention to countless small details.

Many of those details are invisible when everything works correctly.

Why I Chose FastAPI

For the backend, I wanted to use a technology I had not previously used in production.

I chose FastAPI.

It turned out to be an excellent fit for the project.

FastAPI provides:

Strong type safety
Automatic API documentation
Validation out of the box
Excellent performance
Great support for modern Python development

Since MyVault relies heavily on AI-related functionality, building on top of Python made a lot of sense.

Many AI tools and libraries appear in the Python ecosystem first, making experimentation significantly easier.

AI Coding Assistants Changed Everything

A few years ago, building a project like this alone would have required significantly more time.

Today, AI coding assistants have become part of my daily workflow.

I regularly use them for:

Exploring new technologies
Generating boilerplate code
Debugging issues
Refactoring existing code
Writing documentation
Learning unfamiliar frameworks

The most interesting impact isn't that AI writes code.

It's that it lowers the cost of learning.

As a backend engineer, I could move much faster through frontend challenges because AI helped explain concepts, suggest solutions, and generate examples.

You still need engineering judgment.

You still need to review everything carefully.

But the productivity boost is difficult to ignore.

Parsing Bank Statements Is Harder Than It Looks

Initially, I assumed bank statement processing would be straightforward.

Upload PDF.

Extract text.

Done.

Reality was different.

Every bank formats statements differently.

You encounter variations in:

Date formats
Currency formats
Transaction descriptions
PDF layouts
Statement structures

Even simple things like merchant names can appear in multiple formats.

Before any useful analysis can happen, transaction data needs to be normalized into a consistent structure.

Only then can meaningful insights be generated across multiple banks.

This became one of the most interesting technical challenges in the project.

Supporting 22 Languages

From the beginning, I wanted the platform to be accessible to users around the world.

That meant translating far more than just the user interface.

The project includes:

Navigation
Blog posts
Metadata
Financial categories
User-facing messages
Documentation

Supporting 22 languages sounds exciting until you start maintaining them.

Every new feature potentially affects dozens of localized versions.

A small text update can suddenly become a much larger task.

Despite the complexity, I believe localization is worth the effort.

Too many products assume every user is comfortable using English.

Supporting 24 Currencies

Financial software becomes more complicated the moment multiple currencies enter the picture.

People spend money while traveling.

They hold accounts in different countries.

They earn income in one currency and spend in another.

To provide meaningful insights, the system needs to account for currency differences and present information consistently.

Supporting 24 currencies introduced another layer of complexity, but it was important for making the platform useful beyond a single market.

Privacy and Security

Whenever someone uploads financial data, security becomes one of the first questions.

I wanted to keep the design as privacy-focused as possible.

The approach is straightforward:

Uploaded bank statements are processed to extract transaction information.
Original PDF statements are not permanently stored on disk or in the database.
The system focuses on transaction data rather than retaining full documents.
Communication between the browser and the server is protected using TLS encryption.

Trust is essential for any financial product.

Without trust, even the most advanced features become irrelevant.

From Dashboards to Conversations

One of the most interesting developments during the project was the shift toward conversational interfaces.

Traditional finance applications rely heavily on dashboards, filters, menus, and reports.

Those tools are useful, but they often require users to know where information is located.

AI changes the interaction model.

Instead of searching through screens, users can ask questions directly.

For example:

What subscriptions am I paying for?
How much did I spend on groceries last month?
Which category grew the fastest this year?
What are my largest recurring expenses?

The underlying data remains the same.

The difference is how users access it.

The goal isn't to replace visual reports.

It's to make financial information easier to understand.

What I Learned

Building MyVault reinforced several lessons.

First, many good products start with a personal problem.

I wasn't searching for a startup idea.

I simply wanted better visibility across my own bank accounts.

Second, modern AI tools have dramatically expanded what solo developers can accomplish.

Projects that once required small teams can now be built by individuals.

Third, seemingly simple features often hide surprising complexity.

Bank statement processing.

Transaction categorization.

Currency support.

Localization.

Each looked easy at first.

None of them were.

Finally, users rarely care about the underlying technology.

They care about outcomes.

Nobody uploads a bank statement because they are excited about AI.

They do it because they want a better understanding of their money.

What's Next?

The project is still evolving.

There are plenty of opportunities to improve financial insights, add smarter AI capabilities, and make financial information even easier to explore.

But the core idea remains unchanged from the original version.

Help people understand where their money goes, regardless of which bank they use.

That simple frustration with multiple banking apps eventually became a product.

And like many side projects, it started with solving a problem I personally wanted solved.

If you're building your own side project today, that's probably the best place to start.

DEV Community: Timur Shagiakhmetov