Hiring a Java Developer to Keep an Older System Running and Move It Forward
Most Java work that reaches us isn't a new app. It's a system the company has relied on for years, built on a Java version, framework and app server that were current when it was written. The first useful thing a Java developer does is find out exactly where it stands, because that decides whether you're looking at an afternoon of library updates or a planned migration.
The Java it runs on: on the server, run this and note the version and the vendor line (Oracle, Temurin, Corretto and so on).
java -versionThe Java it's built for: in a Maven project, look in pom.xml for maven.compiler.release or java.version. In Gradle, look in build.gradle for the toolchain or sourceCompatibility.
The framework generation: search the code for imports starting with javax.servlet or javax.persistence. If they're there, the app predates Spring Boot 3 and Jakarta EE 9, and the package rename is part of any upgrade.
What your Java version means for the upgrade
Long-term support (LTS) releases are the ones businesses run. Skipping straight to the newest works for some apps, but the jumps below are where the work hides.
Moving an old Java system forward without a rewrite
The order matters more than the speed. Each step leaves the app in a state you could ship.
- 1
Get it building on a clean machine
Before changing anything, build the app from source somewhere other than the original developer's laptop or the production server. Missing jars, local settings and undocumented build steps all surface here.
Watch for: a build that only works because of files sitting on one server.
- 2
Pin down what it does today
Write tests around the flows that matter to the business: placing an order, the nightly export, the invoice run. Old systems rarely have them, and they're what tells you the upgrade changed nothing it shouldn't have.
- 3
Find what will break before you switch
jdeps --jdk-internalsRun jdeps with the JDK-internals check against the build to list code that reaches into parts of the JDK that newer versions lock down. Check each library for a release that supports the target version.
- 4
Update libraries on the Java you have
Bring dependencies up to versions that run on both the old and the new Java, and ship that. Then the Java switch itself is a small change you can roll back.
Watch for: logging libraries. An old Log4j 1.x or an unpatched 2.x is a security finding in its own right.
- 5
Move one LTS release, and the framework with it
Switch the JDK, then do the Spring Boot 3 move and its javax-to-jakarta rename, ideally with OpenRewrite's migration recipes rather than by hand. Run the tests after each.
- 6
Run old and new side by side
Put the upgraded app beside the old one, or in front of a slice of traffic, and compare. Keep the old version ready to switch back to until the new one has run a full business cycle, month-end included.
Your Java system, current again and still doing its job
n-frames takes over Java systems whose original developers have moved on, gets them building again and moves them to a supported Java and Spring version in the order above. If the app also has to connect to newer tools, an API for a portal or a sync to your CRM, we scope that alongside the upgrade.
Estimate my Java upgrade →Questions people ask
Can you take over an existing Java system, or do you only build new ones?
Both, and taking over is most of our Java work. We start by getting the code to build away from its old server and mapping what it talks to: databases, file drops, other services. Changes come after that, not before.
What if the real issue is performance under load, not a missing feature?
Then we measure before touching code: thread dumps, garbage collection logs and the slowest database queries usually point to the cause. Connection pools sized for a smaller business and queries that grew with the data are common culprits. Upgrading Java alone rarely fixes a slow system, though a newer JVM's garbage collectors can help. When the slowdown or the errors only show up under heavy traffic, we also look for thread-safety problems: shared state that two requests change at once, or a lock that every request queues behind.
Is an agency really worth it over a cheaper Java freelancer?
For a one-off utility, maybe not. For a system the business runs on, the risk is the same one that left you with an unmaintained app in the first place: one person who understood it. With n-frames, more than one developer knows your system, and the build and upgrade steps are written down. Compare quotes on the whole upgrade plan, not the hourly rate.
Do we have to pay Oracle to keep running Java?
Not necessarily. Oracle prices its Java SE subscription per employee across the whole company, which surprises a lot of businesses. Free OpenJDK builds such as Eclipse Temurin and Amazon Corretto run the same code. Moving to one is usually simple, but check your existing Oracle agreements before you switch.
Is there a catch to the free quote?
No. We ask for read access to the code, or a call with whoever knows the system, and come back with what you're running, the upgrade steps it needs and a price for each. If it's only a few library updates, the quote says that.
Is Java still worth learning for a developer job?
Yes. A lot of business software runs on Java and Spring, and much of the paid work is keeping those systems current. Learn modern Java (17 or later), Spring Boot and SQL, then practice reading and upgrading someone else's older project. Many employers value that skill more than another new app.