Building My Personal Finance Tracker: Backend with Node.js & TypeScript

kartik

updated on

Feb 02, 2025

I’ve always wanted to create a Personal Finance Tracker for myself, one that helps manage expenses, savings, and investments with ease. My goal is to build an app where users can input their total balance and set a monthly budget, then continue to add expenses over time. As they do, the app will help track their finances, provide insights, and keep their goals on track, helping them become more aware of their spending habits.

In this post, I'll share my experience of setting up the backend for this project from scratch. I hope you'll enjoy the journey as I continue posting my learnings, challenges, and experiences along the way.

So after careful consideration, I’ve decided to approach this project by focusing on the backend first. I'm building the backend with TypeScript, Node.js, Express, and MongoDB. In the future, I plan to implement the frontend with Next.js and use NextAuth for authentication. In this post, I’ll walk you through my thought process, the challenges I’ve encountered so far, and the progress I’ve made.

Why Backend First?

While most projects begin with the frontend, I decided to build the backend first for a few reasons:

Data structure and logic are foundational. Before designing how the data is presented, I need a solid structure behind it.
APIs: Having the backend APIs ready will allow me to focus on building a responsive frontend without worrying about data interactions later on.
Scalability: Starting with the backend gives me a head start on designing scalable solutions for database management, user authentication, and data storage.

Tech Stack

Node.js and Express: To build the API and handle HTTP requests efficiently.
MongoDB and MongoDB Atlas: For database management, where I’ll store user financial data (expenses, savings, etc.).
TypeScript: For type safety and better developer experience.

I also plan to use Next.js and NextAuth for the frontend to handle authentication securely, once I’ve laid the foundation with the backend.

Setting Up the Project

I started by setting up the basic project structure for Node.js with TypeScript. Here’s what I did:

Initialized the project using npm init.
Installed necessary packages such as express, mongoose, dotenv, nodemon for auto-reloading during development and morgan for logging HTTP requests -
```
code
loading...
```
Set up TypeScript configuration with tsconfig.json -
```
json
loading...
```

Project Structure

I’ve structured my project as follows:
```
bash
loading...
```

For this post, I’ll be using the Category model as an example to walk you through some of the key concepts and implementations.

index.ts – Main Entry Point
- In index.ts, we connect everything and start the server. This file acts as the entry point for your application. Sample code:
```
ts
loading...
```
app.ts – Initialize Express App and Middleware
- In app.ts, we can initialize the Express app and set up middleware (such as cors, morgan for logging, and mongoose). We can also import and register routes. Sample code:
```
ts
loading...
```
models/category.model.ts – Define the Category Schema
- In the category.model.ts file, I define the schema for a category in MongoDB using Mongoose. This schema dictates the structure of the data stored in the category collection. Sample code:
```
ts
loading...
```
routes/categories.ts – Define Routes for Categories
- In categories.ts, I've defined the actual routes that handles HTTP requests for categories (GET, POST, PATCH, DELETE). Sample code:
```
ts
loading...
```
controllers/categoryController.ts – Handle Logic for Category CRUD Operations
- In categoryController.ts, we define the functions that handle the logic for category-related requests, such as fetching, creating, updating, and deleting categories. Sample code:
```
ts
loading...
```

Database Design

I’m using MongoDB Atlas for database hosting because it offers a managed cloud database with features like automated backups and scalability, which will be valuable as I continue developing the app. Plus, it has a free tier that’s perfect for getting started! :)

The Category model is one of the first pieces of data I’ve designed, allowing users to categorize their finances (e.g., “Food”, “Rent”, “Entertainment”). For simplicity, I’ve used a name and price field for now.

This is just the beginning; I’ll expand on this model as the project evolves.

Challenges I Faced

Database Authentication: I initially encountered some authentication issues when connecting to MongoDB Atlas. After double-checking my connection string and credentials, everything was back on track. Quick tip: Add 0.0.0.0/0 to your network access list under your project to allow access to the DB from any device, anywhere.
Handling TypeScript with Express: Setting up TypeScript to work seamlessly with Express and nodemon was a bit tricky. I had to configure tsx properly and ensure the TypeScript compiler was handling everything as expected.
Data Validation: Currently, I’m implementing basic validation, but I plan to add more comprehensive validation and error handling as I expand the APIs.

What's Next?

Develop APIs for Other Models:
I'll continue expanding the backend by developing APIs for additional models like transactions and budget. I'll keep you updated with it all, their functionality and usage in this product.
Enhance API Functionality:
Further, I plan to enhance the existing API functionality by adding more complex operations, validations, and integrating any necessary business logic to manage finances effectively. I'll get a clearer picture once I start frontend development and view it from a higher-level perspective.
Frontend Development:
Once the backend is fully functional or at least I would be satisfied with the minimum required backend to move further, I'll shift focus to the frontend development using Next.js. The frontend will be responsible for providing a responsive, intuitive user interface where users can track their finances.
User Authentication with NextAuth:
For secure user authentication, I’ll implement NextAuth on the frontend. This will allow users to securely log in, register, and manage their sessions as they interact with their financial data.
Additional Features:
Later on, I’ll introduce more features, such as budgeting, transaction categorization, investment tracking, and financial reports, to give users greater insights into their financial habits and help them manage their finances more effectively.

Conclusion

I’m excited about the progress so far and can’t wait to share more updates as I continue working on this project. The backend setup is coming together nicely, and I’m looking forward to moving on to the frontend (since I absolutely love working on frontend! 😊). Stay tuned for more updates as I dive deeper into building the full application!