DEV Community: Rishikumar Yadav

I Built My Own Budget Tracker - Because I Didn't Want to Pay a Monthly Subscription

Rishikumar Yadav — Sat, 05 Sep 2026 06:14:00 +0000

## Why I Built My Own Personal Budget Tracker

For a long time, I wanted a simple way to keep track of my personal finances. Not something complicated. Not something that required learning a financial system. And definitely not something that asked me to pay a monthly subscription just to keep track of my own money. So I decided to build one myself. That project eventually became a Personal Budget Tracker & Finance Analytics Tool.

The Problem

There are plenty of budgeting and personal finance applications available today. Many of them are actually good.

But I kept running into the same problem:

Why should I have to pay every month to track my own budget?
For someone who simply wants to record income, expenses, savings, accounts, and transactions, a subscription can feel unnecessary.

I wanted something that I could:

Build for myself
Customize whenever I wanted
Understand completely
Host privately
Extend with features I actually needed
Use without a recurring subscription

And since I'm a web designer and developer, the obvious answer was:
Build it myself.

From a Simple Idea to an Actual Application

The original idea was extremely simple:

"I just need somewhere to record my expenses."

But once I started designing it, I realized that simply recording expenses wasn't enough. Money doesn't exist in isolation.

You have different accounts.
You receive income.
You spend money.
You transfer money between accounts.
You save.
You may have cash, bank accounts, wallets, investments, or other financial sources.

So instead of building just an expense tracker, I started thinking about the bigger picture.

The goal became:

Build a complete personal finance tracker rather than just an expense list.

What I Built

The application gradually evolved into a personal finance dashboard with multiple parts working together.

a] Dashboard

The dashboard provides an overview of the current financial situation.
It focuses on things such as:

- Total Income
- Total Expenses
- Savings
- Account Balances
- Financial Activity
- Overall Financial Position

The idea is that I shouldn't have to open multiple pages just to understand what's happening with my money.

b] Accounts

Accounts are one of the core parts of the application. Instead of treating all money as one balance, the application keeps track of individual accounts.

For example:

Bank Account
Cash
Digital Wallet
Savings Account

Each account can have its own transactions and balance.
This also makes it possible to understand where the money actually is, rather than only knowing how much money exists in total.

c] Transactions

Transactions are the heart of the tracker. Every financial movement needs to be recorded correctly.
A transaction can represent things such as:

Income
Expense
Transfer

This sounds simple, but transaction logic becomes surprisingly important once multiple accounts are involved.

For example, if I transfer ₹5,000 from Bank A to Bank B:

Bank A
-₹5,000

Bank B
+₹5,000

My total money hasn't changed. Only its location changed. That distinction is important when calculating balances, savings, and net worth.

d] Bank-to-Bank Transfers

One of the features I specifically wanted was proper account-to-account transfers. A transfer should not be treated as income and expense. Otherwise, transferring money between my own accounts would incorrectly make it look like I earned and spent additional money. So the application treats transfers as their own financial operation.

For example, transferring ₹5,000 from Bank A to Bank B:

Bank A
-₹5,000

Bank B
+₹5,000

Otherwise, transferring money between my own accounts would incorrectly make it look like I earned and spent additional money.
So the application treats transfers as their own financial operation.

Conceptually:

Account A
    ↓
Transfer
    ↓
Account B

The overall net worth remains unchanged. Only the account balances change.

e] Balance Logic

One of the areas where the project became more interesting was handling account balances correctly.

I didn't want balances to be manually maintained.

Instead, the current balance is calculated based on the account's opening balance and all the transactions associated with it.

Conceptually:

Opening Balance
+ Income
- Expenses
- Transfers Out
+ Transfers In
= Current Balance

This makes the transaction history the source of truth. If something looks wrong, I can inspect the transactions instead of wondering why a manually entered balance doesn't match reality.

For example:

Opening Balance      ₹20,000
Income              +₹10,000
Expenses             -₹4,000
Transfers Out        -₹3,000
Transfers In         +₹2,000
--------------------------------
Current Balance      ₹25,000

That helps keep account balances consistent as the number of transactions grows.

f] Net Worth

Another feature that naturally came out of the project was net worth.
Instead of only asking:

"How much money do I have in this account?"

I wanted to be able to see my overall financial position.

The basic idea is:

Total Assets
- Total Liabilities
= Net Worth

For example:

Bank Account        ₹50,000
Savings Account     ₹30,000
Cash                ₹10,000
----------------------------
Total Assets        ₹90,000

