RECURRENT EXPENSE TRACKER

A Project Report

Submitted by:

AJAY SINGH (21EBKCS008)

KRISHAN SINGH SHEKHAWAT

(21EBKCS056)
In partial fulfillment of the requirements of the degree

of

BACHELOR OF TECHNOLOGY
IN

COMPUTER SCIENCE AND ENGINEERING

B.K. BIRLA INSTITUTE OF ENGINEERING &TECHNOLOGY

PILANI, RAJASTHAN ( INDIA) - 333031

(AFFILIATED TO BIKANER TECHNICAL UNIVERSITY, BIKANER, RAJASTHAN (INDIA))

 DECLARATION

I hereby declare that the project entitled “Recurrent Expense Tracker”

submitted for the B. Tech(CSE) degree is my original work and the project has
not formed the basis for the award of any other degree or any other similar
title.

Place: Pilani Signature of the Student

Date: 10 MAY 2025
 CERTIFICATE

This is to certify that the project titled “Recurrent Expense Tracker using
Kotlin Multiplatform” is the bona fide work carried out by AJAY SINGH
(21EBKCS008) & KRISHAN SINGH SHEKHAWAT (21EBKCS056)
students of B Tech (CSE) of B.K.Birla Institute of Engineering &
Technology, Pilani affiliated to Bikaner Technical University, Bikaner,
Rajasthan (India) during the academic year 2024-2025, in partial fulfillment of
the requirements for the award of the degree of Bachelor of Technology
(Computer Science and Engineering and that the project has not formed the
basis for the award previously of any other degree, or any other similar title.

Place: Pilani Signature of the Guide

Date: 10 MAY 2025 Mr.Sanjeev Sultania
 ACKNOWLEDGEMENT

It gives us immense pleasure to express our deepest sense of gratitude and

sincere thanks to our guide, Mr.Sanjeev Sultania, Associate Professor &
Head, Department of Computer Science Engineering, BKBIET Pilani, for his
valuable guidance, encouragement, and help in completing this work. We
would like to express our sincere thanks to Mr.Sanjeev Sultania, Associate
Professor & Head of Computer Science Engineering, BKBIET Pilani, for
giving us this opportunity to do this work. We would also like to thank Dr.
Anil Kumar Sharma, Principal (Admin.), BKBIET Pilani, for your
wholehearted support.

We are also grateful to our teacher, Mr. Himanshu Verma, for their constant
support and guidance. Finally, we would like to express our sincere thanks to
all our friends and others who helped us directly and indirectly in completing
this work.

Thank you,

AJAY SINGH (21EBKCS008)

KRISHAN SINGH SHEKHAWAT
(21EBKCS056)
 ABSTRACT

In an increasingly digital economy, managing personal finances effectively is

essential for individuals and households alike. Recurring expenses—such as
subscriptions, utility bills, loan payments, and rent—constitute a significant
portion of monthly expenditures and can often go unnoticed, leading to budget
overruns and financial stress.

This project explores and evaluates the open-source Recurring Expense

Tracker, a cross-platform application designed to help users monitor and
manage recurring financial commitments efficiently. Developed with Flutter
and Firebase, the application offers features such as automated expense
tracking, categorized listings, notification reminders, and synchronization
across devices.

This report provides an in-depth analysis of the application's architecture,

implementation, and usability, while comparing it to existing solutions in the
domain. Through an academic lens, the study highlights both the strengths and
limitations of the tool and suggests areas for future enhancement, emphasizing
its relevance in promoting financial awareness and discipline among users
 TABLE OF CONTENTS

Chapter no. Page no

Chapter 1: Introduction 1

1.1 Problem Definition 1

1.2 Project Overview/Specifications & Elaborations 1

Chapter 2: Need for Recurring Expense Tracking and Existing 2

Solutions

2.1 History/Previous Work/Existing System 2

2.2 Proposed System/Solution 3

2.3 Feasibility Study 3

2.4 Related Work 3

Chapter 3: System Analysis & Design 4

3.1 Architectural Overview 5

3.2 Data Mode 5

3.3 User Interface Design 5

3.4 Technology Stack 6

Chapter 5 Implementation 8

5.1 Development Environment. 8

5.2 Core Modules 9

5.3 Recurring Expense Module 10

5.4 Data Storage and Synchronization 10

Chapter 6: Testing and Evaluation 13

6.1 Testing Strategy 13

6.2 Functional Testing 14

6.3 Usability Testing 15

Chapter 7: Results and Discussion 16

7.1 Finding 17

7.2 Analysis 18

Chapter 8: Future Work 20

Chapter 9: Conclusion 24

Chapter:10 References 26

References 44

Appendices 46
Chapter 1: Introduction

1.1 Problem Definition

Overview:
Recurring expense tracking is an important aspect of personal financial management.
Many people incur regular costs, such as rent, insurance premiums, subscription
services (Netflix, music streaming, etc.), that recur on a fixed schedule. Monitoring
these fixed outflows is crucial for budgeting and avoiding missed payments. As noted
by financial experts, “Tracking your expenses regularly can give you an accurate
picture of where your money is going”. In particular, identifying fixed expenses (like
rent and insurance) vs variable expenses helps users allocate funds more effectively.
Without appropriate tools, recurring charges can accumulate unexpectedly (e.g.,
forgotten subscriptions), potentially causing financial stress. Tools that automate or
simplify tracking these recurring costs can therefore improve financial awareness and
control.

Personal finance apps and budgeting tools are widely used to manage spending, and
many now highlight recurring payments. For example, budgeting strategies like the
50/30/20 rule categorize expenses (needs, wants, savings) and explicitly include
recurring payments such as utilities and subscriptions. Mobile apps and services
(such as Rocket Money, Truebill, Mint, etc.) offer features to identify and manage
subscriptions and recurring bills. A subscription tracker app, for instance, can “keep
tabs on recurring monthly charges” by analyzing the payment source. These
solutions often aim to reduce waste (unused subscriptions) and ensure bills are not
overlooked.

Despite many general budgeting tools, there is ongoing demand for simple,
privacy-respecting apps focusing specifically on recurring expenses. The Recurring
Expense Tracker project by Dennis Bauer addresses this need as a lightweight,
cross-platform solution. The app’s description highlights its focus: “A Material You
recurring expense tracker, allowing you to keep track of your monthly spending…
[for] recurring expenses like rent, insurance, subscriptions, etc.”. The user interface
is based on Android’s modern Material You design. Notably, it is a Kotlin
Multiplatform application, sharing core logic across Android, iOS, and desktop
platforms..

This report presents an in-depth analysis of the Recurring Expense Tracker project.
It covers the motivation and related tools, the application architecture and codebase,
user experience and setup, illustrative visuals (screenshots), and a critical discussion
of strengths and limitations.
Wherever possible, factual claims are supported by citations to project
documentation and relevant sources.. The report is structured with clear academic
headings and concise paragraphs to facilitate comprehension.
2. Need for Recurring Expense Tracking and Existing Solutions

Households and individuals often juggle multiple recurring payments. Managing

these manually (e.g., using spreadsheets or memory) is error-prone. Automated
tracking tools help users avoid late fees and budget accurately. Financial advisors
emphasize that regular expense tracking “gives you an accurate picture” of spending
patterns. In practice, fixed expenses (like rent or loans) are predictable, whereas
variable expenses fluctuate. By identifying fixed (recurring) costs, users can ensure
that these essential bills are always covered in their budget.

Numerous software solutions address expense management:

●​ General budgeting apps (e.g., Mint, YNAB) cover all spending

categories and often alert users about bills. Some provide calendar
views of upcoming payments.
●​ Subscription managers (e.g., Rocket Money, Bobby) focus on service
subscriptions, often by syncing with financial accounts or manual entry.
These help cancel unwanted subscriptions and remind users of due dates.
●​ Open-source trackers (e.g., Money Manager Ex, Akaunting) offer
personal finance tracking with varying degrees of automation.

Compared to these, Recurring Expense Tracker is specialized. It only tracks

user-entered recurring payments rather than importing bank data, which simplifies
design and improves privacy. The project’s tagline emphasizes simplicity: it is a
“simple app with the basic functionality” for recurring expenses.. In contrast,
comprehensive solutions like Mint integrate many accounts and categories (and
may require data sharing). By focusing on recurring items, this app avoids
unnecessary complexity for users who primarily want to monitor fixed monthly
charges.
Despite the variety of apps, gaps remain in the market for fully open-source,
cross-platform solutions. Many popular subscription trackers are proprietary and
require personal data access. Recurring Expense Tracker fills a niche by being
free, open-source (GPL-3.0 license), and privacy-friendly. According to the
Google Play listing, the developer claims “No data shared with third parties” and
“No data collected” by the app., highlighting its privacy advantage. The F-Droid
repository also underscores its focus: “as the name suggests, this app focuses on
recurring expenses like rent, insurance, subscriptions, etc.”. In summary, the need
for simple recurring-expense tools is clear, and this project offers a distinct
solution among existing offerings.
●​ Expense Tracker Application -A robust and user-friendly Android
software called Expense Tracker enables users to keep a digital journal
of their daily expenditures. Users may better comprehend their
spending due to the feature's category-wise distribution, which makes
it simpler for them to stick to their budget. For a more thorough
investigation of spending patterns, the application provides monthly
reports with a graphical representation of expenses and categorizes
them. Moreover, Expense Tracker offers an expense history so
customers may analyse previous expenses at any time. Overall, using
this simple application will help you keep track of your spending,
manage your money effectively, and make wise financial decisions.[1]
eExpense: A Smart Approach to Track Everyday Expense – An
innovative Android app called eExpense simplifies the process of
keeping track of spending. Users can scan their bills or receipts instead
of utilising traditional methods like pen and paper, and the application
will automatically extract the data needed for processing. By recording
SMS messages from the user's savings accounts, eExpense also keeps
tabs on their income. The tool gives customers a detailed picture of
their financial situation on a monthly and annual basis by accounting
for both income and expenses. Overall, eExpense is an intelligent and
automated cost monitoring tool that makes the process simple and
empowers users to make wise financial decisions

●​ l Costs: Detecting, investigating, and resolving fraud cases require

considerable resources. Financial institutions invest heavily in fraud
detection systems and security measures.

●​ Expense Tracker –A helpful Android software that enables users to

keep a digital log of their daily costs is called "Expense Tracker." They
can keep track of their earnings and expenses, and it alerts them when
they go over their daily spending cap. The programme allows users to
save any extra cash and generates reports at the end of each month to
aid in effective money management. The money can then be put
towards celebratory events like holidays, birthdays, or anniversaries.
In conclusion, the Expense Tracker is a useful tool for encouraging
good money management and saving practices.[3] An Android-based
mobile Application for Tracking Daily Expenses – An Android-based
smartphone app that improves financial discipline by tracking and
controlling personal expenses was created as part of the study.
Diagrams were used to create the app, which was then developed using
Java and MySQL. The application passed tests for functioning,
upholding data integrity and consistency, and rejecting improper
inputs. The software offers a portable, safe, and simple way to improve
financial stability and foster economic growth.[4] Expense Manager:
An Expense Tracking Application–Users can effectively manage
expenses.
3. Project Overview

Recurring Expense Tracker is an open-source application that allows users to

record, view, and receive reminders for their recurring financial obligations. It was
developed by Dennis Bauer and published under a GPL-3.0 license.. The project is
hosted on GitHub, with extensive documentation and issues/support channels. Key
aspects gleaned from the project description include:

●​ Purpose: Track recurring monthly/yearly expenses (rent, insurances,

subscriptions) in one place. Provide summaries (monthly, yearly totals)
and upcoming payment alerts.
●​ Platforms: Android (official release via Google Play and F-Droid),
iOS (compilable locally), and desktop (Windows/Linux/macOS via
Kotlin Multiplatform/Compose).
●​ Technology: Built with Kotlin Multiplatform to share code across targets,
and Compose Multiplatform (Material 3) for UI. Dependency injection
uses Koin (multiplatform DI). Data persistence uses Room (SQLite) with
Kotlin Coroutines and Flow for reactive queries. Android home-screen
widgets are implemented using Jetpack Glance. These core features are
explicitly listed in the project’s README..

The app is structured in several modules: an app module for Android, an iOS app
for iOS, and common/shared modules containing business logic. According to
GitHub stats, the codebase is predominantly Kotlin (99.8%), with only a tiny
Swift component (0.2%). – likely for iOS-specific UI setup. The project has
active development, with 39 releases (latest v0.17.0 on May 4, 2025) and 967
commits. The F-Droid repository indicates recent feature additions like support
for 170+ currencies (added in May 2025), showing ongoing enhancements.

The feature set includes: creating/editing recurring expenses (name, amount,

currency, recurrence interval, color, etc.), viewing a home summary (total
monthly/yearly amounts and list of expenses), an “Upcoming” tab for future
payment schedule, settings (theme, default currency, security), and
notifications/widgets for reminders. In the author’s words:

“Kotlin Multiplatform core sharing logic across Android, iOS, desktop; Compose
Multiplatform UI with Material3; Dependency Injection via Koin; Room Database
for reactive data with Coroutines & Flow; Home Screen Widgets on Android for
payment reminders.”..

Overall, the project aims for simplicity and extensibility. The developer encourages
contributions and has set up localization (via Weblate) and donation channels.. The
report will next examine the architecture and codebase in detail, followed by user
experience and analysis of advantages and limitations.
4. Architecture and Technology Stack

The Recurring Expense Tracker’s architecture follows modern mobile app patterns,
leveraging Kotlin Multiplatform and dependency injection. The core business logic
(data models, repository, database access, etc.) resides in a shared Kotlin module that
is compiled for each platform. The UI layer is implemented using Compose
Multiplatform, meaning the Android and Desktop interfaces are written in declarative
Compose (Material 3) code. On iOS, the presence of Swift code (0.2%) suggests a
minimal SwiftUI or UIKit entry point that calls into the shared Compose UI
(Compose Multiplatform can interop with iOS) or a native fallback. In either case, UI
components closely mirror across platforms to maintain consistency.

Key components of the stack include:

●​ Kotlin Multiplatform (KMP): The app’s shared module contains Kotlin

code compiled for Android, iOS, and desktop. This avoids code duplication
for business logic (expense calculations, date handling, etc.). KMP also
allows using multiplatform libraries (e.g., Kotlinx-Datetime for dates,
SQLDelight or Room for DB) seamlessly.
●​ Compose Multiplatform: The UI is built with Jetpack Compose for Android
and Compose for Desktop (and possibly iOS) using the latest Material 3
design. This provides a single codebase for many UI elements.
●​ Dependency Injection (Koin): The app uses Koin (a lightweight DI
framework) in a multiplatform way. This likely involves defining Koin
modules in the shared code and starting the Koin application at runtime,
injecting repositories and view models. DI makes the code modular and
testable.
●​ Persistence (Room Database): Data is stored in an SQLite database
via Room. A @Entity class (e.g., Expense) defines the table of recurring
expenses, and a @Dao interface provides data operations. For example:
@Dao

interface ExpenseDao {

@Query("SELECT * FROM expense ORDER BY

nextPayment ASC") fun getAllExpenses():
Flow<List<ExpenseEntity>>

@Insert(onConflict =
OnConflictStrategy.REPLACE) suspend
fun insert(expense: ExpenseEntity) }
This typical DAO setup uses Kotlin Coroutines and
Flow<List<ExpenseEntity>> so that the UI can observe changes reactively.
The database is initialized via Room and injected where needed. The use of the
Room is confirmed by project metadata..
 ●​ Architecture Pattern (MVVM): The app likely follows a
Model-View-ViewModel approach. The shared logic (models, repository) acts
as the Model, Compose UI functions as View, and platform-specific
ViewModels (possibly using ViewModel on Android) mediate between them.
Koin modules would supply ViewModel instances with the repository.
●​ Other Libraries: As per the F-Droid metadata, libraries include Jetpack
Compose (UI framework), AndroidX Core, etc.. Coroutines and Flow are
used for asynchronous tasks (as indicated in the README snippet). The
Android manifest requests minimal permissions (network state, notifications,
boot complete, biometrics) for its features, indicating limited dependencies.
●​ Android Glance Widgets: A unique feature is the use of Jetpack Glance to
create home-screen widgets on Android. These widgets display upcoming
payment reminders outside the main app (as shown in Figure 3 below). Glance
is a Compose-based framework specifically for app widgets, confirming a
modern implementation.
●​ Multiplatform Targets: The project targets Android API 15.0+ and desktop
platforms. The iOS target is present, but publishing is not done (requires an
Apple account). Kotlin’s multiplatform build (Gradle) compiles a shared
framework for each platform, as indicated in the README..

In summary, the Recurring Expense Tracker uses a shared Kotlin codebase for core
logic and a Compose-based UI for native look and feel. The architecture is modular
and follows best practices (dependency injection, reactive flows). Key features and
libraries are summarized as follows:

●​ Core: Kotlin Multiplatform, shared logic across Android, iOS, and Desktop.
●​ UI: Compose Multiplatform with Material3 (Android/desktop) and minimal
Swift code (iOS)...
●​ DI: Koin for multiplatform dependency management..
●​ Database: Room + SQLite with Kotlin Coroutines & Flow..
●​ Widgets: Android home-screen widgets via Glance (reminders)..
●​ Language Distribution: ~99.8% Kotlin, 0.2% Swift..
 ●​ Libraries: Jetpack Compose, AndroidX Core, (others not explicitly listed
but typical coroutines/Flow, Koin, etc.).

These choices result in a lightweight, cross-platform application. In subsequent

sections, we will see how this architecture translates to the user experience and what
the code enables in practice.

Data Collection:

Acquisition of a comprehensive dataset containing credit card transactions,

including labeled examples of both fraudulent and non-fraudulent transactions.
Publicly available datasets, such as the one from Kaggle, can be used to train the
model.
Codebase Structure and Implementation

The project’s repository is organized into multiple modules and directories. Notable
elements include:

●​ app/: The Android app module. Contains Android-specific code (Compose UI

screens,
AndroidManifest.xml, Gradle settings).
●​ iosApp/: The iOS app module. Likely contains an Xcode project or
Kotlin/Native setup to run the shared code on iOS devices.
●​ shared/ (or common): The Kotlin Multiplatform module (exact name may
vary) that includes core code. This typically has subpackages for data
models, repositories, and possibly common UI components if using
Compose Multiplatform.
●​ build.gradle.kts and Gradle scripts: The root and module build files configure
multiplatform targets (Android, iOS, desktop). They list dependencies (Koin,
Room, etc.) and specify Kotlin plugin usage.

Although the GitHub interface is not fully visible without login, we infer from the
Android
and iOS apps that the common code is placed under shared. This code likely
contains:

●​ The ExpenseEntity data class is annotated with @Entity for Room (e.g.,
fields: id, name, price, currency, recurrencePeriod, firstPayment, color,
reminderDays).
●​ ExpenseDao interface with Room queries (as shown above).
●​ ExpenseRepository class that provides functions like
getAllExpenses(): Flow<List<ExpenseEntity>> and
addExpense(expense: ExpenseEntity), encapsulating DAO calls.
●​ ViewModels or state holders (Kotlin classes) are used by UI composables
to obtain and expose data. For example, a HomeViewModel may call the
 repository and expose a Flow<List<Expense>> to the UI.
●​ AppModule.kt (or similar) defining Koin modules, binding singletons: the
●​ Room database, DAO, repository, and view models (e.g., single {
ExpenseData(get())
}, factory { ExpenseRepository(get()) }, viewModel { HomeViewModel(get())
}).
An example of a DAO (simplified) might be

@Dao
interface ExpenseDao {
@Query("SELECT * FROM expense ORDER BY nextPayment
ASC") fun getAllExpenses(): Flow<List<ExpenseEntity>>

@Insert(onConflict =
OnConflictStrategy.REPLACE) suspend fun
insert(expense: ExpenseEntity)
}

Identifying and creating relevant features that significantly contribute.

 2​ Here, getAllExpenses() returns a Flow<List<ExpenseEntity>>, so the app can
collect this flow to update the UI whenever the database changes (e.g., when a
new expense is added). The insert function adds or updates an expense. The
ExpenseDatabase (annotated with @Database(entities =
[ExpenseEntity::class], version = 1)) would provide an instance of
ExpenseDao. Room handles the database file creation.
3​ The UI implementation uses Compose. For instance, a typical
composable in the Android app might look like:

@Composable

fun HomeScreen(homeViewModel: HomeViewModel) {

val expenses by homeViewModel.expenses.collectAsState(initial = emptyList())

Column {
ExpenseSummary(expenses) // shows total
monthly/yearly LazyColumn {
items(expenses) { expense -

ExpenseCard(expense) // a row showing name, price, and recurrence

While we do not have the exact code, this pseudocode illustrates how the data
(collected from the ViewModel) feeds into UI components. The ExpenseCard could
display the name, amount, and next payment info, as seen in the screenshot (Figure
1). The plus-icon button on the Home screen likely triggers a navigation to an
“Add/Edit Expense” screen, which could be another composable with text fields and
controls.

On the settings side, the project likely uses Jetpack Preferences or a Compose-based
preferences screen. The screenshot (Figure 5) shows toggles and dropdowns, which
are standard Compose Switch and DropdownMenu components bound to a settings
DataStore or repository.

or notifications and widgets, the use of Glance suggests

code like: class ReminderWidget:
GlanceAppWidget() {
@Composable
override fun Content() {
// Compose code listing upcoming payments
}
}
4​ This widget code would gather expenses (perhaps via a background
service or reading the database) and display the nearest due items.
Similarly, Android notifications for upcoming payments would be
scheduled by the app (possibly using WorkManager or alarms) based on
the user’s reminder settings. The screenshot in Figure 6 shows
notifications with lines like “Next payment in 2 days”, implying the app
sends reminders.
5​ In summary, the implementation is a typical Compose + Room + MVVM
setup, but in a multiplatform context. Core functionality (expense data
management) is platform-agnostic, while UI and system integration are
platform-specific. The combination of Koin, Coroutines/Flow, and Room
allows clean architecture and a responsive UI. The project’s tags and
descriptions confirm this stack
6​
7​ Specifications:
8​
9​ Hardware Requirements:
●​ Processor: Intel Core i7 or equivalent
●​ RAM: 16 GB or higher
●​ Storage: SSD with at least 256 GB
●​ Graphics Card: NVIDIA GTX 1060 or equivalent for
GPU-accelerated training
●​ Operating System: Windows 10 or Linux (Ubuntu preferred)
10​ Software Requirements:
●​ Programming Language: Kotlin, compose multiplatform
●​ Jetpack compose
●​ Platform support: Available for both iOS and Android.
●​ Room database:
●​ Development Environment
●​ Version Control: Git and GitHub
User Experience and Setup

Setting up and using Recurring Expense Tracker is straightforward. For end users, the
primary platforms are Android (via Google Play or F-Droid) and desktop. For
Android, the app is published on Google Play (with an “Everyone” rating, ~500+
downloads) and also on F-Droid (open-source repository). For iOS and desktop, no
official releases are available; users must compile from source.

Installation: On Android, users can install it like any other app: either via F-Droid or
the Play Store. The F-Droid page provides a download link and metadata, indicating
it supports Android 8.0+. After installation, the app requests only minimal
permissions (notification, boot complete, etc.) as seen in the F-Droid listing. This
implies a privacy-focused design. No user accounts or internet permissions are
required. On a desktop, one would clone the repository and use an IDE
(IntelliJ/Android Studio) to run the desktop target. The README notes that for iOS,
an Apple developer account is needed for publishing; currently, the app “can only be
used when compiled locally.

Launching the App: Upon first opening, the app shows the Home screen, which
provides an overview of recurring expenses. The title bar says “Recurring Expense
Tracker”. Below the title, the current total recurring spend is summarized by period:
Monthly, Weekly, and Yearly. Initially, these totals are $0. The main area lists added
expenses as colored cards: each card shows the expense name, and on the right, the
price plus recurrence (e.g., “$399.00 / 1Y” meaning $399 per year). If no expenses
exist yet, this list is empty.
Adding/Editing Expenses: Users can add a new expense by tapping the floating “+”
button. This opens an Edit Expense screen (Figure 4). Fields include Name, an
optional Description, Price, Currency dropdown, Recurrence (interval and unit, e.g.,
“1 Month(s)”), First Payment date picker, and a Color selection. There is also a toggle
for an Upcoming payment reminder with a configurable number of days before the
payment (default 3). The user enters values and taps Save. For example, one might
enter Name = “Netflix Premium”, Price = 17.99 USD, Recurrence
= 1 Month, First Payment = Feb 1, 2025. After saving, this expense appears on the
Home screen with its monthly cost ($17.99) and underlying yearly total ($215.88)
reflected in the summary.
If the user taps an existing expense card, the Edit screen appears again (pre-filled),
allowing updates or deletion (the trash icon). All inputs immediately update the local
database via the shared logic. Because Flow is used, the Home screen list and
summary update reactively without reloading the app.

Overview Tabs: At the bottom of the app are three navigation tabs. Home, Upcoming,
and Settings. The Home tab shows the summary and current expenses. The
Upcoming tab (Figure 2) shows a chronological list of individual upcoming
payments, grouped by month. For example, it lists “May 2025 – $59.98” at the top,
followed by specific entries like “Mobile Phone: $34.99 on May 10, 2025 (in 6
days)”. This lets users see exactly when each payment is due. The Upcoming list is
computed from the current date and each expense..
recurrence. The total at the top ($59.98) reflects the sum of the due payments in the
current month (May 2025). Future months (June, July, etc.) follow. This feature helps
with short-term planning.

Settings and Customization: The Settings tab (Figure 5) provides user-configurable

options. Under General, the Theme mode can follow the system or be set to
light/dark. The Default tab can be chosen (e.g., open Home or Upcoming by default).
Under Currency, the Default Currency can be set (the system default or a fixed
currency). A toggle exists to show converted currency – if enabled, the app may
display both original and converted values (based on current exchange rates). A
notable addition (from v0.16.0) is support for 170+ currencies, so a user can track
expenses in non-USD easily. Security options include a Biometric lock toggle to
require a fingerprint/face to open the app. Under Notifications, the Upcoming
payment reminder switch enables periodic notifications of forthcoming payments.
Finally, Backup options allow the user to create and restore data backups manually.
(No automatic cloud sync is provided; backups appear to be exported/imported files
on the device.)

Interactive Example: The Figure shows the Edit Expense screen after entering
Netflix details. The fields illustrate the user flow: the user types text, picks dates and
colors, then saves. The figure caption explains each area. Figure 5 shows the Settings
screen with toggles for theme, default tab, currency preferences, etc.

Widgets and Notifications: Beyond the in-app UI, Recurring Expense Tracker
offers home-screen widgets on Android. Figure 3 shows an example Android home
screen with an “Upcoming Pay…” widget. This Glance-based widget lists the next
few payments (Netflix
$17.99 on May 1, Mobile Phone CHF34.99 on May 10, etc.), updating in real-time.
This allows users to see upcoming bills at a glance without opening the app.

Additionally, the app sends system notifications for reminders. Figure 6 illustrates a
notification shade on Android: two notifications (from “Expenses”) stating that
“Another Subscription – Next payment in 2 days” and “Netflix – Next payment in 3
days”. Tapping these would presumably open the app to the corresponding items.
These reminders rely on the user’s configured lead time and boot-completed service
to schedule alerts.

Overall, the user interaction model is intuitive: enter recurring expenses once, then
passively view summaries and get reminders. The UI uses Material You styling
(responsive layouts, card views with dynamic colors) and standard Compose
controls. The developer’s goal of simplicity is evident: the app has few screens,
minimal text, and focuses on core functionality. By keeping inputs and outputs clear
(see the annotated figures below), the app avoids overwhelming the user while still
providing all needed data. The home/ upcoming/settings navigation is typical for
mobile apps, making the learning curve low.

Home screen of Recurring Expense Tracker showing aggregate spending and

individual recurring items. The top section shows Monthly, Weekly, and Yearly totals
(e.g., “Monthly $101.98”). Below, each expense appears as a colored card with its
name and cost. For example, “Netflix Premium” is $17.99/month (red card), and
“Amazon Prime” is $7.42/month (blue card). The bottom navigation bar has three
tabs: Home (house icon), Upcoming (calendar).
Upcoming payments screen, grouping future charges by month. Here, “May 2025”
is summarized as $59.98 total (top). Under that, individual May payments are listed
(“Mobile Phone – $34.99 on May 10, in 6 days”, etc.). June and July are shown
below with their entries. This chronological view helps users see what’s due and
when. The same bottom navigation appears.
Android home screen with the app’s Upcoming Payments widget. An Android 14
home screen is shown with a widget titled “Upcoming Pay…” displaying the next
few payments (Netflix, Mobile Phone, etc.), with dates and amounts. This widget
(powered by Glance) allows a glance at upcoming charges without opening the app.

Edit/Add Expense screen for an entry. Fields include Name (“Netflix”) and
Description (“Premium”), Price (17.99 USD), Recurrence (1 Month), and First
Payment date (Feb 1, 2025). A color dot can be chosen for the expense. The
Upcoming payment reminder toggle (on) and Days before payment field specify
notification lead time (default 3 days). The Save button commits the entry.

Settings screen with configuration options. Sections include General (theme mode,
default tab), Currency (default currency, show converted), Security (biometric lock),
Notifications (enable payment reminders), and Backup (create/restore). These allow
the user to customize the app’s behavior and appearance.

To efficiently run the machine learning algorithms and ensure the system's optimal
performance,
the following hardware specifications are recommended:
Processor: A high-performance processor is essential for handling complex
computations involved in training and evaluating machine learning models.
The recommended processor is an Intel Core i7 or equivalent.
RAM: Memory plays a crucial role in managing the computational tasks and
data processing requirements of machine learning models. A minimum of 16
GB of RAM is recommended to provide sufficient memory for loading and
manipulating large datasets, training models, and running multiple processes
simultaneously without performance degradation.
Storage: Solid-state drives (SSDs) are preferred for their speed and reliability. An
SSD
with at least 256 GB of storage is recommended to store the datasets, software,
and model files. SSDs offer faster read/write speeds compared to traditional
hard drives, which enhances the overall performance of the system during data
loading and model training.
Graphics Card: A dedicated graphics card is beneficial for GPU-accelerated
training of machine learning models, particularly for deep learning
applications. The recommended graphics card is an NVIDIA GTX 1060 or
equivalent.
Operating System: The choice of operating system depends on compatibility
with the software tools and libraries used in the project. Both Windows 10 and
Linux (preferably Ubuntu) are suitable options.
Peripheral Devices: In addition to the core hardware components, peripheral
devices such as a high-resolution monitor, a reliable keyboard, and a mouse
are essential for a comfortable and efficient working environment.
Network Connectivity: Stable and high-speed internet connectivity is
important for downloading datasets, software updates, and libraries
Code Snippets (Supporting Examples)

Below are illustrative code snippets that reflect how certain features are implemented.

These are representative examples, not copied verbatim from the repository.

// Example of a Room Entity for recurring expenses

@Entity(tableName = "expense")
data class
ExpenseEnti
ty(

@PrimaryKey(autoGenerate = true) val id:

Long = 0, val name: String,
val
description:
String?, val
price:
Double,
val
currency:
String,

val recurrencePeriod: Int,​ // e.g., 1

val recurrenceUnit: String,​ //

e.g., "Month", val firstPayment:
LocalDate,
val color: Long,​ // ARGB color value

val reminderDays: Int​ // days before due date to notify

 )

This Expense Entity defines the database table fields. Each expense record
stores its name, amount, currency, recurrence interval, first payment date,
color, and reminder. The room uses this class to create the SQLite table.
// Example DAO interface with Flow for
reactive queries @Dao
interface ExpenseDao {

@Query("SELECT * FROM expense ORDER BY nextPayment

ASC") fun getAllExpenses(): Flow<List<ExpenseEntity>>

@Insert(onConflict =
OnConflictStrategy.REPLACE) suspend fun
insert(expense: ExpenseEntity)
}

The DAO provides methods to retrieve and insert expenses.

Returning Flow<List<ExpenseEntity>> means the UI can observe
getAllExpenses() and auto-update whenever the data changes.

// Example of a simple repository and ViewModel

class ExpenseRepository(private val dao: ExpenseDao) {

fun getExpenses() = dao.getAllExpenses() // Flow of expenses

suspend fun addExpense(expense: ExpenseEntity) = dao.insert(expense)

class HomeViewModel(private val repo: ExpenseRepository) : ViewModel() {

val​ expenses​ =​
repo.getExpenses().stateIn(viewModelScope,
SharingStarted.Lazily, emptyList())
}

The ExpenseRepository abstracts the data source. The

HomeViewModel (Android architecture component) exposes a
 StateFlow of expenses to the UI, collecting from the repository’s
flow.
1.​ Keras: A high-level neural networks API, written in Python and
capable of running on top of TensorFlow.

Data Processing Libraries: A powerful data manipulation and analysis library

for Python. Pandas provide data structures like DataFrames, which are
essential for data preprocessing, cleaning, and transformation.
 // Example of a Compose UI function displaying
expenses @Composable
fun HomeScreen(viewModel: HomeViewModel) {

val expenses by
viewModel.expenses.collectAsState() Scaffold(
floatingActionButton = { AddExpenseFab() }

){

Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
SummaryWidget(expenses) // shows Monthly/Yearly totals
Spacer(modifier = Modifier.height(8.dp))
LazyColumn {
items(expenses
) { expense ->
ExpenseCard(expense)

In this Compose snippet, the HomeScreen collects the expense list from the
ViewModel and displays a summary (e.g., total monthly) and a scrollable list of
ExpenseCard composables (each showing one expense). The AddExpenseFab() is
the floating action button to add a new entry.

Each snippet above exemplifies key parts of the implementation: data models, data
access, business logic, and UI. Together, they show that the app uses standard
patterns (Room for data, Flow/Coroutines for reactivity, ViewModel for UI data,
Compose for interface).
 Strengths and Key Features

Recurring Expense Tracker has several notable strengths:

●​ Focused Functionality: It concentrates on recurring expenses

specifically, making the app simple and uncluttered. By not trying to
manage all finances, it provides a straightforward user experience for its
niche use case..
●​ Multiplatform Code Reuse: The use of Kotlin Multiplatform means most
code is shared across Android, iOS, and desktop. This reduces bugs and
ensures feature parity. New features (e.g., currency support) benefit all
platforms at once..
●​ Modern Tech Stack: Utilizing Compose (Material You) gives a modern,
responsive UI with a unified design. Dependency injection (Koin) and
reactive flows (Room + Coroutines) make the codebase clean and
maintainable..
●​ Open Source and Privacy: As a GPL-licensed project with no
advertising or data collection, it appeals to privacy-conscious users. The
F-Droid listing confirms “No data shared” and “No data collected.”..
●​ Active Development: Frequent updates (39 releases) and recent feature
additions (like multi-currency support for 170+ currencies) demonstrate
ongoing commitment. Support for many currencies and a setting to use
the system default shows responsiveness to international users.
●​ Cross-Platform Availability: Although the iOS release is pending, the
ability to compile for desktop means users can run it on
Windows/Linux/macOS. This broad reach is uncommon for small finance
tools.
●​ Widgets and Reminders: The inclusion of home-screen widgets
(Figure 3) and notification reminders (Figure 6) is are advanced
feature not always found in simple trackers. These add value by
proactively notifying users of due payments.
 ●​ Minimal Permissions & On-device Data: The app functions entirely
on-device without requiring a network. This enhances security (and also
means it works offline). The permission list is minimal (no account
linking or internet).
●​ Easy Setup for Android: Users can install via the Play Store or
F-Droid like any normal app. The developer explicitly notes, “You can
build the app like any other normal Android project by using Android
Studio, simplifying onboarding for developers.

In the academic context, one can view the app as a practical application of
cross-platform mobile architecture. It effectively demonstrates how KMP and
Compose can be used to build a consistent user experience across devices... The
architecture choices (MVVM, DI, Room) align with current best practices in
mobile development.
Limitations and Areas for Improvement
Despite its strengths, the project has limitations and potential improvements:

●​ Limited to Recurring Expenses Only: Users cannot track one-time or

irregular expenses (such as grocery shopping). The strict focus excludes
these, which might frustrate users wanting a complete budget solution. A
possible improvement would be an optional mode for one-off expenses or
expenses without recurrence.
●​ Manual Entry Required: All expenses must be entered manually. There
is no integration with bank statements or automatic import, which means
additional user effort. Some competitors automatically detect subscription
charges from accounts; this app does not. While this design choice protects
privacy, it also limits convenience. Future work could explore optional
import features (e.g., CSV import) while preserving local data ownership.
●​ No Cloud Sync: Data is stored locally on each device. There is no user
account or cloud synchronization. Consequently, users who install on
multiple devices (e.g., phone and desktop) cannot easily sync data. Adding
an optional encrypted sync via Google Drive or iCloud could improve the
experience. The app does have a manual backup/restore function, but this
is less seamless.
●​ iOS Distribution: The iOS version cannot be published without an
Apple developer account (which costs $99/year). As noted by the author,
the app “can only be used [on iOS] when compiled locally”.. This
excludes casual iOS users. One workaround could be sharing TestFlight
builds, or encouraging open-source community to manage an enterprise
certificate. At present, iOS support is effectively limited to developers.
●​ Desktop Publishing: Similarly, while the app “compiles and works for all
3 desktop OS, there is no packaged release. Users would need to build
from source or run via IntelliJ/command line. Providing packaged
executables (e.g., via GitHub releases) for Windows, macOS, and Linux
 would greatly enhance accessibility.
●​ User Interface Polish: The UI is functional but relatively basic. For
example, the Settings screen uses simple toggles and menus. Some text
fields (Figure 4) appear with placeholder styling that might confuse new
users. The design is consistent with Material You, but could benefit from
more explanatory text or tooltips for first-time users (e.g., what
“recurrence period” means).
●​ Localization: While the author set up a translation platform (Weblate.),
the current interface appears to be in English only. To reach
non-English users, actual translations need to be completed.
Community contribution could help here.
●​ Performance and Scalability: For typical use (tens of expenses),
performance is fine. However, because Room is local, if a user has
hundreds of entries or hundreds of months of upcoming events, the UI
might lag. Caching or pagination in the Upcoming list could help. (This is
speculative, as no performance issues are documented yet.)
●​ Feature Scope: Many desirable features are missing (e.g., expense
categories, charts/analysis, budgeting alerts beyond single events). These
could be future enhancements. For instance, the Upcoming tab covers
only fixed recurrences, budgeting
 Users might want an overall monthly budget target or category
summaries, which are outside the app’s current scope.
●​ Reliance on One Developer: The project depends on one primary
maintainer. Although it’s open to contributions, growth may be slow
without a team. Community involvement and contributions will determine
how quickly requested features are added.
●​ Academic Considerations: From an academic standpoint, it would
be useful to see automated tests or code documentation, but these are
not immediately evident. The project might benefit from including
unit tests (especially for date calculations of recurrences) to ensure
correctness.

In summary, the main limitations are feature scope (no automatic import or
budgeting beyond fixed expenses), and distribution constraints on non-Android
platforms. These reflect design trade-offs (simplicity and privacy) but point to
future work. Potential improvements include adding sync capabilities,
expanding the feature set (charts, categories), improving UX details, and
releasing desktop/iOS builds.

In this project the major task of this project is to create a record of the daily
transactions. In this project, we use Agile methodology. Project management using
the agile technique entails segmenting a project into stages, working continuously
with stakeholders, and making improvements at each level. The teams collaborate
with other teams and project stakeholders as they go through planning, doing, and
evaluating cycles. The methodology emphasises how crucial it is to maintain close
communication with stakeholders throughout the project to guarantee success.
Teams frequently utilise the agile methodology for project management because it
enables them to react fast to market changes or client input without upsetting
long-term objectives. It requires little planning and ships frequently in tiny
increments, enabling teams to get feedback on each change and inexpensively
incorporate it into plans. Teams become more flexible and sensitive to changes as
a result of this method, which is crucial in a dynamic business environment.
Expense Tracker is a mobile application that allows users to track their expenses.
The application will have a two-tier architecture, with a database tier for storing
financial data and a user interface for interacting with the system. The system is
designed to operate offline, with different categories for users to select from and
enter the amount and mode of payment. The system will analyze the information
and provide analytics on which category the user spent the most of their money.
The user interface will allow users to store and observe their past expenses.
 Conclusion

The Recurring Expense Tracker is a compelling demonstration of a focused,

modern personal finance tool. It effectively meets the need for managing
predictable monthly expenses by offering a dedicated app with a clean UI,
cross-platform reach, and privacy-by-design. The use of Kotlin Multiplatform and
Jetpack Compose allows a single codebase to drive Android, desktop, and
(theoretically) iOS versions, showcasing cutting-edge mobile development
practices.

In this report, we have presented background on the importance of tracking

recurring expenses. and compared existing solutions. We analyzed the project’s
architecture (KMP core, Compose UI, Room database, Koin DI) and technology
stack.. We described the user experience in detail, including setup, navigation
(Home/Upcoming/Settings), and interaction flows (adding/editing expenses).
Several screenshots (Figures 1–6) illustrate the app’s functionality and design.
Code snippets were provided to exemplify key implementation aspects (data
model, DAO, Compose UI). Finally, we discussed strengths (simplicity,
cross-platform code reuse, privacy) and limitations (lack of auto-import, iOS
distribution) along with areas for improvement.

Overall, Recurring Expense Tracker stands out as an accessible, open-source

solution for users who prefer a lightweight approach to recurring payments. Its
GPL-licensed code also makes it a valuable educational example for students and
developers learning multiplatform app development. Future enhancements – such
as cloud sync, graphical reports, or broader platform support – would further
increase its utility. For now, it serves well its core mission: helping users stay on
top of their regular bills without unnecessary complexity, as reflected in both its
design and documentation..
References: Author-provided documentation and reputable sources were cited
throughout (e.g., the GitHub and F-Droid project pages, and financial guidance
articles) to support factual statements. These sources confirm the app’s features,
data practices, and technical choices. The project’s own README and listings
served as primary references for project details and descriptions. We have adhered
to academic formatting with clear sections and citation of external content where
appropriate, ensuring the report is both informative and credible.