Working with Java?

Java app stuck on 8, leaking or breaking? We fix it.

Most Java systems that reach us are running on a version that stopped getting free Oracle updates years ago, with a Maven file nobody has touched since the original author left. We find the real cause of the slow startup, the heap error or the failing upgrade, and we fix that first.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

application.log

still failing

What it is

Java at a glance

Java is a statically typed language created by James Gosling at Sun Microsystems and first released in 1995. Programs compile to bytecode that runs on the Java Virtual Machine, which is the piece that makes the compile-once, run-anywhere promise actually hold up in practice.

Oracle maintains the reference OpenJDK and sells a paid Java SE subscription on top of it. Free distributions include Adoptium Temurin, Amazon Corretto, Azul Zulu, the Microsoft Build of OpenJDK, and Eclipse Temurin. The long-term support releases people actually run are 8, 11, 17 and 21, with 8 now past Oracle's free public updates.

Java is the quiet workhorse of large organisations. It is everywhere in banking, insurance, telco, retail and government, usually in back-end systems that have been running for ten or fifteen years and need to keep running for another ten.

Type
Statically typed, JVM language
First released
1995
License
GPL v2 with Classpath Exception for OpenJDK
Maintained by
Oracle plus OpenJDK contributors
Typically used for
Enterprise back ends, Android (Kotlin-first now), big-data tooling (Spark, Kafka), banking and insurance systems

The honest version

Java pros and cons

No technology is all upside. This is where Java earns its place and where it tends to cause trouble.

Where Java is strong

  • Industrial-grade runtimeThe JVM has been in production for thirty years. Profilers like JFR, Mission Control and async-profiler tell you exactly where a slow service is spending its time.
  • Backwards compatibility you can lean onCode written for an older Java release usually still compiles and runs on a newer one. That is why so much Java from the 2000s is still earning its keep.
  • A huge, mature ecosystemSpring, Hibernate, Maven and Gradle cover almost every back-end problem a business has. You rarely need to invent the wheel from first principles.
  • Modern Java is pleasant againJava 17 and 21 brought records, sealed classes, pattern matching and virtual threads. Writing a new service no longer feels like 2008.
  • Long LTS cyclesThe 8, 11, 17 and 21 releases each get years of security updates. You can plan upgrades on a realistic timeline instead of chasing the newest release every six months.

Where Java bites

  • Java 8 is everywhere and overdueEnormous amounts of production code still run on Java 8, which stopped getting free Oracle public updates in March 2022. Staying there means paying Oracle or accepting unpatched risk.
  • Distribution confusionOracle JDK, OpenJDK, Temurin, Corretto, Zulu, Microsoft Build. Teams end up with different JDKs on their laptops and on production, which quietly causes trouble.
  • The javax to jakarta rename broke a lotJakarta EE 9 renamed the javax namespace to jakarta, and Spring Boot 3 requires Java 17 plus jakarta. Many libraries did not update cleanly, and projects stall mid-upgrade.
  • Old projects accumulate CVEsAnt and older Maven builds pull in dependencies that nobody has refreshed in years. Log4Shell was one famous example, but the problem is constant and quiet.
  • Heavy footprint by defaultTraditional Java services take seconds to start and hold on to a lot of memory. Virtual threads and GraalVM native image help, but neither is a drop-in for every workload.
  • Serialization keeps surfacingJava's built-in serialization has produced a steady stream of remote code execution CVEs over the years. It still turns up in old code where it should not.

Sound familiar?

Common Java problems we fix

The Java problems that bring people to us, and what you have once each one is fixed.

Java 8 · public updates ended March 2022

The app is still on Java 8 and the client wants 17 or 21

Old Spring, old Hibernate, javax imports everywhere, and a Maven file that half-works. Upgrading needs the dependencies refreshed in the right order, not a single flag change.

Running on current Java, tests green

java.lang.OutOfMemoryError: Java heap space

Production keeps running out of heap