Credit Card Due     ₹15,000
----------------------------
Net Worth           ₹75,000

This gives a much clearer picture of the overall financial position rather than looking at individual account balances separately. It also means that moving money between my own accounts doesn't artificially increase my net worth.

Tech Stack

The project is built using a simple and familiar web technology stack.

I didn't want to overcomplicate the architecture. The goal was to use technologies I already understood and could maintain myself.

The main stack includes:

HTML
CSS
JavaScript
PHP
MySQL

The frontend handles the interface and interaction.
PHP handles the server-side logic.
MySQL handles the financial data.
The architecture isn't designed to be unnecessarily complicated.
For a personal finance application, I would rather have a system that I understand completely than add layers of technology simply because they're popular.

Design Philosophy

While building the tracker, I didn't want it to feel like a traditional accounting application.
Personal finance can already feel complicated, so I wanted the interface to make things easier to understand rather than adding more complexity.

The main goal was:

Simple
  ↓
Clear
  ↓
Useful
  ↓
Reliable

The idea was:

Useful Feature
      ↓
Solves a Real Problem
      ↓
Keep It

rather than:

Feature
Feature
Feature
Feature
Feature
      ↓
More Complexity

For me, good design isn't about making an application look impressive. It's about making the application easy to understand, comfortable to use, and reliable enough to trust.

The project isn't just a concept or a demo.It evolved into a private tracker that is being used by a small group of people close to us.

That changed how I approached development. When you're building something only for a portfolio, it's easy to say: "This should work."

When real people use it, you start asking different questions:
What happens if someone enters incorrect data?
What happens when an account becomes inactive?
What happens when money moves between accounts?
What happens when there are hundreds of transactions?
Can users understand what the dashboard is showing?
Can financial data be recovered?
What happens when something doesn't match?

Real usage exposes problems that aren't always visible during development. And that's probably one of the most valuable parts of building this project.

What I Learned

Simple applications aren't necessarily simple to build
Data correctness matters more than visual design
Real users are better testers than assumptions

Instead of trying to predict every possible requirement, I'm letting real usage help determine what should be improved next.

What's Next?

The project is now moving toward Version 1.1.
Rather than adding dozens of random features, the next version is focused on a few practical improvements.

Planned for Version 1.1
ITR Filing Details
Monthly Financial Snapshots
Small Financial Insights

The idea is to build these based on actual usage and feedback rather than simply adding features because they sound interesting.

Why I Didn't Just Use Excel ?
This is probably the obvious question. Yes, I could have built a spreadsheet. And honestly, spreadsheets are incredibly powerful.

But building the application myself gave me something a spreadsheet couldn't:

A system designed specifically around the way I wanted to manage my finances.
I can decide how accounts work.
I can decide how transactions behave.
I can design the dashboard.
I can add features when I need them.
And most importantly: I understand what's happening behind the interface.

This Started as a Personal Project, I didn't start this project thinking:

"I'm going to build a finance product."

I started with:

"I want to track my budget without paying a monthly subscription."

That's it.

The application grew from that simple requirement. And I think that's one of the best ways to build software.

Start with a real problem.
Solve it.
Use the solution.
Find the problems with your solution.
Improve it.
Repeat.

Final Thoughts

Building this Budget Tracker has been less about creating another finance application and more about learning how to build software that people can actually rely on.

It combines several things I enjoy:

Web Design
Frontend Development
Backend Development
Database Design
UX
Data Visualization
Problem Solving

And there's still a lot left to improve. For now, the goal isn't to build the biggest personal finance application. It's to build a simple, reliable and useful one.

One that solves the problem that started everything: I just wanted to keep track of my money without paying a monthly subscription.

And apparently, the easiest way to get that was to build the thing myself.

Thanks for Reading

If you're also building a personal project, I'd love to hear about it. Sometimes the smallest problems make the most interesting projects.

Rishikumar Yadav

What is GEO (Generative Engine Optimization) — and Why You Should Care as a Web Designer & SEO Specialist

Rishikumar Yadav — Fri, 10 Oct 2025 10:39:28 +0000

In recent years, the way users search for information online has shifted dramatically. Instead of typing a keyword into Google and scrolling through a list of results, more and more people are using AI-powered tools like ChatGPT, Gemini, Perplexity, Bard, and others. These tools often give direct, conversational, synthesized answers rather than just a list of links.

To stay visible in this changing landscape, a new optimization strategy has emerged: Generative Engine Optimization (GEO). If you work in web design, frontend development, server management, or SEO — GEO is something you must understand and start integrating into your work.

