DEV Community: Shreeprabha bhat

Why I Switched from H2 to MongoDB in My Growing Spring Boot App

Shreeprabha bhat — Sun, 26 Oct 2025 15:31:59 +0000

When I started building my Expense Tracker application, all I cared about was testing my APIs without the complications of setting up a database. I just needed something lightweight that would let me test my APIs and move fast.

That’s when I chose H2 Database. It was easy, embedded, and worked right out of the box. But as my application grew and I started incorporating real life scenarios into the app, I began hitting the limitations of H2. That’s when I realized it was time to move to something more scalable and production ready MongoDB.

Honestly, my decision to use MongoDB wasn’t driven by any specific reason. It was simply pre installed on my computer, and I made the laziest move possible I went ahead and used what was already available.

I also had hands on experience testing MongoDB applications when I worked as a tester. Now, using MongoDB to develop my application after switching to development actually made my work more interesting and explorative.

Installing MongoDB Compass

MongoDB Compass is the official GUI for MongoDB that allows you to visualize, explore, and manage your data easily. Here’s how to install it on different operating systems:

Windows
Download the installer from https://www.mongodb.com/try/download/compass
Run the .exe file and follow the installation wizard.
Once installed, launch Compass and connect to your local MongoDB instance using:
mongodb://localhost:27017
macOS
Download the .dmg file from https://www.mongodb.com/try/download/compass
Open the .dmg file and drag MongoDB Compass into your Applications folder.
Open Compass and connect using:
mongodb://localhost:27017
Linux
Download the .deb package from https://www.mongodb.com/try/download/compass
Install it using the terminal:
sudo dpkg -i mongodb-compass_<version>_amd64.deb sudo apt-get install -f
Launch Compass from the applications menu or by running:
mongodb-compass
Connect to your MongoDB instance using:
mongodb://localhost:27017

Configuring MongoDB in Your Spring Boot App

After installing MongoDB and Compass, the next step is to configure your Spring Boot application to use MongoDB instead of H2. Here’s how I did it:

Add MongoDB Dependency

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
            <version>4.0.0-M2</version>
        </dependency>

Update application.properties In src/main/resources/application.properties, configure the connection to your local MongoDB instance:

spring.data.mongodb.uri=mongodb://localhost:27017/db_name

Here, db_name is the name of the database MongoDB will create automatically if it doesn’t exist.

Update Your Entities

Since MongoDB is document-based, you need to annotate your model classes with @Document instead of JPA’s @Entity.

Update Repositories

Switch your repositories to extend MongoRepository instead of JpaRepository:

public interface ExpenseRepository extends MongoRepository<Expense, ObjectId>

Test Your App

Run your application and add some expenses. Open MongoDB Compass and you should see your data persisted in the expenses collection. Unlike H2, your data won’t disappear when the app restarts.

Conclusion

Switching from H2 to MongoDB was a simple decision that made a huge difference in my application’s growth. Unlike H2, MongoDB is schemaless, which means I don’t have to define rigid table structures upfront. This flexibility allows me to easily evolve my Expense Tracker app as new features are added, without worrying about database migrations.

Another reason I appreciate MongoDB in my Expense Tracker app is for the Reports API. Reports often need flexible structures sometimes aggregating expenses by day, category, or user, and the fields can vary depending on the type of report. In a traditional table-based database like H2, this would require multiple joins or schema changes. With MongoDB’s document based design, I can store dynamic report data easily, making it much more flexible and scalable for real life reporting needs.

MongoDB’s document based structure also makes it great for handling dynamic data, scalable applications, and real-time analytics. Beyond small projects like mine, MongoDB is widely used in building content management systems, IoT applications, e commerce platforms, and data intensive web services.

Looking back, H2 was perfect for prototyping and testing, but for any real life application with growing data and users, MongoDB is the tool that lets your app scale, adapt, and thrive.

H2 Database: Quick Setup for Multi-Table Testing in Spring Boot

Shreeprabha bhat — Mon, 15 Sep 2025 03:24:36 +0000

