Finanxy

Finanxy helps people track, plan, and manage money across personal, family, couple, and business life - all in one flexible app.

Comment

Inspiration

I have been creating Android apps since 2016. Some of those apps made money, but I often stopped maintaining them when their revenue began to decline. Later, I entered the job market because I wanted to gain professional experience, so I postponed my dream of earning a living by creating my own apps.

Creating apps has always been something that I love. I love creating product that people can actually use.

The idea for Finanxy had been sitting in my project list for a long time, possibly since before the COVID-19 pandemic in 2020. Over the years, I continued adding feature ideas and notes whenever something came to mind. Out of all my ideas, Finanxy was the one I wanted to pursue the most because I believed it had the greatest potential for an indie developer like me.

Time went by as I worked daily as an Android programmer. Then, unexpected news arrived: my company told me to look for another job because I was being laid off. It happened in December 2024.

After being laid off, I decided that it was enough. My age was also approaching 30, and that was my limit for postponing my dream.

I reconsidered the direction of my future. Should I grind DSA and LeetCode, then pursue an overseas job with higher pay? Should I try a conventional business, affiliate marketing, clothing, or another online business? Or should I go back to the thing I had always wanted to pursue, which was creating apps and hoping they could make money?

After a lot of thinking and consideration, I chose to pursue what I had always wanted, which was creating apps. It is something that I love and something that I can keep doing for a long time.

In early 2025, after starting the foundation of Finanxy, the AI boom became much bigger, with agentic AI tools such as Cursor, Augment, and Cline. I thought that eventually everyone would be able to create apps more easily.

That gave me more urgency. I felt that I was in an important window for the future of apps, and it pushed me to seriously pursue the app I had always wanted to create.

With all of those motivations, I decided to seriously pursue the dream I had postponed for so long.

What It Does

The initial idea for Finanxy was to create an expense-tracking app that included at least the important features commonly found in existing finance applications, including:

  • Expense, income, and transfer tracking
  • Budgets
  • Financial goals
  • Planned payments
  • Subscription tracking

I also wanted to add more advanced ways of recording transactions, such as:

  • Scanning receipts
  • Sharing screenshots or images
  • Using a chatbot similar to Telegram or WhatsApp
  • Tracking stock and cryptocurrency portfolios

At the beginning of development, I did not plan to ship the business features immediately. However, as development progressed, I realized that the foundation could support them sooner than expected.

Today, Finanxy is no longer just a personal expense tracker. It is an offline-first financial management app designed to help manage finances across different kinds of workspaces:

  • Personal
  • Couple
  • Family
  • Business (currently focused on small businesses)

Finanxy includes common expense-tracking features while also supporting more advanced financial management requirements.

It supports shared workspaces, multiple currencies, and decimal precision of up to 38 digits for financial calculations. We also try to follow established accounting concepts, including account-based and double-entry principles.

Transactions can maintain a revision history when their totals are modified. A single transaction can also contain:

  • Individual item details
  • Location information
  • Attachments
  • Additional transaction metadata

Finanxy supports receipt scanning to record transactions. In the future, we plan to support transaction tracking through chat platforms, notifications, shared images, and an AI assistant that can record transactions directly.

Users can back up their data through:

  • Local storage
  • Google Drive
  • Finanxy Cloud Backup for Premium users

How I Built It

I began laying the foundation for Finanxy in early 2025 while simultaneously defining the visual direction of the app, including its colors, typography, interface components, and overall UI atmosphere.

I wanted Finanxy to have a reliable foundation for expense tracking, so I referred to accounting concepts such as double-entry bookkeeping and account-based transaction recording.

Getting this foundation right was challenging. I reworked the transaction logic two or three times.

I am also an avid expense-tracker user and have consistently tracked my daily expenses for years. Based on my own review, the app I currently use is already the best expense-tracker app that I found. However, I think the app have calculation mismatches when the amount of data becomes large, possibly because existing transactions have been edited.

I wanted Finanxy to avoid these problems.

To verify the accuracy of its calculations, I created tests involving multiple years of financial data and large transaction histories. These tests help ensure that totals remain correct even when the data spans many years.

After the transaction foundation, product design, backend architecture, and technology stack were ready, I began developing the mobile and backend projects.

For the mobile application, I use Kotlin and Compose Multiplatform. The project follows a modular structure and Clean Architecture principles.

