transfer confirmed
mid risk user
transfer menu
options menu
high risk user
simulate menu
low risk user
find help mid
find help high

About the Project

Inspiration

Freelancers and independent workers often face a problem that traditional financial tools do not fully reflect: their income may be irregular even when their financial behavior is responsible.

Someone can earn different amounts each month and still consistently pay bills, save, and manage their money well.

We wanted to build something that went beyond simply showing balances and past transactions.

Capi Frog helps people with irregular income understand their financial stability, save more intelligently, detect risk early, and strengthen their financial readiness.

What It Does

Capi Frog is a financial wellness assistant designed for freelancers and users with variable income.

It helps users understand:

how financially stable they are
how much they can safely save
where they should prioritize their savings
how resilient they would be if their income decreased
what behaviors are strengthening their credit readiness

The application automatically classifies the user into:

Stable
Medium Risk
High Risk

If risk increases, Capi Frog activates Find Help Before You Need It, which explains what is changing financially and shows how the user could handle situations such as reduced income or an unexpected expense.

Capi Frog also includes Credit Readiness, which highlights behaviors such as consistent payments, recurring income, financial cushion, and income variability. It is not intended to replace an official credit score.

How We Built It

Frontend

We designed and iterated the experience in Figma, then implemented the application using:

React
TypeScript
Vite

React allows the interface to update dynamically depending on the user's financial state.

Backend

Our backend is built with Python and FastAPI.

It processes the user's financial information and calculates features such as:

savings rate
income stability
financial cushion
debt-to-income ratio
spending volatility

These values are then sent to our machine-learning model.

Machine Learning

We use a Logistic Regression model with Scikit-learn to estimate financial risk.

We selected Logistic Regression because it is fast, interpretable, and well suited for tabular financial data.

For the prototype, we use synthetic financial profiles and financial stress simulations to represent scenarios such as:

reduced income
unexpected expenses
shrinking financial cushion

The trained model is stored using Joblib in a .pkl file so the backend can reuse it without retraining every time the server starts.

Gemini

We integrated the Gemini API as the natural-language layer of the application.

Gemini does not calculate the financial-risk score. Our backend performs the calculations first, and Gemini receives the structured results and transforms them into clear, personalized feedback.

This allows us to separate:

financial analysis from financial explanation.

Challenges We Faced

One of our biggest challenges was defining the right target user.

The original problem could apply to many different groups, but a solution designed for everyone quickly becomes too generic. We explored several possible demographics before focusing on freelancers and people with irregular income, especially users whose financial behavior may be responsible even though their income does not look like a traditional paycheck.

That decision also affected the features we chose to prioritize. We had to continuously evaluate which features actually solved that user's problem and which ones only added complexity. This led us to focus on financial stability, safe-to-save recommendations, income variability, credit readiness, and early risk detection.

Another challenge was implementing those features as one connected experience rather than a collection of separate tools. The financial-risk states, savings recommendations, Credit Readiness, Gemini explanations, and frontend interface all needed to respond to the same underlying financial information.

We also had to integrate the React frontend with the Python/FastAPI backend and machine-learning model while continuing to iterate quickly on the interface.

Finally, integrating the Gemini API required some iteration to make sure the model received the right structured financial context and returned useful, concise feedback. This helped us refine Gemini's role in the project: our financial engine performs the calculations, while Gemini turns those results into understandable and personalized guidance.

What We Learned

This project taught us the importance of combining technical functionality with a clear user experience.

We learned how to:

connect a React frontend to a Python/FastAPI backend
integrate a machine-learning model into a real application
use Gemini as an explanation layer instead of relying on it for core calculations
design around irregular income rather than assuming every user has a traditional paycheck
balance useful features with a simple interface

Most importantly, we learned that income variability does not automatically mean financial instability.

Capi Frog is designed to help make that difference visible.