What Exactly Is GEO?
GEO stands for Generative Engine Optimization.
It refers to optimizing your content (and technical setup) so that AI tools are more likely to pick your site’s content as part of their answers. That means better structure, clarity, credibility, and context — not just keywords.[2]
Unlike traditional SEO, where the goal is to rank high in search engine result pages (SERPs), GEO is about being cited or used in AI-generated responses. Think of it as optimizing for a world where users may never click through to a link because the AI tool already gave them your answer.[1]

Key Differences: GEO vs SEO

Main Goal
Traditional SEO focuses on ranking well in search engine results pages (SERPs) like Google or Bing by using keywords, backlinks, and other ranking factors. In contrast, GEO (Generative Engine Optimization) aims to have your content included or cited in AI-powered answers, summaries, or overviews produced by generative search engines and AI assistants.
Content Style
SEO content is typically keyword-rich, often optimized around search volumes and may use repetition for ranking purposes. GEO content, on the other hand, emphasizes clarity, structure, depth, semantic meaning, readability, and authority — making it more useful for AI systems to reference and summarize.
Structure
With SEO, structure revolves around meta tags, headings, internal linking, page speed, and backlinks. GEO builds on these basics but adds structured data/schema, FAQ or Q&A sections, clarity, use of lists and summaries, and citing credible sources — elements that help AI engines understand and extract information more effectively.
Measurement
SEO success is measured through organic traffic, rankings, click-through rate (CTR), and backlinks. GEO success is measured differently: it’s about visibility in AI-generated results, citation frequency, and how often your content is used within AI-generated answers.

Why GEO Matters — Especially for You
If your work involves frontend development, SEO, server management, content design, GEO gives you a chance to lead, not get left behind.

Here’s why:

First-mover advantage: Many sites are still optimized only for traditional SEO. Implement GEO principles early and you’ll be ahead of competitors in being surfaced by AI tools.

User behaviour is changing: More people are asking questions in natural language, expecting instant answers. The role of conversational search / AI assistants is growing. If your content is not AI-friendly, you may be invisible to a large chunk of your audience.

Design & performance gains double up: Good structure, fast loading, clean markup, good accessibility — all help both for SEO and GEO. So your skills in frontend & server optimization matter more than ever.
Brand authority & trust become even more critical: AI models often prefer citing sources that appear authoritative, up-to-date, and useful. Ensuring that your content shows experience, expertise, authority, and trustworthiness (E-E-A-T) is essential. [3]

How to Optimize for GEO: Practical Steps
Here are actionable things you can do, especially with your web design / frontend / server + SEO combo:

Organize content clearly. Use headings (H2, H3), bullet lists, FAQs. Summaries at top or bottom. Make content “scannable”.

Rich media & context. Include images, diagrams, maybe even short videos. Sometimes AIs include images or visuals.

Citations & references. Link out to credible sources; quote stats or research. This signals credibility.

Technical health. Good page speed, mobile responsiveness, SSL, structured data (schema.org) are even more important. If AI can’t crawl or understand your content well, it won’t use it.

Semantic/Conversational keyword research. Think about how people ask questions naturally. Use long-tail, question forms (“how to”, “why is”, etc.).

Monitor and iterate. Use tools / analytics to see what content gets cited / utilized by AI engines, then refine. You might measure brand mentions in AI, or test prompts and see which content shows up.

Challenges & What to Watch Out For

Metrics are still evolving. Geo visibility isn’t as well-defined as “rank on page 1” yet.
Dependence on AI platforms’ black-box behaviours. Models update often, criteria may change.
Potential for over-optimization; content that reads too much like it’s “made for AI” can lose human appeal. Balance is key.
Risk of bigger brands dominating citations since authority, existing backlinks, and trust give them an advantage. Smaller players will need to lean into niche authority, unique content, expertise.
Conclusion
Generative Engine Optimization is not a replacement for SEO — it’s an evolution. As AI-powered search and answer tools become more mainstream, GEO will become increasingly important.

If you can adapt your workflow (frontend design, content structure, performance, credibility) to be friendly both to humans and AI systems, you’ll not only preserve visibility — you’ll expand it into channels many competitors are still ignoring.

References
HubSpot (2024). The Marketer’s Guide to Generative Engine Optimization (GEO).
Mangools (2024). Generative Engine Optimization: The Future of SEO in the Age of AI.
AIOSEO (2024). Generative Engine Optimization (GEO): How to Optimize for AI Search Engines.