DEV Community: Marcin Parśniak

Finovara - Building a Simple Chatbot in Spring Boot

Marcin Parśniak — Wed, 25 Mar 2026 16:37:24 +0000

Recently, I added a simple chatbot to my Finovara app that answers users’ finance-related questions.

No AI, no NLP libraries — just clean architecture, enums, and text files.

It works surprisingly well for the limited scope we need. Here’s how it’s built.

The Idea

The chatbot works like this:

A user asks a question.
The system normalizes the input.
It maps the question to a predefined entry.
The entry corresponds to a SmartReportType enum.
The enum is handled by a handler class.
The handler generates the actual response.

This makes the system:

Predictable
Easy to extend
Fast and lightweight

Core Architecture

The main entry point is:

  public String generateResponse(String email, String userQuestion) {
        User user = userManagerService.getUserByEmailOrThrow(email);

        SmartReportType type = smartReportQuestionService.getTypeFromQuestion(userQuestion);

        if (type == null)
            return "I’m not smart enough to answer this question. Please ask a question from the question book!";

        SmartReportHandler handler = handlers.get(type);

        if (handler == null) {
            return "Report type not supported";
        }

        return handler.generate(user.getId());
    }

Here’s what’s happening:

The question is mapped to a SmartReportType enum.
Each enum has its own handler.
The handler generates a response based on templates and user data.

This is basically a Strategy Pattern in action.

Mapping Questions to Enums

Instead of hardcoding questions in Java, they are stored in TXT files:

MONTH_SPENDING | how much did i spend this month
MONTH_SPENDING | monthly expenses
AVERAGE_DAY_SPENDING | average daily spending
EXPENSE_RATE | what percentage of my income is spent
SAVINGS_RATE | how much did i save

Loader Service:

questionMap.put(question, SmartReportType.valueOf(enumName));

Normalization:

private String normalize(String text) {
    return text.toLowerCase()
        .trim()
        .replace("?", "");
}

Thanks to this:

“How much did I spend?”
“how much did i spend”
“HOW MUCH DID I SPEND??”

all map to the same key.

Handlers: Business Logic

Each enum type has its own handler:

public interface SmartReportHandler {
    SmartReportType getType();
    String generate(Long userId);
}

Handlers are responsible for fetching user data and generating responses.

Example: Expense Rate

BigDecimal total = sumExpenses.multiply(BigDecimal.valueOf(100))
    .divide(sumRevenue, 2, RoundingMode.HALF_UP);

String template = templateService.getRandomResponse(SmartReportType.EXPENSE_RATE);
return template.replace("{amount}", total.toString());

Dynamic Responses (Templates)

Responses are stored in text files instead of being hardcoded:

You spent {amount} this month.
Your total expenses are {amount}.
Your savings rate is {amount}%.

Randomization makes replies feel less repetitive:

return responses.get(random.nextInt(responses.size()));

*Thanks for reading! *

If you’re curious to see the full project or try it yourself, check out the code on GitHub:

M4rc1nek / finovara-backend

Backend service for a personal finance management application

Finovara

Finovara is a financial management platform designed to help users effectively track analyze, and optimize their income, expenses, and savings The application provides a secure, bank-like experience focused on transparency, financial awareness, and long-term money planning.

🎯 Purpose of the Application

Finovara aims to support users in making better financial decisions by offering clear insights into their financial activity and helping them maintain control over their budgets and savings.

The platform focuses on:

organizing income and expenses in a structured way
visualizing financial data through charts and statistics
supporting saving goals and spending limits
providing a virtual wallet concept for daily financial management

🚀 Key Features

Secure user authentication and authorization
Income and expense tracking
Categorization of financial operations
Interactive charts and financial statistics
Reports summarizing spending and income trends
Virtual wallet management
Savings goals (e.g. piggy banks)
Spending limits and budget control
Scalable architecture prepared for future financial…

View on GitHub

Deploying Finovara on Docker and fixing a critical bug.

Marcin Parśniak — Fri, 20 Mar 2026 21:35:33 +0000