H2 is a lightweight in memory relational database management system that is commonly used with spring boot for development which greatly supports integration testing.

There are numerous uses of H2 Database that makes it user friendly some of them are:

Great for unit and integration testing:

Every time test suite runs H2 creates a fresh database schema.
It works with @SpringBootTest and @DataJpaTest seamlessly.

Fast and lightweight

Since it is an in memory relational database it is super fast in read/write operation.
No need to install a heavy database server.

Supports both in memory and file mode

By using spring.datasource.url=jdbc:h2:mem:testdb we can make sure the db exists only while the app is up and running.
spring.datasource.url=jdbc:h2:file:./data/testdb. persists the data into a local file.

Easy debugging with web console

H2 comes with a built in web console /h2-console.
It is handy to run SQL queries and check if data is persisted correctly.

How to access web console:

After starting your Spring Boot application, you can access the H2 console by navigating to http://localhost:8080/h2-console in your web browser.

Setting up H2 Database for a spring-boot application:

Add H2 Dependency

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
</dependency>

Based on the application requirement scope of H2 Database can be changed. Most commonly used scopes are compile, runtime and test.

compile :

It's a default scope if you don't specify one.
Dependency is available at compile time, runtime and packaged into your app.

runtime:

Not required during compile time but needed at runtime.
JDBC drivers don't refer them directly in code but they are required during running the app.

test:

Available only during test compilation and execution.

Configure application properties

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.hibernate.ddl-auto=update
spring.h2.console.enabled=true

spring.jpa.hibernate.ddl-auto this property tells hibernate what to do with the database schema each time the application starts.

create-drop: Hibernate will create the schema when the application starts and drops all the tables on shut down. Perfect for testing , but not for real world applications where data has to be retained.
update: Hibernate will update the schema to match entities. It will keep existing data in the table. New data/table will be added to the database but the old data won't be deleted automatically. Good for developing small scale applications but risky in production.

Conclusion:

The H2 database is a powerful tool for quickly testing and prototyping Spring Boot applications. With minimal configuration, it allows you to spin up an in memory or file based database, visualize data through the H2 Console, and run multi table queries just like you would in a production grade database.

Choosing the right spring.jpa.hibernate.ddl-auto option whether update for retaining data across restarts or create-drop for fresh setups can make development smoother and testing faster. By leveraging H2, you can isolate and validate application logic without worrying about external dependencies, making it a must have for both beginners and seasoned Spring developers.

INTRODUCTION TO KAFKA: EVOLUTION AND MESSAGING SYSTEM TYPES

Shreeprabha bhat — Sun, 15 Jun 2025 16:18:24 +0000

Kafka is a message streaming platform that uses publish and subscribe mechanism to stream the records. Kafka was developed by linkedIn which later was donated to apache. It is a open source platform widely used for building real-time data pipelines and streaming applications.

Before the introduction of messaging systems like Kafka, most applications communicated directly in a tightly coupled manner.

The connection was supposed to be built from each source node to destination. This caused rigid and fragile interactions between the source and destination. To overcome these difficulties messaging system was developed which significantly reduced the rigid interactions.

Messaging System:

A messaging system is a middleware component responsible for transferring data between applications. It helps applications exchange information efficiently without getting burdened by the complexities of data transmission, timing, or direct system dependencies. This allows developers to focus on business logic while the messaging system handles reliable data delivery.

Point to point communication

Message persisted in queue.
Message can be consumed by one receiver.
No time dependency laid for the receiver to receive message.
After the message is sent an acknowledgement to sender.

Publish-Subscribe communication

Message persisted in topic.
Message can be consumed by any number of receivers.
Time dependency exist for consumers to consume.
After message is sent no acknowledgement to sender.

Apache Kafka has transformed the way modern systems handle data exchange, moving from tightly coupled, direct communication to a more scalable, decoupled, and resilient messaging approach. Its ability to handle real-time data streams, ensure durability, and support both point-to-point and publish-subscribe patterns makes it a powerful backbone for event-driven architectures.

VIRTUAL FUNCTIONS IN JAVA