A slow leak, an oversized cache, or a query loading more rows than anyone intended. The heap dump tells the story if someone reads it.

Leak found, heap sized to real load

GC pause: 4.2s

Long garbage collection pauses

ParallelGC on a large heap, or G1 with defaults that never got tuned. Users see the app freeze for seconds at a time.

GC tuned, pauses under budget

UnsupportedClassVersionError

A class was compiled against a newer JDK

Mixed JDK versions in CI, or a dependency that quietly moved to Java 17. The server still runs Java 8 and refuses to load it.

Build and runtime on the same JDK

javax.* not found

The jakarta migration stalled halfway

Some libraries moved to jakarta, some did not, and the build fails on imports from both namespaces. Spring Boot 3 insists on jakarta.

One namespace throughout, builds clean

CVE-2021-44228 (log4j)

The security team found exploitable dependencies

Log4Shell or one of its relatives, Jackson gadgets, or old commons-collections. The fix is a coordinated dependency bump, not a one-line patch.

CVEs cleared, upgrades documented

startup: 94s

The service takes too long to start

Hundreds of Spring beans, classpath scanning on every start, and a fat uber-jar. Rolling deploys take an hour because every pod waits on startup.

Startup trimmed, deploys quick

previous team: unreachable

A Java app was handed over with no documentation

No README, no runbook, build only works on one laptop, and the original developer has moved on. Nobody is sure what the service even does.

Build reproducible, owners named

What we do

Java help, from rescue to upkeep

Ring us for one tricky JVM problem, or let us manage the runtime and dependencies on an ongoing basis.

Version upgrades
Java 8 to 17 or 21, including Spring Boot 2 to 3 and the javax to jakarta rename, rehearsed on a branch first.
Performance and memory
Heap sizing, GC tuning, JFR and async-profiler work, with numbers before and after.
Security and CVEs
Dependency audits, log4j and serialization cleanup, and a plan for keeping on top of them.
Legacy takeovers
Older Spring, Struts, JSF and plain servlet apps. We document what they do and get the build reproducible.
Build modernisation
Ant to Maven, Maven to Gradle where it earns its keep, reproducible builds and sensible CI.
Managed Tech
Monitoring, patching, dependency updates and a team to call, on an ongoing basis.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Java alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Java questions

Something else? Call+1 737 727 7327

Can you upgrade our Java 8 application to Java 17 or 21?

Yes, and it is one of the jobs we do most often. The language step is usually the easy part. The real work is refreshing Spring, Hibernate and the dependency tree, dealing with the javax to jakarta rename if you are going to Spring Boot 3, and running your tests on each hop. We normally go 8 to 11 to 17 on a branch, with CI green at each stop, before touching production.

Can you take over a Java enterprise app from a previous team?

Yes. We get the build reproducible on our machines first, write down what the application actually does, and only then start changing things. Most handovers we see are missing a working README and a deploy runbook, and that is where we start.

How do we migrate from javax to jakarta?

In practice it is a package rename across the whole codebase and every dependency that touches servlet, JPA, JMS or validation. Spring Boot 3, Tomcat 10 and Jakarta EE 9 or later all require jakarta. Tools like OpenRewrite handle most of the mechanical rename, but libraries that have not released a jakarta build still need replacing by hand.

Should we move our Java app to GraalVM native image?

Sometimes. Native image gives fast startup and a small memory footprint, which is useful for serverless and short-lived workloads. It also rules out some reflection-heavy libraries and adds build complexity. For a long-running server with virtual threads on Java 21, plain OpenJDK is usually the better answer.

Why is our Java application hitting OutOfMemoryError in production?

It is almost always one of three things: a genuine leak where a collection or cache holds on to objects forever, a heap sized smaller than the real working set, or a query that loads far more rows than anyone expected. A heap dump at the moment of failure usually points straight at the cause.

How much does Java help cost?

Estimates are free. Tell us the Java version, the framework and what is going wrong, and you get a price before any work begins.

Free estimate

Java application giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.