A business-critical application already runs on Java, integrates with several enterprise systems and carries years of behaviour that is poorly documented. The immediate request may be an upgrade, a new API or relief from rising infrastructure cost. Whether Java is modern enough matters less than whether the organisation should renew its JVM platform, contain it behind stable interfaces or move specific responsibilities elsewhere.
Java remains a sound foundation for long-lived services when its runtime, framework and dependency estate are kept current. Its maturity is an advantage only if the team uses the platform’s diagnostics and compatibility discipline instead of treating an old deployment as untouchable.
Java is a platform commitment before it is a language choice
Production Java includes a JDK distribution, release line, framework, build system, dependency graph, garbage collector, container or host settings and operational tooling. Two applications written in the same language can carry very different support and licensing obligations.
We record that platform as part of the application: exact build tool and plugin versions, target Java release, runtime provider, framework line and deployment settings. A build that succeeds on one developer’s workstation but selects a different compiler or transitive library in CI is not repeatable.
This wider decision is where Java often earns its cost. A team with established JVM operations, vendor integrations and engineers who can interpret runtime evidence can support a Java service for a long time. Adding that platform for a small isolated feature may be harder to justify.
The JDK distribution and support route belong in the decision
An LTS label does not identify who supplies the binaries, which licence applies to production use, how long updates are available or who will respond to a runtime defect. Those answers vary between distributions and commercial arrangements.
We choose and document a JDK provider, permitted usage, update source and replacement date. The application should expose its runtime version in deployment inventory so unsupported instances can be found. Container images do not solve this by default; an old JDK inside an immutable image remains old.
The upgrade calendar needs to account for framework and build-tool compatibility as well as the runtime. Waiting until security support ends turns a routine platform update into a project with a deadline.
Spring conventions can contain complexity or spread it
Spring Boot can provide a coherent application boundary for configuration, HTTP endpoints, persistence, security and health. It can also make too much behaviour implicit when annotations, auto-configuration and global context are used without clear module boundaries.
We keep domain rules in ordinary Java where possible and use framework code at the edges. Configuration values are typed and validated at startup. Integration tests cover security filters, serialisation, database transactions and any conditional configuration that changes between environments.
A framework upgrade is easier when business behaviour is not coupled to internal extension points. Custom starters, reflection-heavy libraries and copied configuration from old examples deserve scrutiny because they can hold back the whole platform.
Object-relational mapping still generates database work
JPA and Hibernate make persistence convenient, but object navigation can conceal query count, join shape and transaction boundaries. Lazy association access can turn one endpoint into many database round trips. Cascades can write more data than a code review suggests.
We inspect generated SQL and query plans for important paths, then test with realistic relationship depth and row counts. Fetch joins, entity graphs and projections each suit different shapes; no single eager-loading setting fixes every case. The database schema, constraints and indexes remain owned through SQL, even when migrations and queries originate in Java.
Transaction boundaries should align with a business operation. Extending a transaction through remote calls or view serialisation increases lock time and makes partial failure harder to reason about.
Virtual threads change concurrency economics, not capacity limits
Virtual threads make a thread-per-task style practical for many blocking I/O workloads. They reduce the cost of waiting threads; they do not increase database connections, downstream API quotas, CPU or memory.
Adoption starts with a representative load test and the exact runtime and libraries intended for production. We bound calls to scarce dependencies and propagate deadlines. Native calls and older runtime behaviour can affect how virtual threads release their carrier, so JDK version and diagnostics matter.
For CPU-heavy work, adding more virtual threads can create contention without more throughput. The concurrency model must follow the bottleneck rather than a language feature announcement.
The JVM should be observable before an incident
Java Flight Recorder can capture runtime events including allocation, garbage collection, locks, threads and I/O with production-oriented overhead. That evidence is more useful than changing heap flags from memory after an outage.
We establish service metrics, structured logs, traces and a safe way to collect a flight recording or heap dump. Container memory limits, JVM heap sizing and non-heap memory are considered together. An OutOfMemoryError can come from retained application objects, native allocation, direct buffers or an undersized limit; each requires different evidence.
Operational access is designed before launch, including where diagnostic files go, who may collect them and how sensitive customer data is handled.
Java upgrades are easier when compatibility stays routine
The safest Java estate is one that moves regularly. Compiler warnings, deprecated APIs and framework migration notes are handled while the changes are small. CI runs on the target JDK before production, and the release is canaried or rolled out gradually where consequence warrants it.
Dependencies need the same discipline. A bill of materials can align related libraries, but direct and transitive versions still require review. Bytecode agents, annotation processors, JDBC drivers and native components are frequent sources of upgrade friction because they interact closely with the runtime.
We separate a JDK update from unrelated feature work, retain a rollback route and compare latency, errors, memory and garbage collection before and after the change.
Legacy Java replacement should follow seams, not fashion
A rewrite discards defects and accumulated constraints together with proven behaviour. Before recommending one, we map business capabilities, external integrations, scheduled work, data ownership and operational failure modes.
Often the better move is to stabilise the existing application, add tests around valuable behaviour and expose a supported API. A high-change capability can then move behind that seam while the stable core remains. This creates evidence about coupling and migration cost instead of betting the business on a complete replacement.
Legacy modernisation should leave the organisation with fewer unsupported dependencies and clearer ownership after each stage, even if the full destination changes.
Questions to answer before approving Java
- Which JDK distribution, licence and support timeline will production use?
- Which framework, build tool and dependency versions form the supported platform?
- Does the organisation already operate JVM services and interpret JVM diagnostics?
- What are the real concurrency limits in databases and downstream services?
- Which generated SQL paths need query-count and plan tests?
- How will Flight Recorder, heap dumps and runtime metrics be collected safely?
- Can JDK and framework upgrades be released independently of product features?
- Is modernisation protecting proven behaviour or proposing a rewrite without enough evidence?
When Java is a durable system choice
Java fits long-lived services, integration-heavy systems and established JVM estates where strong compatibility, mature tooling and runtime observability have clear value. It is particularly defensible when a capable team and support route already exist.
For an inherited Java system, renewal is often a better first decision than replacement. A current JDK, supported framework, reproducible build and visible diagnostics can change the risk profile before any architectural migration begins.
When Java creates a platform larger than the problem
Java is harder to justify for a small service when the organisation has no JVM capability, the workload is straightforward and another supported stack already covers it. It is also the wrong comfort choice when an enterprise label is being used to avoid defining a simple product boundary.
Choose Kotlin only when its language benefits justify another layer on the same JVM platform. Choose .NET or an existing web stack when that reduces operational fragmentation. The aim is fewer platforms for the business to keep healthy, even when its developers could work in more.
Renew a valuable Java platform deliberately; do not preserve an unsupported one by inertia.
I do not recommend replacing a working Java system because its age makes the stack look unfashionable. I first want to know its JDK provider, support date, framework line, dependency graph and runtime evidence. If the business behaviour is valuable, I would bring that platform onto a maintained route and create seams around the parts that need to change. For a new, small service, Java has to justify a complete JVM operating model. Existing capability is a strong reason; an enterprise label is not.
Alexander De Sousa · Founder, Digital Royalty · LinkedIn
What the Java decision includes beyond source code
Java's value comes from a mature runtime and ecosystem. The same breadth creates a duty to choose support, observe the JVM and keep framework and dependency upgrades routine.
The Java commitment in six decisions
- Best fit
- Long-lived services, enterprise integrations and existing JVM systems whose behaviour and operating capability are worth retaining.
- Product effect
- Strong compatibility and tooling, with delivery pace shaped by framework, dependency and platform upgrade discipline.
- Adoption cost
- Moderate inside an established JVM estate; high when a team must add Java build, runtime, diagnostics and support capability for one service.
- Ongoing owner
- Java engineers and platform operators responsible for the JDK, framework, dependency graph, database behaviour, JVM capacity and diagnostics.
- Exit cost
- High for a coupled monolith with shared data; lower when capabilities expose stable contracts and migration can follow business seams.
- Main risk
- Mistaking long runtime life for application support and allowing JDK, framework and library upgrades to accumulate into one urgent programme.
Platform routes to compare before selecting Java
-
Renew the existing Java system
Right when: Choose when the application carries valuable behaviour and JVM capability already exists, but runtime and framework support need attention.
Watch for: Protects proven behaviour while requiring staged platform work and stronger tests.
-
Build a focused Java service
Right when: Choose for integration-heavy or long-lived services that benefit from the JVM and can reuse an established operational route.
Watch for: Mature tooling and libraries, with more platform surface than a small script or serverless function.
-
Use Kotlin on the JVM
Right when: Choose when null-safety, coroutines or concise language features improve delivery while Java interoperability and the JVM remain valuable.
Watch for: Retains JVM duties and adds Kotlin compiler, Gradle and mixed-language concerns.
-
Use the supported .NET estate
Right when: Choose when the organisation already operates Microsoft and .NET systems and the workload has no Java-specific integration need.
Watch for: Consolidates team capability, but may require adaptation around JVM-native vendors or existing Java libraries.
Research behind this Java position
-
Vendor support roadmap
Oracle Java SE Support Roadmap
Shows that release designation, update availability, licensing and commercial support dates are separate parts of a production JDK decision.
-
Official concurrency design
OpenJDK JEP 444: Virtual Threads
Defines virtual threads as lightweight JVM threads for high-throughput blocking workloads and explains their task-per-thread and diagnostic model.
-
Official runtime evolution
OpenJDK JEP 491: Synchronize Virtual Threads without Pinning
Records the later JVM change that removed major synchronized pinning cases while retaining diagnostics for remaining native-code situations.
-
Official build documentation
Maven dependency mechanism
Explains transitive dependencies, scopes and dependency management used to produce a defined Java classpath across modules.
-
Official JVM diagnostics
Java Flight Recorder diagnostic tools
Documents production-oriented collection of runtime events covering allocations, garbage collection, threads, locks and I/O.
-
Framework documentation
Spring Boot system requirements
Makes Java, build-tool and container compatibility explicit for the selected framework release rather than treating Spring as independent of its platform.
-
Practitioner persistence question
Stack Overflow: solving N+1 queries in JPA and Hibernate
The discussion demonstrates how convenient association access can multiply queries and why fetch strategy must follow each use case.
-
Community modernisation discussion
Reddit: making the case for a Java runtime upgrade
Practitioners describe organisational resistance and dependency age around Java upgrades. It is anecdotal context for a decision governed by support evidence.
Tell us what you need
A few quick questions, then a straight answer from a real person — usually within a few hours.
What happens next
- 1 We reply A real person reads your answers and gets back to you, usually within a few hours.
- 2 Questions or a short call If anything isn't clear, we ask by email or book a short call. Before any call we audit your website and make the quick fixes it finds, free.
- 3 Your fixed quote A clear, fixed price in writing, within 48 hours of any call. There is no obligation to go ahead.
Tell us what you're working on
Whether it's a new site, a platform, or a process that shouldn't be manual any more — we'll tell you honestly if we can help.