EXP.

NO: 1 PROBLEM STATEMENT

Abstract
Managing personal finances can often feel overwhelming, especially in today’s cashless and
fast-paced world. The Money Management System aims to simplify this process by
providing individuals with a comprehensive tool to track expenses, set budgets, and gain
insights into their spending habits. Designed to promote financial discipline and informed
decision-making, the system encourages users to take control of their finances and work
towards achieving their financial goals.
There is a growing need for such a system as many individuals face challenges in managing
their money effectively. Impulse spending, lack of budgeting skills, and limited awareness of
financial tools often lead to unnecessary expenses and financial stress. Rising living costs and
economic uncertainty have further highlighted the importance of adopting better financial
management practices. The Money Management System addresses these challenges by
offering a simple yet effective solution for organizing and analyzing personal finances.
The system is intended for a wide audience, including young professionals seeking to manage
their income and expenses, students learning the basics of financial independence, families
organizing household budgets, and anyone aiming to track and reduce unnecessary spending.
By catering to different financial situations, the system ensures that users, regardless of their
experience with financial planning, can benefit from its features.
Key features of the system include expense tracking to categorize and monitor spending,
budgeting tools to set and stay within limits, visual insights to understand spending patterns,
and savings goal trackers to help users plan for future needs. Together, these tools provide a
holistic approach to personal finance management, making it easier for individuals to build
better financial habits and achieve long-term stability.
EXP. NO: 2.1 Software Requirements Specification

AIM:
To write a Software Requirements Specification for the mini project.

Procedure:
Steps followed to write an effective SRS document for the Personal Finance Management
System

Personal Finance Management System

1. Introduction
The Personal Finance Management System is a user-oriented application designed to help
individuals manage their income, expenses, and savings. The system will provide a
centralized platform for tracking spending, setting budgets, monitoring financial goals, and
gaining insights through visual reports. This document outlines the requirements for the
development of the system.

2. Scope
The system is intended for individual users who want to maintain better control over their
personal finances. Users will be able to log income and expenses, categorize transactions, set
monthly or yearly budgets, receive alerts on overspending, and view data analytics to
understand their spending behavior. An administrator module will support basic system
monitoring and data management.

3. Functional Requirements
3.1 Customer Features
1. Register/Login: Users can create accounts and securely log in.
2. Add Transactions: Users can input income and expenses with categories, amounts,
and dates.
3. Budget Management: Users can define budgets per category (e.g., food, travel) and
receive alerts when limits are crossed.
4. Expense Analysis: Users can view summaries and graphs that analyze their financial
activity.
5. Set Financial Goals: Users can set savings or investment goals and track their
progress.
3.2 Administrator Features
1. Manage User Data: Admins can view and manage user accounts for system-level
updates or support.
2. Monitor System Activity: Admins can oversee logs, usage statistics, and general
system health.

4. Non-Functional Requirements
1. Performance: The system must ensure smooth and responsive performance under
normal user loads.
2. Security: User financial data should be encrypted and access must be controlled with
secure authentication.
3. Usability: The interface must be clean, intuitive, and user-friendly.
4. Reliability: The system should function consistently and handle errors without
crashing.

5. User Interface Requirements

1. The interface should be clean, simple, and accessible across devices.
2. Key features like transaction entry, reports, and budgets should be easy to access via
the main menu.
3. Visualizations (pie charts, bar graphs) should be used to display financial summaries.

6. Data Requirements
1. All user financial records, budgets, and goals must be stored securely in a database.
2. Transaction data should include amount, category, date, and optional notes.
3. Data must support real-time updates and retrieval for visual reporting.

7. System Requirements
1. The system will be developed as a web application compatible with desktops and
smartphones.
2. It should support modern browsers like Chrome, Firefox, Safari, and Edge.
3. Backend and frontend systems should be lightweight and scalable for personal use.

8. External Interface Requirements

1. Integration with external financial APIs (e.g., for automated transaction imports) may
be included optionally.
2. Email notifications can be used to alert users about budget breaches or savings
milestones.

9. Quality Assurance and Testing Requirements

1. Unit testing and integration testing will be done on core modules such as budget
calculation, data visualization, and transaction storage.
2. User acceptance testing (UAT) will ensure that the system meets usability
expectations.
3. System testing will validate performance and reliability.

10. Documentation Requirements

1. User guide for navigation and feature usage.
2. Technical documentation for developers including system architecture and database
schema.

11. Maintenance and Support Requirements

1. Periodic updates will include bug fixes and minor feature improvements.
2. Support documentation will be provided to assist users with common issues.

12. Constraints and Assumptions