Shreeprabha bhat — Sat, 03 Aug 2024 07:22:36 +0000

WHAT ARE VIRTUAL FUNCTIONS?

Virtual functions are member functions that has to be redefined in derived functions. Any function that can not be used for polymorphism can never be a virtual function. Hence a public, final or static function can never be a virtual function.

EXAMPLE:

class Animal{
void sound(){
System.out.println("All animal makes sound");
}
}
class Dog extends Animal{
void sound(){
System.out.println("Dog barks");
}
}
class Main{
public static void main(String[] args){
Animal a=new Dog();
a.sound();
}
}

In the above example the method sound in Animal class is overridden in class Dog to provide specific implementations. In the main method the object 'a' is created using child class Dog. The method call sound() gets resolved at the runtime and the appropriate overridden method in the derived class is executed.

CONCLUSION

All non static methods are virtual functions by default in Java. Method calls on any base type are resolved at run time invoking the overridden methods in the derived classes.

HIGHER ORDER ARRAY METHODS IN JAVASCRIPT

Shreeprabha bhat — Fri, 14 Jun 2024 11:23:50 +0000

WHAT ARE HIGHER ORDER METHODS?

Higher order array methods in javascript are built-in methods that take a function as an argument or return a function as a result.

In Javascript we use many higher order methods that helps in several array manipulation tasks. Few of commonly used array methods are:

forEach()
map()
filter()
reduce()
find()
findIndex()
some()
every()
sort()
flatmap()

In this blog I am going to discuss about the most commonly asked higher order methods that are map(), reduce() and filter().

map()

map() higher order method is used to map through an array and return a new array by performing some operation.

Syntax

map((value)=>{
})
map((value,index)=>{
})
map((value,index,array)=>{
})

Example

let a=[1,2,3,4]
let a1=a.map((value)=>{
console.log(value)
return value+2
})
let a2=a.map((value,index)=>{
console.log(value,index)
return value+2
})
let a3=a.map((value,index,array)=>{
console.log(value,index,array)
return value+2
})

filter()

filter() method is used to filter an array with values that passes the test.

Syntax

filter((value)=>{
})
filter((value,index)=>{
})
filter((value,index,array)=>{
})

Example

let a=[28,96,15,1,3,5]
let a1=a.filter((value)=>{
return value>10
})
console.log(a1)

reduce()

reduce() method is used to reduce an array into a single value. reduce() method usually takes two parameters as an argument.

Syntax

reduce((h1,h2)=>{
})

Example

let a=[1,4,5,3,7]
let a1=a.reduce((h1,h2)=>{
return h1+h2
})

Higher order methods are powerful tools that allow more readable, concise and function-style programming. map(), reduce() and filter() methods are some basic and more important methods which are usually asked in beginners interview.

HOW TO HOST AN APPLICATION USING GITHUB

Shreeprabha bhat — Wed, 05 Jun 2024 14:46:48 +0000

As a beginner I always had the doubt where I can host my application or portfolio freely. With online platform I found out the one of the easiest way to host an application using Github. Today I am going to write about the steps involved in hosting the application using github.

STEP 1: CREATE A REPOSITORY

Login to your github account
Create a repository

Tap on the "New" option on top right corner
Provide Repository name.
Give the description if you wish.
Make your repository public/private based on your choice.
Tap on Create Repository on the bottom right corner.

STEP 2: UPLOAD YOUR APPLICATION FILES

Upload all the files that are involved in your application.
You can refer "https://dev.to/vidyarathna/getting-started-with-github-3a7d" this article from @vidyarathna to upload your files to the github using git.

STEP 3: ENABLE GITHUB PAGES

Open your repository.
Go to settings and open "Pages" option.
Select "main" branch from the dropdown under Branch.
Once you choose the branch save it.

STEP 4: ACCESSING THE APPLICATION

Once you save you the branch you will see a message on the top.
Message on the top contains the URL to your application which will be in the format "https://your-username.github.io/my-app".
You can tap on the "Visit site" on the right side of the URL.
You can visit your application and perform preferred action using this.

