This is a submission for the GitHub Finish-Up-A-Thon Challenge
What I Built
"Where did my money go?"
Every expense tracker ever built answers that question. I wanted to build something that answered a harder one:
"Why did my money go there — and what should I do about it?"
FinancialEdApp is an AI-powered personal finance platform that combines expense tracking, budget planning, loan/EMI analysis, and a conversational AI assistant — all working together on your actual financial data.
It didn't start that way though. It started as a half-working prototype I built under pressure, shipped zero of, and left to collect dust in a private folder for months. This challenge gave me the push to finally finish it.
The Comeback Story
Where It Was: An Honest Before
The project started at Economic hackathon i saw somewhere. I had a vision for a smart finance app — not just a tracker, but something that would actually explain your financial behavior.
What I shipped at the deadline was considerably humbler:
| Feature | State at Abandonment |
|---|---|
| Expense tracking UI | ✅ Worked, barely styled |
| Budget planning | ⚠️ UI existed, no logic behind it |
| AI Financial Assistant | ❌ Completely mocked — returned hardcoded strings |
| Loan / EMI Analysis | ❌ Static inputs, zero calculation logic |
| Data persistence | ❌ Everything reset on refresh |
| Tests | ❌ None |
| CI/CD | ❌ "Deploy" meant running npm run build on my laptop |
| Cloud infrastructure | ❌ Never left localhost |
The AI assistant — the entire point of the app — was a facade. When a user asked "Why did my savings drop?", it returned the same canned response regardless of their data. I knew it. I just ran out of time.
Then life happened. The code sat untouched for 7months.
The Turning Point
When I saw this challenge, I opened the repo expecting to feel overwhelmed. That was hard to find the repo and code in machine sitting in some mycode folder.
I made a list of what "actually finished" would mean:
- Real AI assistant connected to the user's own financial data
- Working EMI calculator with full amortization logic
- Budget tracking that actually saves and persists state
- A CI/CD pipeline so deployments aren't a prayer
- Production deployment on Azure Kubernetes Service (AKS) That's what I set out to finish. Here's how it went.
What Changed: The Real After
The AI Assistant — from fake to functional
The biggest gap. The original "AI" was if (query.includes("savings")) return hardcodedString. Embarrassing in retrospect.
The rewrite connected the assistant to the user's actual expense history, budget targets, and loan data. Now when you ask "Why did my savings decrease last month?" — the model gets your real data as context and responds with specific observations: "Your dining expenses increased 34% in March and exceeded your ₹4,000 budget by ₹1,200."
Loan & EMI Calculator — from stub to substance
The EMI form previously accepted inputs and did absolutely nothing with them. I built out the full amortization engine: monthly breakdowns, total interest calculations, and an early repayment simulator so users can see the actual rupee impact of prepaying a loan.
Budget Tracking — actually persistent now
Budgets used to vanish on refresh. The state management overhaul means budgets, categories, and goals persist properly. The budget vs. actual comparison view now shows live overrun indicators instead of static placeholder data.
Infrastructure — from "it works on my machine" to AKS
Containerized with Docker, automated with GitHub Actions, deployed to Azure Kubernetes Service with Azure Container Apps handling scaling. The CI/CD pipeline runs on every push to main — lint, build, test, deploy. No more laptop deploys.
Screenshots
My Experience with GitHub Copilot
Copilot wasn't just a code autocomplete tool on this project. It was the reason I didn't abandon the repo again the moment I reopened it.
Breaking Through the Paralysis
The hardest part of returning to an old project is re-orientation. What does this file do? Why is this state structured this way? I found myself using Copilot Chat as a code archaeologist — pasting in old functions and asking "What was this trying to do?" before I could safely extend it.
The Specific Moments That Mattered
1. The EMI Amortization Engine
I wrote one comment:
// Calculate monthly amortization schedule for a loan
// given principal, annual interest rate, and tenure in months
// Return array of { month, principal, interest, balance }
Copilot generated a complete, correct implementation. I verified the math against known loan calculators, found one edge case in the final-month rounding, asked Copilot to fix it — and it did. What would have taken me 90 minutes of formula-checking took 15.
2. CI/CD Pipeline from Scratch
I had never set up an AKS deployment pipeline before. I described what I wanted in a comment block in the YAML file and Copilot drafted the full GitHub Actions workflow: Docker build → push to Azure Container Registry → rolling deploy to AKS. It wasn't perfect on the first pass — the registry auth step needed fixing — but having a near-complete scaffold to edit was dramatically faster than starting from a blank file.
3. AI Context Injection
The trickiest engineering problem was safely injecting financial context into the AI prompts without exceeding token limits or leaking sensitive data. Copilot suggested a summarization pattern I hadn't considered — pre-processing transactions into statistical summaries (category totals, percentage changes, budget deviation) rather than passing raw transaction arrays. This made the prompts leaner and the AI responses noticeably more useful.
4. The Bug I'd Been Staring At
There was a budget comparison calculation that returned correct totals for some months and wrong ones for others. I'd been looking at it for an hour. I opened Copilot Chat, described the symptom, and it spotted the issue in under a minute: a timezone offset was causing transactions near midnight to be bucketed into the wrong month. I would not have found that quickly on my own.
The Broader Lesson
I used AI tools across the entire development lifecycle on this project — not just for writing code. Planning, architecture review, debugging, documentation, infrastructure, and CI/CD all benefited.
The most valuable insight: AI is most useful when you're specific. Vague prompts get vague code. When I described the exact shape of data I had, the exact output I needed, and the exact constraint I was working within — Copilot delivered something I could actually use.
Tech Stack
| Layer | Technology |
|---|---|
| Frontend | React, Next.js, TypeScript |
| AI | OpenAI API, GitHub Copilot |
| Infrastructure | Docker, Azure Kubernetes Service, Azure Container Apps |
| DevOps | GitHub Actions, CI/CD pipeline |
What's Next
This project is now a real foundation, not a prototype. Planned next:
- Bank account integrations via open banking APIs
- Automatic transaction import and categorization
- Financial forecasting with ML-based trend detection
- Family / shared budgeting mode
- Personalized financial literacy modules based on spending patterns
Final Thought
The app I demo today is not the app that existed when I reopened this repo. The core idea was always solid — the execution just needed time, focus, and honestly, a development partner that never got tired of my questions at 1am.
That's what GitHub Copilot was on this project. Not magic. Just a remarkably patient collaborator.
Top comments (0)