1. Development will be completed within the timeframe allotted for the mini-project.
2. The system assumes individual use and is not intended for large-scale or corporate
financial tracking.
3. Hosting will be on a basic cloud server or local machine for demonstration.

RESULT:
Software Requirements Specification for the Personal Finance Management System is
successfully completed.
EXP. NO: 2.2
USE CASE SPECIFICATIONS
AIM:
To write a use case specification for the mini project.

Procedure:
4. Create a use case model for the mini project
5. Identify the use cases and actors
6. Draw the table with the following details:
● Use case name
● Participating actors
● Flow of events
● Entry condition
● Exit condition
● Quality requirements
7. Finally, end the use case

Use Case Name: Add Expense

Participating Actors:
● User (logs in to PFMS)
● System (records and stores expense)
Flow of Events:
8. The user logs in to the PFMS dashboard.
9. User navigates to the “Add Expense” section.
10. User enters details such as category, amount, date, and description.
11. User submits the expense entry.
12. The system validates and saves the data.
13. Confirmation is shown and the dashboard updates.
Entry Condition:
The user must be logged in to the PFMS.
Exit Condition:
Expense is successfully added and stored in the database.
Quality Requirements:
14. Quick data entry with no lag.
15. Accurate validation of amount and date fields.
16. Immediate reflection of the new expense in reports and summaries.

Use Case Name: Set Budget

Participating Actors:
● User
● System
Flow of Events:
17. User logs in and navigates to “Budget” section.
18. User selects categories and enters budget limits.
19. User submits the budget.
20. System stores the data and begins monitoring expenses against the budget.
Entry Condition:
User is authenticated and has expense categories added.
Exit Condition:
Budget is stored and alerts are set for thresholds.
Quality Requirements:
21. Accurate comparison between expense and budget.
22. Timely alerts when budget is exceeded.

RESULT:
Use case specification for the mini project Personal Finance Management System is
successfully completed.
EXP. NO: 3
PROJECT PLANNING WITH PERT DIAGRAM
AIM:
To draw a PERT diagram for the mini project Personal Finance Management System
(PFMS).

Procedure:
23. Identify key tasks involved in developing PFMS.
24. Define dependencies between tasks.
25. Connect tasks logically to form the PERT diagram.
26. Estimate the time frame using Optimistic (O), Most Likely (M), and Pessimistic (P)
durations.
27. Determine the critical path and calculate earliest start and finish times.
28. Monitor task progress based on the plan.

SAMPLE INPUT:
29. List of Tasks
30. Task Durations
31. Dependencies
32. Optimistic, Most Likely and Pessimistic Durations
33. Critical Path:
34. Start and Finish Times

SAMPLE OUTPUT:

RESULT :
The Pert chart for the mini project is successfully completed
EXP. NO: 4.1

Use Case diagrams

AIM : To draw a use case diagram for the mini project

Procedure :
1. Identify the actors of the system.
2. For each category of users, identify all roles played by the users relevant to the system.
3. Identify what are the users required for the system to be performed to achieve these goals.
4. Create use cases for every goal.
5. Structure the use cases.
6. Prioritize, review, estimate and validate the users.
7. Add the relationship wherever needed
SAMPLE INPUT:
Actors, Use Cases, Relationships, System Boundaries, Use Case Descriptions, Actors' Roles
and
Responsibilities have to be used as input to draw the diagram
SAMPLE OUTPUT:
RESULT : Thus the use case for the mini project is successfully completed.
EXP. NO : 4.2

Interaction diagrams

AIM : To draw a interaction diagram for the mini project

Procedure :
1. Define who will interact with the interaction
2. Draw the first message to a sub-system
3. Draw the message to other sub-system
4. Draw return message to actor
5. send/respond to anonymous actors

SAMPLE INPUT:
Identify Objects or Actors. Define Roles, Identify Messages, Sequence of Messages and
Lifelines to draw the
diagram.
SAMPLE OUTPUT:
RESULT : Thus interaction diagram for the mini project is successfully completed.
EXP. NO: 4.3

State Chart diagrams and activity diagrams

AIM : To draw State Chart diagrams and activity diagrams for the mini project.
Procedure :
State Chart diagrams:
1. Identify the initial state and the final terminating states.
2. Identify the possible states in which the object can exist (boundary values corresponding to
different attributes guide us in identifying different states).
3. Label the events which trigger these transitions.
Activity diagrams:
1. Figure out the action steps from the use case. Here you need to identify the various
activities
and actions your business process or system is made up of.
2. Identify the actors who are involved. ...
3. Find a flow among the activities. ...
4. Add swimlanes.
SAMPLE INPUT:
State Chart diagrams: Identify Objects, States, Transitions, Initial and Final States, State
Actions, Guard
Conditions to draw the State Chart diagram.
Activity diagram: Identify Activities, Actions, Control Flows, Decisions and Branches, Merge
Points, Initial
and Final Nodes and Swimlanes
SAMPLE OUTPUT:
a) State Chart diagrams