You can also select Custom domains to host your applications. You can check Github's documentation for more details. Github's pages site is more suitable for static websites. It is better to use other hosting solutions for dynamic sites.

BEGINNERS COMMAND - GIT

Shreeprabha bhat — Thu, 30 May 2024 09:52:41 +0000

GIT

GIT is a version control system that is designed to handle small to large projects with speed and efficiency. It allows multiple people to work on same project simultaneously without effecting other's code.
GIT is most common skill that recruiters expect in everyone's resume. There are some of the basic commands that must be known to everyone while working with git or attending any technical interview.

MUST KNOW GIT COMMANDS

These commands are used to setup git in your system. Using the commands below one can access the git synchronized with the mail ID.

git config --global user.name "Your name"
git config --global user.email "Your mail"

This command is used initialize a repository in your git. Once the repository is initialized other actions like commit, push or pull can be performed over these repository.

git init

Below command is used to clone an existing repository into your repository.

git clone <repository_url>

The command below is used to get the status of repository.

git status

Stage the changes for commit.

git add <file_name> 
# Command stages the changes in that particular file
git add .
#Command stages the entire changes.

Commit changes to the repository

git commit -m "Your message"

View the history of commits in the repositiory

git log

Creating a new branch.

git branch <branch_name>

Switch to a new branch

git checkout <branch_name>

Create and switch to a new branch

git checkout -b <branch_name>

Merge a branch to the new branch

git merge <branch_name>

Know which branch you are working in.

git branch

Add a repository to the remote repositiory

git remote add origin <repository_url>

Fetch changes from the remote repository

git fetch

Push changes to the remote repositiory

git push origin <branch_name>

Pull changes from the remote repository

git pull

List remote repositories

git remote -v

Stash the changes when your are not ready to commit them.

git stash

Apply the stashes to the desired branch

git stash apply

EVERYTHING TO KNOW ABOUT MVC ARCHITECTURE

Shreeprabha bhat — Wed, 29 May 2024 07:42:11 +0000

WHAT IS MVC ARCHITECTURE?

MVC Architecture is a popular development technique where the User Interface, Data storage and the logic are divided into separate components. Using MVC architecture developers can work independently on each component without effecting the other.
MVC stands for Model View Controller architecture where the model contains the entire logic and data, view handles the user interface and controllers handles the data manipulation and acts as an intermediary between model and view.

Let's see what are the purposes and responsibilities involved within MVC architecture.

MODEL
Main responsibility of Model is to represent the data and logic of the application.

It maintains all the queries by user.
Handles request from and to the database.
Maintains the state of the application.
Handles business logic

VIEW
View is nothing but the user interface that is visible to the user upon logging into the system.

Provides a way for user to interact with the application using the features available in the UI.
Updates the UI along with the changes happening in the Model.

CONTROLLER
It acts as an intermediary between view and model. Any data that has to be changed in the model is passed by the user in the view later interpreted by the controller and sent to the model.

Interpret user inputs
Updates the model.
Reflects the changes in the model to the view.

WORKFLOW

User interaction - User sees the view and might update a value or make a request to retrieve some random value from db.

Controller Handling- These changes by the view is passed on to the model through the controllers.

Model Update- Requested values from the DB are retrieved in the model.

View Changes -Later the view gets updated with these modified changes.

ADVANTAGES

MVC architecture helps in the separation of each components, which will help the developers to work on each component independently without affecting the other.
It contributes in the easy maintainability of the application.
Components can be reused across different paths of the application.
Developers can work on different component simultaneously with the help of separation of each component.

MUST KNOW LINUX COMMANDS FOR BEGINNERS

Shreeprabha bhat — Tue, 28 May 2024 07:45:29 +0000

It's common for web developers and software development aspirants to work on linux operating system. Compared to other operating systems linux is versatile and open source operating system. Understanding liux has become crucial for tech enthusiasts, system administrators and also fresh graduates who are looking forward for their career in tech market.
Let's know more about some of the most commonly used commands which are frequently asked in the interviews as well.