I chose Kotlin Multiplatform because I wanted my app to have native performance as much as possible. Also to be honest I support and love KMP.

The main focus is Android and iOS. Desktop and web are lower priorities, but those platforms would be useful for Finanxy’s business features.

Mobile and backend development began with the goal of completing an MVP. I started by integrating Supabase and building the synchronization system. After that, I added additional modules, including:

  • Goals
  • Budgets
  • Planned payments
  • Business features
  • Other financial management modules

Once the MVP was complete, I moved into a screen-by-screen improvement phase. I iterated on each screen day by day, refining the layouts and user experience.

The following phases included:

  • Bug fixing
  • Backend improvements
  • Infrastructure completion
  • Performance and stability improvements
  • Preparing the app for release

Finanxy is now officially live in Google Play Store.

Challenges I Ran Into

The biggest challenge was completing Finanxy with all the features I wanted.

I wanted to include as many features as possible in version 1.0.0 because I wanted to avoid migrations and migration-related workaround code that could make the codebase messy later.

Also, I often wondered when the project would finally be finished because it's been in development for some time. Thoughts like that sometimes discouraged me during development.

However, considering the scope of Finanxy, I still believe the development was relatively fast. I developed the project entirely on my own while working part-time, handling everything from design, mobile development, backend development, DevOps, marketing, and more.

Some of the main technical challenges were synchronization, backup & restore, export & import, and transaction logic. Several of these parts had to be developed more than once.

For example, the initial backup and restore implementation did not scale well for very large datasets. Loading potentially millions of records into memory at once would not be practical.

I redesigned it to use a streaming and paginated mechanism, allowing records to be loaded and processed page by page instead of all at once.

The implementation also needed to work across all supported platforms, which meant choosing approaches that were compatible with Kotlin Multiplatform.

At the same time, I had to ensure that the modular structure and Clean Architecture principles were followed without overengineering the application. Finding that balance required a significant amount of thought.

Accomplishments That I’m Proud Of

The accomplishment I'm most proud of would be finishing Finanxy itself.

This project represents the combination of all the experience I have gained throughout my years of creating applications.

Finanxy was an idea that I postponed for a long time because I did not previously have the opportunity to pursue it seriously. Unlike some of my earlier apps, which were built more casually in the hope that they might generate revenue, Finanxy has been developed with a clear long-term intention.

I want it to become a real, sustainable product and business.

I'm so excited and can't wait to release Finanxy, see how it performs in the app market, and learn how the public responds to it.

What I Learned

Building a Reusable Technical Blueprint

One of the most valuable things I gained from this project is a reusable blueprint for future applications.

I now have established foundations for:

  • Kotlin Multiplatform mobile projects
  • Backend services
  • Cloud infrastructure
  • Deployment environments
  • Synchronization systems
  • Backup and restoration

This should allow me to develop future applications more quickly because the blueprint is already based on modern technologies and lessons learned from Finanxy.

Planning for Non-Development Work

I also learned that tasks requiring multiple days of work must be included in the development timeline, even when they are not directly related to programming.

Examples include:

  • Legal preparation for the business
  • Creating and verifying an organization Play Store account
  • Meta business verification
  • Store review periods
  • Administrative and compliance work

These tasks can take a significant amount of time and should not be treated as last-minute details.

Creating Environments Early

Another important lesson was to develop the mobile, backend, and infrastructure environments as early as possible.

During Finanxy’s development, I initially postponed creating separate development/staging environments. At one point, I even considered not implementing them at all.

Eventually, I created them near the release date when I had some available time. After implementing them, I realized just how valuable they were to have.

Testing would be much more difficult without development/staging environments once the app was already available on the Play Store. Now, I can safely test changes without risking the production environment.

For future applications, I will likely establish development/staging and production environments from the beginning. They did not require too many days to implement, but the long-term benefits are significant.

What’s Next for Finanxy

What’s next for Finanxy is releasing it on iOS, desktop, and web using Kotlin and Compose Multiplatform.

Many features are also still being developed, like the business features for example.

We will also continue making Finanxy as stable as possible and improving everything from performance to UI and UX.

Built With

  • admob
  • android
  • composemultiplatform
  • kotlin
  • kotlinmultiplatform
  • revenuecat
  • supabase
Share this project:

Updates

Submission history