b) Activity diagram

RESULT : State Chart diagrams and activity diagrams for the mini project are successfully
completed.
EXP. NO: 4.4

Class Diagrams

AIM : To draw class diagrams for the mini project.

Procedure :
1. Identify the class names.
2. Identify the primary objects of the system.
3. Distinguish the classes
4. Determine how each of the classes or objects are related to one another.
5. Create the Structure.
SAMPLE INPUT:
Identify Classes, Attributes, Methods, Relationships such as Association End Multiplicity,
Inheritance and
Generalization, Aggregation and Composition to draw the class diagram.
SAMPLE OUTPUT:

RESULT : Thus the class diagrams for the mini project are successfully completed.
EXP. NO: 4.5

Package Diagrams

AIM : To draw package diagrams for the mini project.

Procedure :
1. Select Diagram > New from the application toolbar.
2. In the New Diagram window, select Package Diagram.
3. Click Next.
4. Enter the diagram name and description.
5. The Location field enables you to select a model to store the diagram.
6. Click OK.
7. Draw the package diagram with different notations.
8. Specify the links for different packages.
SAMPLE INPUT:
Identify Packages, Package Contents, Relationships Between Packages, Package Visibility,
Package
Stereotypes and Package Dependencies to draw the package diagram.
SAMPLE OUTPUT:

RESULT : Thus the package diagrams for the mini project is successfully completed.
EXP. NO: 4.6

Component and deployment diagrams

AIM : To draw Component and deployment diagrams for the mini project.
Procedure :
Component diagram
1. Decide on the purpose of the diagram.
2. Add components to the diagram, grouping them within other components if appropriate.
3. Add other elements to the diagram, such as classes, objects and interface.
4. Add the dependencies between the elements of the diagram.
deployment diagrams
1. Identify the purpose of your deployment diagram.
2. Figure out the relationships between the nodes and devices.
3. Identify what other elements like components, active objects you need to add to complete
the diagram.
SAMPLE INPUT:
Component diagram: Identify Components, Interfaces, Dependencies Between Components,
Ports and
Adapters, Deployment Considerations and Component Stereotypes to draw the Component
diagram.
Deployment diagrams: Identify Nodes, Artifacts, Deployment Relationships, Network
Connections, Execution
Environments and Node Stereotypes to draw the Deployment diagram.
SAMPLE OUTPUT:
Component diagram
Deployment diagrams
RESULT : Thus the Component and deployment diagrams for the mini project are
successfully completed.
EXP. NO. : 5

MAPPING DESIGN TO CODE

AIM : To generate code from class diagram for the mini project

Procedure :
35. Select Tools > Code > Instant Generator from the toolbar.
36. In the Instant Generator window, select Python/java as the Language.
37. Fill in the Output Path, which is the directory where you want the code to generate to.
38. Select the classes to generate code
39. Give ok and check the codes in the given directory.

CODE GENERATION:

Dashboard.java

import java.util.Date;

public class User {

private int userID;

private String name;

private String email;

 private String password;

public User() {

public boolean login() {

// TODO: implement login logic

return true;

public void logout() {

// TODO: implement logout logic

public class Expense {

private int expenseID;

private int userID;

private float amount;

private String category;

private Date date;

 public Expense() {

public void addExpense() {

// TODO: implement add expense logic

public void updateExpense() {

// TODO: implement update expense logic

public class Income {

private int incomeID;

private int userID;

private float amount;

private String source;

private Date date;

public Income() {

}
 public void addIncome() {

// TODO: implement add income logic

public void updateIncome() {

// TODO: implement update income logic

public class Budget {

private int budgetID;

private int userID;

private float amount;

private String month;

public Budget() {

public void setBudget() {

// TODO: implement set budget logic

}
 public void updateBudget() {

// TODO: implement update budget logic

public class Category {

private int categoryID;

private String name;

private String type; // "Expense" or "Income"

public Category() {

public void addCategory() {

// TODO: implement add category logic

public void updateCategory() {

// TODO: implement update category logic

}
public class Summary {

public Summary() {

public String generateMonthlySummary(int userID) {

// TODO: implement monthly summary generation

return "";

public String generateCategoryWiseReport(int userID) {

// TODO: implement category-wise report generation

return "";

}RESULT : Thus the code from class diagram for the mini project is successfully generated.