An aging stack that held back development and security
A mature, modular monolith running the client's full range of services was under continuous development, but its technological foundation had aged and started to constrain the business.
An unsupported stack
Java 8 and an old version of Spring Boot were out of support — a growing security risk with no patches for known vulnerabilities.
A brake on development
Adding a new feature or a modern library was hard or impossible, and critical operations — like bulk label generation — ran too slowly.
A high barrier to entry
Onboarding a new developer was long and costly — running the project required knowledge scattered across the team and familiarity with the whole domain.
From an aging monolith to an organized, supported system
We worked in stages, without freezing product development — solo at first, later with a team we led.
Stack migration and dependency cleanup
We migrated Java 8 → 17 and Spring Boot 1 → 3 along with upgrading the remaining libraries, removed unnecessary dependencies, and unified versions across the whole system.
Performance optimization
We fixed the data-access layer — the SQL queries and the use of Spring Data and Hibernate — which cut generating 10k labels from ~45 to ~10 minutes. We also optimized a related module.
Standardization and CI/CD on GitLab
We developed one shared process and migrated all modules and applications onto it: unit and E2E tests on every MR and on the main branch, security scans (OWASP), image build with a version tag → Nexus → deployment to environments (staging/production).
Simplification and fast onboarding
We simplified running the project so a new developer can set up the IDE and test environment in a single working day — without first having to learn the entire domain.
What we found under the hood
Before starting the modernization, we mapped the actual technical state of the system and its delivery process.
An inefficient data layer
Poor SQL queries and suboptimal use of Spring Data and Hibernate — including dynamic queries instead of static ones and badly chosen collection types — slowed down critical operations.
A fragmented deployment process
Some deployments went through Jenkins, some through GitLab, and some were done manually — by running docker-compose on the servers. There was no single, repeatable process.
No observability for the team
Logs were stored locally on the servers and monitoring was in practice available only to the administrator — developers had no insight into how the application behaved.
Debt in the dependencies
Outdated and unnecessary libraries and inconsistent versions across modules raised the risk and cost of further development.
A supported stack, faster operations, and repeatable deployments
A modern, supported stack
Java 17 and Spring Boot 3 with organized, slimmed-down dependencies and automated security scans in CI — back to regular patches and lower risk.
Faster critical operations
Generating 10k labels cut from ~45 to ~10 minutes (−78%), with optimization that also covered a related module.
One repeatable deployment process
A shared GitLab CI pipeline for all modules and applications — with tests, security scans, versioned images, and deployment to environments instead of manual steps.
One-day onboarding
After simplifying the project, a new developer spins up the IDE and test environment in a single working day — onboarding is no longer a bottleneck.
From an aging, hard-to-maintain monolith, the client gained a system on a supported stack, with a single repeatable deployment process and faster critical operations — ready for further, calmer development.
How we can help in a similar situation
Technical Debt Reduction
Modernizing an aging stack and paying down technical debt so further development is faster, cheaper, and safer.
Performance Profiling
Finding and removing bottlenecks — from database queries to the application layer — based on measurements, not guesswork.
CI/CD Automation
One repeatable deployment process with tests and security scans instead of manual, fragmented steps.
“What convinced us most was the concrete result: an operation that used to take tens of minutes was cut several times over after optimization. On top of that, one organized deployment process and a new developer ready to work in a single day. I'd recommend working with them to anyone facing technical debt in a mature system.”CTO · postal-logistics & e-commerce operator
Is technical debt holding your system back?
We'll modernize the stack, speed up critical operations, and organize deployments — without stopping the business. Let's start with a free consultation.
Book a diagnostic call