I recently decided to move my Spring Boot app Finovara to Docker.

At first it was just supposed to be a small improvement to the setup.
In reality, it turned into a debugging session that took way longer than I expected.

Why I even bothered with Docker

There were a few reasons behind this:

I wanted more control over the environment
I needed a separate database (finovara-test) for automated tests
I was tired of manually setting everything up locally
and I wanted something closer to a real production setup

Initial setup

I started with a simple PostgreSQL container and connected my app to it.

Here’s a simplified version of what I used:

services:
  finovara-db:
    image: postgres:15
    container_name: finovara-db
    restart: always
    environment:
      POSTGRES_DB: finovara
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      retries: 10

Dockerfile:

FROM eclipse-temurin:21-jdk
WORKDIR /app
COPY target/*.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

Everything started without issues.
Database was running, app connected, no errors.

So I thought I was done.

The moment things got weird

I made some changes in the app, rebuilt everything, ran it again and nothing changed.

same responses
same data
same behavior

At this point I was pretty sure I messed something up.

What I thought vs what it actually was

My first guess was Docker caching.
Seemed like the obvious explanation.

But after digging a bit more, it turned out to be something else entirely.

The app was connecting to a completely different database than I expected.

Everything looked correct:

same DB name
same user
same config

So from the outside it looked like everything was fine, but I was basically working on one database and checking another.

Fixing it

The fix wasn’t one single thing, more like a combination of small adjustments:

I changed the password in my .env file
I changed the port, because something else was already using 5432
I cleaned up and adjusted the docker-compose config
and most importantly, I actually verified which database the app connects to

After that, everything finally made sense again and changes started showing up immediately.

Thanks for reading and visit my github!

M4rc1nek / finovara-backend

Backend service for a personal finance management application

Finovara

🎯 Purpose of the Application

Finovara aims to support users in making better financial decisions by offering clear insights into their financial activity and helping them maintain control over their budgets and savings.

The platform focuses on:

organizing income and expenses in a structured way
visualizing financial data through charts and statistics
supporting saving goals and spending limits
providing a virtual wallet concept for daily financial management

🚀 Key Features

Secure user authentication and authorization
Income and expense tracking
Categorization of financial operations
Interactive charts and financial statistics
Reports summarizing spending and income trends
Virtual wallet management
Savings goals (e.g. piggy banks)
Spending limits and budget control
Scalable architecture prepared for future financial…

View on GitHub

Liquibase in Spring Boot – Developer's Guide

Marcin Parśniak — Tue, 10 Mar 2026 08:05:12 +0000

Liquibase in Spring Boot – Developer's Guide

Managing database schema changes can seem simple at first… until it isn’t. A quick ALTER TABLE here and there might work with one developer, but once you have multiple environments—dev, staging, prod—things get messy fast.

This is where Liquibase comes in.

In this guide, I’ll walk you through:

What Liquibase is and why it matters
Setting it up in Spring Boot
Writing migrations safely
Managing different environments

What is Liquibase?

Liquibase is essentially Git for your database schema. Instead of running SQL scripts manually and hoping everyone runs them correctly, you define changes in a structured format and Liquibase tracks which ones have been applied.

Example XML changeset:

<changeSet id="add-phone-number" author="dev">
    <addColumn tableName="users">
        <column name="phone_number" type="varchar(20)"/>
    </addColumn>
</changeSet>

Liquibase keeps track of applied migrations in a table called DATABASECHANGELOG, ensuring:

Changes are applied only once
Order is maintained
Rollbacks are possible

Why use Liquibase with Spring Boot?

Some key benefits:

Consistent environments – dev, staging, and prod stay in sync
Migration history – see who changed what and when
Automatic migrations – Spring Boot can run them on startup
Rollbacks – undo changes safely if needed

Adding Liquibase to your project

Maven:

<dependency>
    <groupId>org.liquibase</groupId>
    <artifactId>liquibase-core</artifactId>
</dependency>

Gradle:

implementation 'org.liquibase:liquibase-core'

Spring Boot will automatically detect Liquibase and run migrations.

Configuration

In application.yml (safe YAML formatting):

spring:
  liquibase:
    change-log: "classpath:/db/changelog/changelog.xml"
    contexts: "dev"

Typical project structure:

resources
 └ db
    └ changelog
        └ changelog.xml

Master changelog with multiple changesets

Instead of separate XML files, you can put all changesets in a single file: changelog.xml

<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog
                   http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.8.xsd">

    <changeSet id="create-users" author="you">
        <createTable tableName="users">
            <column name="id" type="bigint">
                <constraints primaryKey="true"/>
            </column>
            <column name="email" type="varchar(255)">
                <constraints nullable="false"/>
            </column>
            <column name="created_at" type="timestamp"/>
        </createTable>
    </changeSet>

    <changeSet id="add-email-index" author="you">
        <createIndex indexName="idx_users_email" tableName="users">
            <column name="email"/>
        </createIndex>
    </changeSet>

    <changeSet id="add-phone-column" author="you">
        <addColumn tableName="users">
            <column name="phone_number" type="varchar(20)"/>
        </addColumn>
        <rollback>
            <dropColumn tableName="users" columnName="phone_number"/>
        </rollback>
    </changeSet>

    <changeSet id="insert-test-data" author="you" context="you">
        <insert tableName="users">
            <column name="id" valueNumeric="1"/>
            <column name="email" value="test@example.com"/>
        </insert>
    </changeSet>

</databaseChangeLog>

Using SQL instead of XML

You can also write all changesets in a single formatted SQL file:

-- liquibase formatted sql
-- changeset dev:create-users
CREATE TABLE users (
    id BIGINT PRIMARY KEY,
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP
);

-- changeset dev:add-email-index
CREATE INDEX idx_users_email ON users(email);

-- changeset dev:add-phone-column
ALTER TABLE users ADD COLUMN phone_number VARCHAR(20);
-- rollback: ALTER TABLE users DROP COLUMN phone_number;

Best practices

Never edit executed migrations – migrations are immutable
One changeset = one change – separate tables, columns, and indexes
Number your files if using multiple files – avoids Git conflicts
Test locally – drop the DB, run the app, ensure migrations work from scratch
Be careful on production – avoid ALTER COLUMN TYPE, DROP COLUMN, or NOT NULL on large tables

Liquibase vs Flyway

Feature	Liquibase	Flyway
XML/YAML/JSON	✔	✖
SQL	✔	✔
Rollback	✔	limited

Flyway is simpler but Liquibase is more flexible for enterprise setups.

Conclusion

Liquibase is a lifesaver for keeping database schema consistent across environments. Stick to the golden rules:

immutable migrations
one change per changeset
test migrations locally

Thanks for reading!

Revenue test (JUnit5) - Finovara

Marcin Parśniak — Sat, 07 Mar 2026 10:56:13 +0000

Hello!

After the latest update to my project, I decided it was the perfect time to finally start writing tests for Finovara.

So far, I've written tests for the main methods.
On average, I run 2-3 tests per method, which seems like a good compromise. I cover both the happy path and a few edge cases and alternate flows—basically, I try to make sure everything works as expected, regardless of the situation.

Overall, I'm aiming for 70-80% code coverage, though this may change as I add more tests and improve what I already have.

Example of a simple test:

@Test
void shouldAddRevenueSuccessfully() {
        RevenueDTO dto = new RevenueDTO(null, null, new BigDecimal("100"), RevenueCategory.SALARY, null, "test income");
        String email = "test@test.com";
        User user = new User();

        when(timeConfig.clock()).thenReturn(Clock.systemDefaultZone());
        when(userManagerService.getUserByEmailOrThrow(email)).thenReturn(user);

        revenueService.addRevenue(dto, email);

        verify(walletService).addBalanceToWallet(email, dto.amount());
        verify(revenueActivityService).createRevenueActivity(eq(email), eq(RevenueActivityType.ADDED_REVENUE), any(Revenue.class));
        verify(revenueRepository).save(any(Revenue.class));
        verify(revenueScoringService).recalculateScore(email);
        verify(autoPaymentsService).handleRevenuePiggyBankAutomation(email, dto.amount(), AutoPaymentsMode.APPLY);
    }

Next, I plan to write expense tests. I'll see how it goes

Thanks for reading, and please visit my GitHub:

M4rc1nek / finovara-backend

Backend service for a personal finance management application

Finovara

Finovara is a financial management platform designed to help users effectively track analyze, and optimize their income, expenses, and savings The application provides a secure, bank-like experience focused on transparency, financial awareness, and long-term money planning.

🎯 Purpose of the Application

Finovara aims to support users in making better financial decisions by offering clear insights into their financial activity and helping them maintain control over their budgets and savings.

The platform focuses on:

organizing income and expenses in a structured way

visualizing financial data through charts and statistics

supporting saving goals and spending limits

providing a virtual wallet concept for daily financial management

🚀 Key Features

Secure user authentication and authorization

Income and expense tracking

Categorization of financial operations

Interactive charts and financial statistics

Reports summarizing spending and income trends

Virtual wallet management

Savings goals (e.g. piggy banks)

Spending limits and budget control

Scalable architecture prepared for future financial…

View on GitHub

User Notification Settings - Finovara

Marcin Parśniak — Thu, 05 Mar 2026 22:35:56 +0000

Hello everyone!

In the latest update to Finovara,
I implemented user notification settings.
This feature allows users to decide whether they want to receive email notifications for important account events.

What this feature does

Users can now enable or disable notifications for important events happening in their account.

When notifications are enabled and the user:

changes their password
changes username
deleted account

the system will send an email notification to the address assigned to his account informing his of the change.

Example of mail sending method:

 @Async
    public void sendEmail(User user, String subject, String templatePath, String username, String email) {
        try {
            MimeMessage message = javaMailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");

            helper.setTo(user.getEmail());
            helper.setFrom("Finovara <" + senderAddress + ">");
            helper.setReplyTo(senderAddress);
            helper.setSubject(subject);

            String html = loadTemplate(templatePath, username, email);
            helper.setText(html, true);

            javaMailSender.send(message);

        } catch (Exception e) {
            throw new RuntimeException("Failed to send email", e);
        }
    }

Example loadTemplate:

 private String loadTemplate(String templatePath, String username, String email) {
        try {
            ClassPathResource resource = new ClassPathResource(templatePath);
            try (InputStream inputStream = resource.getInputStream()) {
                String html = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);

                if (username != null) {
                    html = html.replace("{{username}}", username);
                }
                if (email != null) {
                    html = html.replace("{{email}}", email);
                }
                return html;
            }
        } catch (Exception e) {
            throw new RuntimeException("Failed to load email template", e);
        }
    }

Thanks for reading!

I encourage you to take a look at the process of creating the Finovara application at: https://github.com/M4rc1nek/finovara-backend

Moving from Hibernate Auto-DDL to Liquibase - Finovara

Marcin Parśniak — Tue, 03 Mar 2026 18:54:06 +0000

Hello!

For a long time in my Spring Boot project, I relied on

hibernate.ddl-auto = update

It was simple.
Change an entity → restart the app → the database updates itself.

But when the project grew to 18 entities, I realized something important:

I had zero control over my database history.

So I decided to switch to Liquibase.

What I Changed

Disabled Hibernate auto schema updates

spring:
  jpa:
    hibernate:
      ddl-auto: none

From that moment, Hibernate stopped modifying the database structure.

2. Enabled Liquibase

spring:
  liquibase:
    enabled: true
    change-log: classpath:db/changelog/changelog.xml

3. Added simple changeSets

<changeSet id="1-create-users" author="Marcin Parśniak">
        <createTable tableName="users">
            <column name="id" type="BIGINT" autoIncrement="true">
                <constraints primaryKey="true" nullable="false"/>
            </column>
            <column name="username" type="VARCHAR(255)">
                <constraints nullable="false" unique="true"/>
            </column>
            <column name="password" type="VARCHAR(255)">
                <constraints nullable="false"/>
            </column>
            <column name="email" type="VARCHAR(255)">
                <constraints nullable="false" unique="true"/>
            </column>
            <column name="created_at" type="TIMESTAMP"/>
            <column name="profile_image_path" type="VARCHAR(500)"/>
        </createTable>
    </changeSet>

Now Liquibase manages the schema.

If you want to see how im doing it, check out my github profile:

M4rc1nek / finovara-backend

Backend service for a personal finance management application

Finovara

🎯 Purpose of the Application

Finovara aims to support users in making better financial decisions by offering clear insights into their financial activity and helping them maintain control over their budgets and savings.

The platform focuses on:

organizing income and expenses in a structured way
visualizing financial data through charts and statistics
supporting saving goals and spending limits
providing a virtual wallet concept for daily financial management

🚀 Key Features

Secure user authentication and authorization
Income and expense tracking
Categorization of financial operations
Interactive charts and financial statistics
Reports summarizing spending and income trends
Virtual wallet management
Savings goals (e.g. piggy banks)
Spending limits and budget control
Scalable architecture prepared for future financial…

View on GitHub

Reccuring Revenue - Finovara

Marcin Parśniak — Mon, 02 Mar 2026 21:27:00 +0000

Hello everyone!

A while ago, I added a new setting to the Finovara app.

What did I add?

I added a user setting for recurring revenue.

The user specifies the:

recurring revenue amount
revenue category
start date
frequency of revenue generation (daily, weekly, monthly)

How does it work?

The scheduler runs cron daily (currently every minute as a test, but will run daily at midnight).

The cron runs and checks if the revenue generation date matches.
If so, we check the condition in the code.
If it matches, a recurring revenue is created.

This is what an example implementation in a processor looks like:

for (User user : users) {
            RevenueSettings settings = user.getRevenueSettings();
            if(settings == null) continue;
            while(settings.isRecurringRevenuesEnable() && settings.getNextExecutionDate() != null && !settings.getNextExecutionDate().isAfter(today)){
                createRecurringRevenue(user, settings);
                switch (settings.getRecurringStrategy()) {
                    case DAILY -> settings.setNextExecutionDate(settings.getNextExecutionDate().plusDays(1));
                    case WEEKLY -> settings.setNextExecutionDate(settings.getNextExecutionDate().plusWeeks(1));
                    case MONTHLY -> settings.setNextExecutionDate(settings.getNextExecutionDate().plusMonths(1));
                }
            }
        }

Finovara - Piggy banks activity logs.

Marcin Parśniak — Fri, 27 Feb 2026 21:31:35 +0000

Hey everyone 🙂

I’ve been working on another improvement in my Finovara project — this time around Piggy Banks.

Recently I added something I called Activity tracking for savings. The idea was simple: when people save money, they should clearly see what actually happened in their piggy banks.

So now, whenever a user:

• puts money into a piggy bank
• withdraws funds
• creates a new piggy bank
• deletes one
• or performs any savings-related action

it all gets recorded in their activity history.

Each entry shows what happened, when it happened, and the amount involved. Nothing fancy, just clear visibility so users don’t have to guess where their money moved.

While working on this, I also cleaned up something on the backend side.

Previously, every saving feature had to be saved separately. It worked, but it felt messy and required multiple API calls.

So I introduced a single endpoint that lets the frontend save all piggy bank settings in one request.

Now it handles things like:

• automatic savings rules
• transaction round-ups
• goal completion behavior

The backend simply receives one DTO with all sections and passes them to the right services internally.

It made the whole flow much simpler, both for the API and for the frontend.

Thanks for reading! :D

Finovara - Limits activity logs.

Marcin Parśniak — Wed, 25 Feb 2026 20:13:46 +0000

Hi everyone,
In the latest update of my Finovara project, I added more logs for user activities about limits.
How does it work?

As soon as a user:
• Adds a limit
• Removes a limit
• Edits a limit

They can see all their account activities.

A sample JSON looks like this:

{
"limitActivityType": "ADDED_LIMIT",
"limitType":  "DAILY",
"amount": 1500.00,
"previousAmount": 1000.00,
"date": "2026-02-25T14:30:00"
}

Records are deleted from the database every month thanks to the scheduler and cron job set in the .yml file.
Here's the link to the commit related to this update: https://github.com/M4rc1nek/finovara-backend/commit/ce42ab006d46d0c309d3806ddf83498065cbd3ea

Thanks for reading!

Building Activity Logs for Expenses and Revenue in Finovara

Marcin Parśniak — Tue, 24 Feb 2026 08:52:38 +0000

Hi everyone,

First of all, I would like to invite everyone to my github: https://github.com/M4rc1nek/finovara-backend
So,

I’ve just finished working on a new feature in my project Finovara. I added a full activity log system that tracks changes for both expenses and revenue.

Why I built it

Users should always be able to see what happened to their data, what changed, when it changed, and what the previous values were.

That’s why I decided to implement an audit-style activity history for all financial operations.

What the system tracks

The activity logs now record actions for both expenses and revenue. It includes:

• adding a record
• editing a record
• deleting a record
• saving previous values whenever something is updated

Logs for expenses and revenue work in exactly the same way. They follow the same structure and logic, just applied to different types of financial data.

What a log entry contains

Each activity record stores:

• type of operation
• amount
• category
• date
• previous amount when edited
• previous category when edited

Because of this, when a value changes, the user can clearly see both the old and the new data.

How it works under the hood

All logs are stored in dedicated tables that act as an audit trail. Whenever an expense or revenue operation happens, the service layer automatically creates an activity entry. This keeps the logging fully transparent and doesn’t clutter the business logic.

Sorting

Users can sort their activity history by newest, oldest, highest amount, or lowest amount.

I implemented this using Spring Data sorting. The frontend sends the selected option, and the backend maps it to the proper configuration so the database returns already sorted results.

Automatic cleanup

I also added a scheduler to prevent the tables from growing forever. Every six months it automatically removes old activity logs. This keeps the system clean while still preserving a long enough history window.

Why this matters

This makes Finovara feel much closer to a real financial system. Users get full visibility into their financial history and can always understand what happened to their data.

It also creates a solid foundation for future features like security activity tracking, full account history logs, and advanced auditing.

More updates coming soon.

My programming journey from age 10 to building a real backend system

Marcin Parśniak — Sun, 22 Feb 2026 19:45:09 +0000

Hi everyone,

My name is Marcin, I’m 16 years old, and programming has been a part of my life for many years.

How it started

I began my journey at the age of 10, learning C# completely on my own.
At first, I built:

simple console programs
small logic games
basic interactive projects

That was the moment I realized I genuinely enjoyed creating things from nothing using code.

Exploring technology

As I grew older, I started exploring different areas of tech.
For a while, I focused on game development, building projects in:

Godot (GDScript)
Unity (C#)
Unreal Engine (Blueprints)

Through this, I learned not only programming, but also:

problem-solving
logical thinking
how complex systems are structured

Beyond coding — understanding computers

At the same time, I became interested in the broader technical side of computers.

I spent time learning about:

computer hardware
how operating systems work internally
networking fundamentals
basic cybersecurity concepts

I was always curious about how systems really function under the hood, not just how to use them.

Choosing a direction

Around the age of 15, I decided to focus fully on backend development.

Since then, I’ve been specializing in:

Java
Spring ecosystem
backend architecture
building real-world applications

What interests me most is designing systems, implementing business logic, and understanding how everything connects together.

What I’m working on now

Currently, I’m developing my biggest project so far — Finovara.

It’s a personal finance management backend system, similar to a virtual banking logic platform, which I’m designing and building entirely on my own.

This project allows me to combine everything I’ve been learning:

system architecture
backend engineering
security thinking
real-world problem solving

Constant learning

I spend a lot of time learning, experimenting, and improving every day.

Programming isn’t just something I study —
it’s something I naturally enjoy doing in my free time.

If you’re interested

If you’d like to see what I’m working on, feel free to check my GitHub, especially my main project Finovara.

Thanks for reading.