Ankur

Posted on Sep 23

How I Built a Banking System Backend with Java, Spring Boot, JWT, Docker and GitHub Actions

#springboot #java #docker #backend

Introduction

Start with why you built it:

Most of my earlier Java projects focused on learning individual concepts. For this project, I wanted to put those concepts together into something closer to a real backend system.

I built a banking management system using Java and Spring Boot, with authentication, authorization, transaction processing, database migrations, automated testing, Docker, and CI/CD.

The goal wasn't to build an actual production banking platform, but to practice the engineering patterns and infrastructure involved in building a production-style backend.

This is a much better opening than simply listing your technologies.

What I built

Show the architecture:

Client
↓
REST Controllers
↓
DTOs + Validation
↓
Services
↓
Repositories
↓
MySQL

Then explain the supporting infrastructure:

Spring Security + JWT
↓
Authentication / Authorization

Flyway
↓
Database migrations

Docker
↓
Application container

GitHub Actions
↓
CI/CD

GHCR
↓
Container registry

Tech stack

Use a table:

Technology Purpose
Java 21 Backend language
Spring Boot Application framework
Spring Security Authentication & authorization
JWT Stateless authentication
MySQL Relational database
JPA/Hibernate Persistence
Flyway Database migrations
JUnit/Mockito/MockMvc Testing
Docker Containerization
Docker Compose Local multi-container environment
GitHub Actions CI/CD
GHCR Container registry
Springdoc OpenAPI API documentation
Actuator Monitoring

User & account management

Explain the actual functionality:

User
├── Create
├── Retrieve
├── Update
├── Delete
└── Change password

User
│
└── Accounts
├── Account number
├── Account type
└── Balance

Don't over-explain basic CRUD. Spend more article space on the interesting engineering decisions.

JWT authentication

This deserves its own section.

Explain:

Login
↓
Validate credentials
↓
Generate JWT
↓
Client stores token
↓
Authorization: Bearer
↓
JWTAuthenticationFilter
↓
Validate token
↓
Authenticate request

Then explain why you chose stateless authentication.

You can include a Swagger screenshot here.

Transaction system

This should be one of the main sections.

Explain:

Deposit
Account balance
↓
Add amount
↓
Save new balance
↓
Create transaction record
Withdrawal
Account balance
↓
Check sufficient funds
↓
Subtract amount
↓
Save new balance
↓
Create transaction record
Transfer
Source account
↓
Validate ownership
↓
Check balance
↓
Debit source
↓
Credit destination
↓
Record transactions

Then talk about the concurrency problem.

That's much more interesting to a developer reading your article than "I created a POST endpoint."

Preventing double spending

I'd make this a dedicated section:

Handling concurrent transactions

Explain the problem:

Balance = ₹1000

Request A → reads ₹1000
Request B → reads ₹1000

A withdraws ₹800
B withdraws ₹800

Without proper concurrency handling:
₹1600 could potentially be withdrawn from ₹1000.

Then explain the mechanism you implemented.

This is probably one of the strongest technical parts of your project, so don't bury it.

Database migrations with Flyway

Show:

V1
↓
users

V2
↓
accounts

V3
↓
transactions

Explain why migrations are preferable to relying on Hibernate automatically changing the production schema.

Testing

Talk about the breadth of your tests.

For example:

Service tests
Controller tests
Repository tests
JWT tests
Security tests
Authentication tests
Validation tests
Exception handling tests
Transaction tests

Then show your GitHub Actions result.

You can say:

The project currently has 100+ automated tests, which are executed as part of the CI pipeline.

Docker

Explain your setup:

Docker Compose
│
├── banking-api
│ └── Spring Boot
│
└── banking-mysql
└── MySQL

Then explain why you removed the dependency on locally installed application configuration and moved credentials to environment variables.

CI/CD

This should be another strong section.

Show your actual pipeline:

Git Push
↓
GitHub Actions
↓
Start MySQL
↓
Run Tests
↓
Build Application
↓
Build Docker Image
↓
Publish to GHCR

Then include your GitHub Actions screenshot.

This demonstrates that your CI/CD actually works.

GitHub Container Registry

Show the GHCR screenshot.

Explain:

docker pull ghcr.io/ankur400web/banking-system:main

And explain that the container image is automatically published after the CI pipeline succeeds.

What I learned

This is where you can get personal.

Something like:

The biggest thing I learned from this project was that backend development isn't just about writing controllers and connecting a database.

A real backend involves authentication, authorization, validation, database consistency, concurrency, testing, configuration management, logging, containerization, and deployment pipelines.

Each feature introduced another engineering problem that I had to understand rather than simply implement.

That would make a strong ending.