A Banking Backend You Can Actually Run Locally: Spring Boot Microservices with Docker Compose

You've probably read a dozen tutorials about microservices architecture that stop right before the hard part. Great diagrams, clean code snippets, and then nothing you can actually run. The internet-banking-concept-microservices project from javatodev.com takes the opposite approach—it's a full internet banking backend built with Spring Boot microservices, and it ships with a Docker Compose setup that spins the whole thing up on your machine.

What It Does

This is a reference implementation of an internet banking API built on a Spring Boot microservices architecture. The project started as a tutorial series on javatodev.com, and what you get here is the working source code behind it. It includes six main services: a user service handling registrations and profile retrieval (and talking to Keycloak's REST API for user management), a fund transfer service, a utility payment service, a notification service (still pending development), a banking core service acting as a dummy core banking system, plus the supporting infrastructure—a config server, a service registry, and an API gateway.

The stack is what you'd expect from a modern Spring project. Version 2.0.0 runs on Java 21, Spring Boot 3.2.4, and Spring Cloud 2023.0.0. There's a Keycloak instance for authentication backed by PostgreSQL, MySQL for the banking application database, OpenZipkin for distributed tracing, and RabbitMQ for messaging between services. Everything is wired together with Docker Compose, so you're not manually configuring service discovery or gateway routing yourself.

Why It's Cool

• It's a runnable system, not a snippet collection. The README gives you three commands and a container table. You clone, cd into the docker-compose folder, run docker-compose up -d, and you have eleven containers talking to each other on a defined network. That's a meaningful difference from most architecture tutorials, where the "how do I actually see this work" question goes unanswered.

• The service breakdown mirrors real banking concerns. User management, fund transfers, utility payments, and a core banking layer are separated into distinct services. The fund transfer and payment services both push messages to a centralized RabbitMQ queue for the notification service to consume. This is the kind of event-driven pattern you'd actually see in production systems, and it's worth studying in a small, comprehensible codebase before you encounter it in a large one.

• Authentication is handled realistically. Keycloak is deployed with a default dataset matched to the application—realms, clients, and users are pre-configured. You don't have to spend an afternoon setting up an identity provider just to test an API call. The README even gives you test credentials ([email protected] / 5V7huE3G86uB) and points you to an authentication request in the Postman collection to get started.

• The IP and port table is a small but genuinely useful touch. Every container's IP and port mapping is documented—from the API gateway on 8082 down to the core banking service on 8092. When you're debugging why service A can't reach service B, having this table saves you from running docker inspect on every container.

• Dummy data is included out of the box. The core banking database ships with dummy accounts and user details, so you can test fund transfers and payment flows immediately rather than seeding your own data first.

• The Postman collection syncs the whole suite. There's a shared collection URL, and you switch to the LOCAL_DOCKER_SETUP environment to match the Compose setup. It's a small detail that removes friction from poking at the API.

How to Try It

Getting started takes three steps, assuming you have Docker and Docker Compose installed:

1. Clone the repository:

   $ git clone https://github.com/JavatoDev-com/internet-banking-concept-microservices.git
   

2. Navigate to the docker-compose folder:

   $ cd internet-banking-concept-microservices/docker-compose
   

3. Start the application:

   $ docker-compose up -d
   

Once the containers are up, import the Postman collection from the link in the README and switch to the LOCAL_DOCKER_SETUP environment. Authenticate using the test credentials, then explore the endpoints under the BANKING_CORE_MICROSERVICES collection. The full repository is at github.com/JavatoDev-com/internet-banking-concept-microservices.

Final Thoughts

This is best suited for developers learning microservices patterns in the Spring ecosystem—people who've read the theory and want a working system to poke at, break, and extend. The notification service is still marked as pending development, so it's not a finished product, and the project is explicitly a concept rather than something you'd deploy to production. But as a learning scaffold, it's about as complete as these things get: real authentication, real messaging, real service discovery, all startable with one command. If you've been looking for a microservices example that respects your time, this one is worth cloning.