Building a Personal Finances CRM with Firebase and AI

Introduction

It was around 2–3 AM. I couldn't sleep, so I decided to put Firebase — and AI — to the test. After all, it’s a tool every developer should play with at least for fun. 

My goal sounded simple on paper but ambitious in practice: create a Personal Finances CRM application, powered by Firebase services, with a working MVP ready in just a few hours — or at least before I passed out at my desk.

Fueled by curiosity (and whiskey, I’ll admit it), I envisioned using AI to accelerate the setup, structure the app quickly, and maybe even get something live. 

Spoiler alert: It didn’t fully work as planned — but the experience gave me deeper insights that turned out to be more valuable than simply hitting a deadline.

This is the story of that late-night sprint: what went right, what went wrong, and what I learned along the way.

The Project Vision

The vision was clear: a Personal Finances CRM that individual users could trust to log their incomes, expenses, categorize transactions (Food, Bills, Entertainment), set monthly budgets, and get alerts when approaching budget limits.

My plan was to create both the UI and API in a monorepo, using the same application structure. 

I deliberately didn’t specify the tech stack in my initial prompt — I wanted to see how Gemini would process the request and infer the technology choices.

The core features I aimed for in the MVP were:

• A home dashboard with a quick resume of expenses
• The ability to add new expenses and control finances
• A spending trends view
• A user settings page

Here’s the original prompt I used:

Build a Personal Finances CRM application using Firebase. The app should allow individual users to securely create an account, log their incomes and expenses, categorize transactions (e.g., Food, Bills, Entertainment), set monthly budgets per category, and receive alerts when close to budget limits. Each user should have a dashboard summarizing their financial health: total savings, spending trends, budget adherence, and goals progress. The app must support real-time data sync, offline persistence, and push notifications for important events (e.g., overspending alerts). Prioritize privacy and data security. Focus on building a Minimum Viable Product (MVP) first, with user registration, transaction logging, and dashboard reporting as core features.

Ambitious? Definitely. 

But that’s how you grow.

Reality Check

Once I jumped into the build, things got interesting — fast.

The AI helped me scaffold a Next.js frontend... but only the _UI_ part, and very basic at that. 

Initially, Firebase generated just a giant title with the project name and four buttons. 

I then had to clarify my instructions: 

• Instead of big buttons, I wanted a proper layout — a header, a sidebar with navigation, and dynamic content areas.

From there, I spent significant time coding directly in Firebase, issuing more precise instructions to Gemini, and gradually shifting my approach toward one-task-at-a-time.

As the project grew, I hit familiar bumps:

• Web app crashes due to missing libraries
• Gemini introducing typos or outdated imports
• Having to manually debug, fix typos, and explain solutions back to Gemini

Beyond that, I had to step in heavily:

• Reviewing and refactoring messy generated code
• Manually splitting components using Atomic Design principles (even though I asked for it upfront)
• Setting up authentication flows, Firestore models, and deployment scripts myself

In other words: 

AI could _start_ the conversation — but it couldn't finish it.

Four hours flew by. 

By the end of the session, I had a frontend skeleton — but no real backend logic, no solid database schema, and certainly no production-ready app.

Key Learnings

After catching up on sleep, here’s what stood out from this experience:

1. Specificity is Non-Negotiable

Telling an AI "build a CRM" is like telling a junior dev "build an app" — you’ll get _something_, but not necessarily what you envisioned. 

Precise, step-by-step tasks, clear expected outputs, and tight feedback loops are absolutely essential.

2. You Can’t Shortcut Project Complexity

Even with Firebase — which greatly speeds up backend development — 

things like authentication, data validation, database security, and deployment pipelines still require real technical planning.

3. AI Context Memory is Finite

As the project grew, Gemini began "forgetting" architecture decisions due to token limitations. 

In complex projects, you have to remind the AI about naming conventions, app structure, and business logic frequently.

What Worked Well

Not everything was a struggle — some wins made the night worthwhile:

• The AI understood the overall project structure better than expected
• Boilerplate setup (library installs, Firebase initialization, routing) was faster than doing it manually
• It provided a decent starting point for UI prototyping

With well-defined atomic tasks, the AI proved to be a solid co-pilot — but not the captain.

What I'd Do Differently Next Time

If I were to do this again (which I definitely will), I would:

• Break down the project into small atomic tasks: ("Create a signup page," "Setup Firestore schema for transactions," "Implement transaction logging form," etc.)

• Stay in control of architectural decisions: Be very clear on things like folder structure, design patterns, and database rules.

• Set realistic time expectations: Production-grade apps can’t — and shouldn’t — be rushed into existence overnight.

• Use AI strategically: Let AI accelerate setup, but keep core logic, QA, and architecture in human hands.

 What I Didn't Like

One big friction point: the cost per token.

For this tiny MVP attempt, I ended up spending around $10–$20 USD. 

On the free version, I could barely create 5 files with 5 prompt instructions before running into token limits — and a lot of those tokens were "wasted" because Gemini doesn’t process instructions as efficiently as, say, ChatGPT does.

Now that I’m on a Tier 1 plan, I realize that building a robust application would scale that cost exponentially. 

At some point, the benefit vs cost ratio becomes questionable — and that’s a serious conversation for any real-world project.

Final Thoughts

This late-night Firebase sprint reinforced an important lesson:

Real building still matters.

AI can (and should) make developers faster — but it’s no replacement for clear thinking, smart engineering, and hands-on craftsmanship. 

Especially in full-stack apps like a Personal Finances CRM, there’s no silver bullet — just better tools, better workflows, and better habits.

Next, I’m planning to migrate tool instructions like Firebase setup into Avante.nvim and run Ollama models locally on my homelab — moving more control into my own hands.

Some things, like a beautifully crafted MVP, are absolutely worth staying up past 3AM for.