Fischer Jordan Backend Assignment for Financial Analysis
Finance Manager is a full-stack web application designed to help users manage their personal finances efficiently. The system allows users to track income and expenses, manage budgets, categorize transactions, upload receipts, import bank statements, and visualize financial data through analytics dashboards.
The application is built with a modular architecture that ensures scalability, maintainability, and secure data handling.
- User Authentication (Register/Login)
- Income & Expense Management
- Category-based Transaction Organization
- Budget Tracking & Limit Monitoring
- Multi-Currency Transaction Support
- Dashboard Analytics & Reports
- Receipt Upload & Management
- Bank Statement Import
- Notification System
- Secure User Data Isolation
Frontend (React)
│
│ REST API Calls
▼
Backend (Node.js + Express)
│
├── Routes
├── Controllers
├── Services
├── Middleware
└── Utilities
│
▼
Database (SQL)
- React-based user interface
- Authentication context for session management
- Protected routes for authenticated users
- Dashboard and transaction management UI
- Node.js with Express
- RESTful API architecture
- JWT-based authentication
- Modular controller-service structure
Main entities:
- Users
- Categories
- Transactions
- Budgets
- Notifications
- Receipts
- User registers or logs in.
- Credentials are validated by the backend.
- JWT token is generated upon successful authentication.
- Token is stored on the frontend.
- Protected APIs require token verification via middleware.
- Invalid credentials
- Missing or expired tokens
- Unauthorized API access
- Duplicate user registration
- Each user has isolated financial data.
- All database queries are filtered using
user_id. - Users can update profile details securely.
- Cross-user data access prevention
- Invalid profile updates blocked
Users can create and manage categories for organizing transactions.
- User creates/updates/deletes a category.
- Request is validated.
- Category is stored with user ownership.
- Duplicate categories prevention
- Safe handling of categories linked with transactions
Transactions represent income or expenses and form the core functionality.
User Input → API Request → Validation → Database Insert
↓
Budget Update
↓
Notification Trigger
- Add transaction
- Edit transaction
- Delete transaction
- Fetch transaction history
- Multi-currency transactions
- Currency normalization
- Monthly summary recalculation
- Budget usage update
- Invalid amount or date
- Currency inconsistencies
- Editing transactions updates summaries correctly
- Deleting transactions recalculates budgets
- Negative or zero values restricted
Users can set budgets per category and track spending.
- User sets budget for a period.
- Transactions update budget usage.
- Notifications generated when limits are exceeded.
- Budget overflow detection
- Duplicate budgets prevention
- Budget recalculation after transaction updates
The dashboard provides financial insights and summaries.
- Monthly spending
- Income vs expense comparison
- Category-wise distribution
- Dashboard requests aggregated data.
- Backend performs aggregation queries.
- Data returned in chart-ready format.
- Empty dataset handling
- First-time user support
- Currency-safe aggregation
Users can upload receipts and link them to transactions.
- Receipt uploaded by user.
- File stored via storage service.
- Metadata saved in database.
- Linked to transaction.
- Invalid file type rejection
- Missing transaction handling
- Storage failure handling
Users can import transactions using bank statements.
- Bank file uploaded.
- Parser extracts transaction data.
- Transactions inserted in batch.
- Dashboard summaries updated.
- Duplicate transaction detection
- Invalid file formats
- Partial import error handling
Notifications are generated when:
- Budget limits are exceeded
- Important financial updates occur
Transaction/Budget Update
↓
Notification Service
↓
Stored in Database
The system ensures:
- JWT-based authentication
- Protected API routes
- User-specific data isolation
- Backend validation before database operations
- Prevention of orphan records
- Modular backend architecture
- Service layer for reusable business logic
- Utility modules for financial calculations
- Aggregation-based reporting
- Scalable database structure