1. cd path/to/directory -Changes the current directory

This is the most commonly used command in the linux operating system. Whenever user want to navigate to a new folder he/she can make use of this command.
Options available:
cd .. :Comes out from the current folder
cd :Moves back to the home directory

2. ls -List files

This command is used to know about the list of files that are present in the current working folder.
Options available:
ls -l :Long listing format
ls -a :Lists hidden files

3. pwd -Present working directory

This command is used to display the current working folder.

4. mkdir directory_name -Make directory

This command is used whenever user want to create a new folder.

5. rmdir directory_name -Remove director

Above command is used whenever user wants to remove a folder that is empty.

6. rm fil_name -Removes a file

Above command is used whenever user wants to remove specific file from a directory. Along with options the command can also be used to remove directories.
Options available:
rm -r directory_name :Removes a directory along with all its files and other contents.

7. cp source_file destination_file -Copy file contents

This command is used whenever user wants to copy the contents of one file to another. Here the contents present in source_file will be copied to destination_file.
Options available:
cp -r source_directory destination_directory : Functions similar to file copying but here the entire contents of source_directory will be copied to destination_directory.

8. mv old_name new_name -Moves or renames a file

Above command is used whenever user wants to rename a file, here the file with old_name will be renamed to new_name.

9. cat file_name -Concatenate file

Using the above command user can view the contents of file_ name over the console.

10. head file_name

Using the above command user can just view the first ten lines present in the file.
Options available:
head -n 5 file_name -User can view only first five lines of file. Using this option user can vary the number of lines visible

11. tail file_name

Similar to head command here we can view the last ten lines present in the file.
Options available:
tail -n 5 file_name -To view the last five lines instead of default ten.

12. ps

Using this command one can know about the processes that are currently being run in the system. It displays the processes with their PID.

13. kill pid

We can use this command whenever we want to stop a process that is running in the system. PID required can be acquired from the ps command.

14. whoami

Using this command one can know about the user of the system.

15. uname -a

This command displays the user name along with the system information.

CONCLUSION
There are huge set of commands being used while working with linux operating systems. The commands explained here are the basic set and mainly asked in the interviews of entry level candidates.

SOFTWARE DEVELOPMENT LIFE CYCLE

Shreeprabha bhat — Mon, 27 May 2024 10:49:01 +0000

WHAT IS SDLC?

SDLC stands for Software Development Life Cycle and it is a structural procedure to design, develop and test a software application.

GOAL OF SDLC

The main goal of SDLC is to make sure the developed software product is well structured and produces a product that meets client requirements.
There are several steps involved in this procedure to make it possible.

STEPS INVOLVED IN SDLC

Requirement Analysis
Defining the requirements
Designing
Development
Testing
Deployment
Maintenance

REQUIREMENT ANALYSIS

The first step of SDLC is requirement analysis. Generally in this step the Product team has to get the overview of the product and the requirements from the client to develop the software product.

DEFINING THE REQUIREMENTS

Requirements collected from the clients has to be given a proper shape so that it can be easily understand by the developer to plan a proper software architecture.

DESIGNING

Once the requirements are given a proper shape the developer has to analyze these requirements and has to plan a proper design for the software product that has to be developed.

DEVELOPMENT

Software product can be developed by analyzing the design which is designed on the basis of requirements that is specified by the client.

TESTING

Then comes the testing phase where the testing team has to test the product developed against the client requirements. Defects noted in this step will further go through the Defect Life Cycle. Tester has to make report of these defects found in testing and pass it to the developer so that product can undergo for further perfection.

DEPLOYMENT

Once the product is made to sure to meet client requirements it can be deployed for client use.

MAINTENANCE

Here comes the last step involved in SDLC that is maintenance. Once the product is deployed for client use it has to maintained well for it's proper use and efficiency. Poor maintenance will always lead to non efficient product which might leave a negative impact from users.

SUMMARY

A well planned and structured SDLC will always lead to a successfull and user efficient product deployment. It plays a major role in any organization for its growth and success.

