Design a Personalized Financial Goal Tracker Using Object-Oriented Design

Problem Definition:

The Personalized Financial Goal Tracker is an app that allows users to set, track, and analyze their financial goals. It provides insights into the progress of various goals (e.g., saving for a house, retirement, vacation, etc.) and offers personalized recommendations for improving financial habits to achieve those goals.

Key Features:

1. Goal Creation: Users can create different financial goals, specifying the amount to be saved, the target date, and any monthly contribution they wish to make.

2. Goal Tracking: The system will track the progress of each goal by comparing the current savings against the target.

3. Notifications & Alerts: Users will receive reminders or alerts based on their goal deadlines or when they are falling behind.

4. Financial Insights: The system will provide suggestions for better financial planning (e.g., increasing contributions, cutting unnecessary expenses).

5. Historical Data: Users can track their financial progress over time, viewing trends in savings and expenses.

Object-Oriented Design (OOD) Principles:

We’ll follow Object-Oriented Design (OOD) principles to ensure scalability, reusability, and maintainability of the application. Here’s the breakdown of how the app will be structured using classes and objects.

1. Class Diagram Overview:

The following classes will be created to implement the tracker:

1. User

   • Represents the individual user who creates financial goals.

2. Goal

   • Represents a financial goal that a user is working toward.

3. Transaction

   • Represents a deposit, withdrawal, or transfer related to the user’s financial goals.

4. FinancialAdvisor

   • Provides suggestions to improve the user’s financial habits.

5. GoalTracker

   • Responsible for tracking the user’s progress on each goal.

2. Classes and Their Relationships:

1. User Class

Attributes:

• userID: A unique identifier for each user.

• name: The name of the user.

• email: The user’s contact email.

• goals: A list of all financial goals the user is working on.

• transactions: A list of all financial transactions made by the user.

Methods:

• createGoal(amount, targetDate): Allows the user to create a new financial goal.

• viewGoals(): Returns a list of all the user’s goals.

• addTransaction(transaction): Adds a new transaction (deposit or withdrawal).

• getTotalSavings(): Returns the total amount saved across all goals.

2. Goal Class

Attributes:

• goalID: A unique identifier for the goal.

• goalName: A short name for the goal (e.g., “Buy a Car”).

• targetAmount: The target savings for the goal.

• currentAmount: The amount the user has saved so far.

• targetDate: The date the goal is expected to be completed.

• contributions: A list of transactions contributing to this goal.

Methods:

• addContribution(amount): Adds a new contribution to the goal.

• getProgress(): Returns the current progress percentage toward the goal.

• getRemainingAmount(): Returns the remaining amount to achieve the goal.

• isGoalMet(): Checks if the goal has been reached or exceeded.

3. Transaction Class

Attributes:

• transactionID: A unique identifier for the transaction.

• transactionType: The type of transaction (e.g., “deposit”, “withdrawal”).

• amount: The amount of the transaction.

• date: The date of the transaction.

• goal: The associated goal for this transaction.

Methods:

• getTransactionDetails(): Returns detailed information about the transaction.

4. FinancialAdvisor Class

Attributes:

• user: The user to whom the advice is being given.

Methods:

• provideSuggestions(): Offers financial advice based on the user’s saving habits (e.g., “Consider saving $100 more per month” or “Reduce discretionary spending”).

• analyzeProgress(goal): Analyzes the user’s progress toward a specific goal and provides suggestions for improvement.

5. GoalTracker Class

Attributes:

• goals: A list of all goals to track.

Methods:

• trackProgress(): Tracks the progress of all the user’s goals and provides feedback.

• sendAlerts(): Sends notifications if a user is falling behind on any goal.

3. Sample Code Implementation (in Python):

python
CopyEdit
class User:
    def __init__(self, userID, name, email):
        self.userID = userID
        self.name = name
        self.email = email
        self.goals = []
        self.transactions = []

    def createGoal(self, goalName, targetAmount, targetDate):
        goal = Goal(goalName, targetAmount, targetDate)
        self.goals.append(goal)
        return goal

    def addTransaction(self, transaction):
        self.transactions.append(transaction)

    def viewGoals(self):
        return self.goals

    def getTotalSavings(self):
        total = sum(goal.currentAmount for goal in self.goals)
        return total


class Goal:
    def __init__(self, goalName, targetAmount, targetDate):
        self.goalID = id(self)
        self.goalName = goalName
        self.targetAmount = targetAmount
        self.currentAmount = 0
        self.targetDate = targetDate
        self.contributions = []

    def addContribution(self, amount):
        self.currentAmount += amount
        self.contributions.append(amount)

    def getProgress(self):
        return (self.currentAmount / self.targetAmount) * 100

    def getRemainingAmount(self):
        return self.targetAmount - self.currentAmount

    def isGoalMet(self):
        return self.currentAmount >= self.targetAmount


class Transaction:
    def __init__(self, transactionID, transactionType, amount, goal=None):
        self.transactionID = transactionID
        self.transactionType = transactionType
        self.amount = amount
        self.date = "2025-07-17"  # Example date
        self.goal = goal

    def getTransactionDetails(self):
        return f"Transaction ID: {self.transactionID}, Type: {self.transactionType}, Amount: {self.amount}"


class FinancialAdvisor:
    def __init__(self, user):
        self.user = user

    def provideSuggestions(self):
        totalSavings = self.user.getTotalSavings()
        if totalSavings < 1000:
            return "Consider saving more, you’re under your target savings."
        else:
            return "Your savings are on track."

    def analyzeProgress(self, goal):
        progress = goal.getProgress()
        if progress < 50:
            return f"You're halfway there! Consider increasing your monthly savings to reach your target."
        else:
            return f"You're doing great! Keep it up."


class GoalTracker:
    def __init__(self):
        self.goals = []

    def trackProgress(self):
        for goal in self.goals:
            print(f"Goal: {goal.goalName}, Progress: {goal.getProgress()}%")

    def sendAlerts(self):
        for goal in self.goals:
            if goal.getProgress() < 50:
                print(f"Alert! You're behind on {goal.goalName}. Consider increasing your savings!")

Summary of Key Design Elements:

1. Classes and Objects: The User class aggregates the user’s goals and transactions. The Goal class encapsulates the details of each goal, while the Transaction class represents individual transactions made toward those goals.

2. Encapsulation: Each class hides its internal workings, providing well-defined interfaces for interacting with its data.

3. Modularity: Each component (user, goal, transaction) is self-contained, making the system flexible for future additions (like new types of financial goals).

4. Abstraction: The system allows users to interact with high-level features (goal creation, tracking, etc.) without needing to understand the underlying logic.

Future Enhancements:

• User Authentication: Implement login and session management for user authentication.

• Integration with Banks: Integrate with banks for automatic tracking of deposits.

• Mobile App: Build a mobile version for on-the-go tracking.

This structure ensures the app is scalable, easy to maintain, and offers a good user experience.