Understanding the basics of Docker

Shreeprabha bhat — Fri, 24 May 2024 11:13:30 +0000

While working as a QA I had close interaction with the developers and heard them saying several times about docker and docker images. I even had a discussion with my friend once what docker actually is. And finally when I became a developer myself I got to work with docker and made me know about the basic insights of docker. Today, I am going to share the basic knowledge I gained about docker here.

WHAT IS DOCKER?

Docker is a tool that allows developers to build and deploy their applications easily to the containers to run on host that is linux.
Docker helps to package an app with all its dependencies into standard unit that would benefit software development.

WHAT IS CONTAINERS?

Containers are nothing but the logical mechanism for packaging the application. Several times the application would collapse because of the different versions used on different system. By using containers one can make sure there won't be any service compatibility issue. This would drastically decrease the developer's problem of "It works on my system".

WHAT IS IMAGES?

Docker images are nothing but the read only templates that contains instructions to create containers. They serve as a foundation for containers and encapsulate all the dependencies and configuration needed for an application. Images can either be built from dockerfile or pulled from docker hub.

USING DOCKER

https://docs.docker.com/engine/install/ you can follow up the instructions here to install docker. Once you have installed docker you can check the installation running docker --version.

COMMONLY USED DOCKER COMMANDS AND THEIR USES

docker ps
# Lists the current running containers
docker ps -a
# Lists all the containers including the one that stopped.
docker run -d --name <container-name> <image-name>:<tag>
# Runs a container that is specified
docker stop <container-id>
# Stops a container
docker start <container-id>
# Starts a container that was stopped
docker rm <container-id>
#Removes a container
docker image
# Lists the images

SUMMARY

Docker is a powerful platform that simplifies the development, deployment and management of applications by using containerization.
Docker’s ecosystem, including Docker Compose and Docker Hub, further enhances its capabilities for managing complex, multi-container applications and sharing containerized applications with others.

RAKE IN RUBY

Shreeprabha bhat — Wed, 22 May 2024 16:57:25 +0000

I had been working on ruby on rails from past few days and I had come across few commands like rake -T, rake db:migrate etc, but had never wondered what rake actually is. This made me to dig this topic and am sharing the little much knowledge I gained here today.

WHAT IS RAKE?
It is a tool in ruby that allows to run tasks, migrate database, test executions and some other repetitive tasks. Rake stands for "Ruby Make" and it is specially designed for ruby projects.

HOW DOES RAKE WORK?
Lets consider a example where a person tries to message and call another person.

task :message do
    puts "Hey!! What's up!"
end

task :call do
    puts "Hey! Its been long since we met so thought of calling you!"
end

We can run the above tasks using the below rake command

$rake message
#Output: Hey!! What's up!
$rake call
#Output: Hey! Its been long since we met so thought of calling you!

Rake tasks can also be dependent on other rake tasks they can also have parameters passed to them. Wondering how? Below is an example.

Consider an example where a student has exam. Writing an exam involves several sub tasks in them maybe from preparing a time table to waiting for the results it's a series of steps. So how can we sum up these sub tasks using rake tasks. Lets explore.

task :timetable do
     puts "Prepare timetable"
end

task :study=>timetable do
     puts "Study according to timetable"
end

task :exam=>study do
     puts "Write what you studied"
end

task :result=>[:timetable, :study, :exam]

In this example running 'rake result' will run 'timetable' first later 'study' and then 'exam'.

We can also create custom rake tasks using namespace.

namespace :exam do
    desc "Give exam"
    task :write do
         puts "Write exam"
    end
end

We can run the above rake task using 'rake exam:write'.

RAILS SPECIFIC RAKE TASKS
Below are some commonly used rails specific rake commands.
rake -T Used do list rake tasks
rake db:migrate Apply database migrations
rake test Run the test suite
rake db:seed Populate database with initial data.
rake -t Debugging mode

CONCLUSION
Rake integrates seamlessly with rails and makes it a powerful tool that can handle the development perfectly. From running test cases to migrating database rake supports a smooth workflow.