Java Applications Examples: Where Java Runs in 2026 and How It Has Changed

Search for a hotel on a UK comparison site and the availability query may be answered by a Java in-memory data grid that handles 300 million queries a day; we built that one. Netflix's streaming services, LinkedIn's Kafka pipelines and thousands of Amazon's production services run on Java too, and that is what most Java applications examples look like in 2026: back ends and data infrastructure that users never see.

Many of those systems were written for Java 8 and an application server, a decade before records, virtual threads and Java 25 changed how Java is written and run, and many of them are now due for modernizing.

Where Java runs in 2026: Java applications examples at a glance

Few people see Java any more. Browser applets are gone (Java 26 removed the Applet API altogether), and Google has made Android development Kotlin-first since 2019. The Java that matters runs on servers, in the layers below.

Every company named in this post is backed by its own engineering blog, documentation or source code. Some familiar names from older lists of Java applications are missing for that reason: we could not find a primary source for them, or the only source was a decade old.

Java in banking, payments and trading systems

Finance adopted Java early, in the J2EE years, and many of the systems built then still post ledgers, route payments and run trading platforms. The reasons were practical: a managed runtime without the memory errors of C++, static typing for code that moves money, and a platform with long support cycles from several vendors.

Latency-sensitive trading runs on Java as well. LMAX, which aims to run the fastest trading platform in the world, built that platform in Java and open-sourced the LMAX Disruptor, the inter-thread messaging library it wrote after finding that queues between processing stages added latency. The Disruptor is now a common dependency in Java systems that need low latency, logging libraries included.

Our longest-running example is FastPost, the rule-driven accounting platform we built for Legerity from 2013. It is a Java ledger with an in-memory engine that processes a billion financial transactions in under an hour in the cloud, with sub-second queries over billions of balances, for telcos and insurers. Ledgers suit the JVM: long-running processes give the JIT compiler time to optimize the hot paths, and an in-memory data grid keeps the working set off the database. The techniques are in our guides to low-latency Java applications and how Java enables high performance.

Banking is also where the oldest Java runs. A core or payment hub built on Java EE 6 and a commercial application server around 2012 is still on the javax namespace, often on Java 8, and moving it to Jakarta EE and a supported JDK is a project of its own. Our guide to legacy system modernization compares the ways to do it.

Travel, airline and ecommerce back ends

Travel search is a read-heavy workload with a write problem: prices and availability change all day, and every search has to see the change. The UK hotel metasearch engine from the introduction is a typical case. It had reached the limit of a cluster of dozens of SQL Server machines, where adding one machine raised cost by about 2% and throughput by about 0.1%.

We moved availability search into a Java in-memory data grid that holds everything a query needs, so the request path never touches the database. The engine now answers 300 million queries a day, up from 200 million, with response time down 60% and infrastructure cost down 80% (metasearch case study).

The airline scheduling and pricing systems we have worked on look similar: heavy calculation over large datasets, often a mix of Java and in-database logic from the 2000s, where both the design and the database licences limit how far the system can scale.

In ecommerce the largest example is Amazon, which says it runs Amazon Corretto, its own OpenJDK distribution, internally on thousands of production services. Most retailers run smaller versions of the same thing: an online store and a back office on one Java codebase that has grown for fifteen years, which is where the modernization story at the end of this post comes from.

Netflix, Spotify, LinkedIn and Signal: consumer platforms with Java back ends

The best-documented Java applications examples come from consumer platforms whose engineers write about their systems in public.

Netflix

Netflix's back end is largely Java and Spring Boot. In March 2024 its engineers wrote that more than half of its critical streaming video services ran on JDK 21 with generational ZGC, which Netflix had made its default collector on JDK 21 and later for the benefits of concurrent garbage collection, lower tail latencies among them.

Netflix also moved about 3,000 applications and 1,500 libraries to Spring Boot 3 and Java 17 with a platform team of five engineers who automated most of each upgrade (Tanzu, reporting a SpringOne 2023 talk), and published the most detailed account of a virtual thread deadlock in production, which our Java virtual threads guide walks through.

Spotify

Spotify's backend services are Java services built with Apache Maven. To keep library versions in step across services, Spotify maintains a shared bill of materials, the Java BOM: in 2023 96% of its production backend services used it (Spotify Engineering), and 80% were on a BOM version less than seven days old. An engineer can update a dependency across the fleet with one pull request.

LinkedIn

Apache Kafka started at LinkedIn, which also runs one of the largest deployments. In 2019 its engineers reported more than 100 Kafka clusters and over 4,000 brokers handling 7 trillion messages per day (LinkedIn Engineering), on LinkedIn's own release branches of Kafka with patches for its scale.

Signal

The Signal messenger's server is open source and written in Java: the Signal-Server repository is almost entirely Java, built with Maven, and at the time of writing its .java-version file names Temurin 26, a feature release newer than the current LTS, rather than the oldest supported version.

Big data infrastructure written in Java: Kafka, Spark, Elasticsearch and Cassandra

Much of the open-source data infrastructure of the last fifteen years runs on the JVM, so teams that never write Java still operate it. The language breakdown comes from each project's repository.

Running this layer on an old JDK has a measurable cost. When Uber turned on TLS for its Kafka clusters, p99 latencies degraded about 2.5 times. Its engineers traced the gap to cryptography: Java 11 handles TLS much faster than Java 8, and with brokers moved to Java 11 and the garbage collector tuned, latencies came down significantly (Uber Engineering).

Elasticsearch ships with its own bundled JDK, but Kafka, Cassandra and Hadoop run on whatever JDK the operator installs, so for them the Java version is a decision someone has to keep making.

Android, Minecraft and Java on the desktop

Java was the language of Android from the first release, and the Android platform APIs are still Java APIs, so large existing apps carry a lot of Java code. New Android work is mostly Kotlin since Google's Kotlin-first announcement at Google I/O 2019. Android apps compile to DEX bytecode and run on ART, not on a JVM, so Android API levels and JDK versions are upgraded separately.

Minecraft is the best-known Java game. The original edition, still sold as Minecraft: Java Edition next to the Bedrock edition, is Java, and so is the mod ecosystem built around it.

On the desktop, the IntelliJ platform behind IntelliJ IDEA and JetBrains' other IDEs is written mostly in Java and Kotlin, and Eclipse IDE is Java. Further down, Java Card runs small Java applets on SIM cards and other smart cards.

How widely is Java used in 2026?

Java is fourth in the TIOBE Index for September 2026 with 7.54%, behind Python (17.76%), C (10.28%) and C++ (8.67%). TIOBE counts search-engine results, so it measures attention rather than use. In the Stack Overflow Developer Survey 2025, 29.4% of all respondents had used Java in the past year, just ahead of C# at 27.8%.

Neither figure counts how much production code runs on Java; the systems above are better evidence of that. The survey figures and their trend are in our post on the use of Java in software development, and the reasons behind them in why Java is still popular.

How Java changed from Java 8 to Java 25

A team that last looked at Java with version 8 in 2014 would find a different language. Since Java 10 in March 2018, a feature release ships every six months, in March and September, and since Java 17 every fourth one is a long-term support (LTS) release, so an LTS arrives every two years. Features arrive in small steps, often as previews first, instead of in a large release every three years.

Records, sealed classes and pattern matching

Records (Java 16, JEP 395) are immutable data carriers with the constructor, accessors, equals and hashCode written by the compiler. Sealed classes (Java 17, JEP 409) fix the set of subtypes. Pattern matching for switch and record patterns (Java 21, JEP 441, JEP 440) take records apart in a switch that the compiler checks for completeness: add a fourth payment type and every switch that misses it stops compiling.

Together they replace much of the visitor and DTO boilerplate in older business code. This is a complete Java 25 program:

// Fees.java: run with `java Fees.java` on JDK 25. A compact source file imports java.base itself.
sealed interface Payment permits Card, Transfer, Refund {}
record Card(String token, BigDecimal amount) implements Payment {}
record Transfer(String iban, BigDecimal amount) implements Payment {}
record Refund(String originalId, BigDecimal amount) implements Payment {}

BigDecimal fee(Payment payment) {
    return switch (payment) {
        case Card(_, var amount) -> amount.multiply(new BigDecimal("0.015")).setScale(2, RoundingMode.HALF_UP);
        case Transfer t when t.amount().compareTo(new BigDecimal("10000")) > 0 -> new BigDecimal("5.00");
        case Transfer _ -> BigDecimal.ONE;
        case Refund _ -> BigDecimal.ZERO;
    };
}

void main() {
    IO.println(fee(new Card("tok_1", new BigDecimal("200.00"))));  // 3.00
}

The _ marks a component the code does not use (Java 22, JEP 456), and the file needs no class declaration, no public static void main and no imports, because it is a compact source file.

Virtual threads for I/O-bound services

Virtual threads (Java 21, JEP 444) let a server run one thread per request without sizing a thread pool, because a blocked virtual thread releases its OS thread. Java 24 removed the main early limitation, pinning inside synchronized blocks (JEP 491). For a typical Spring Boot service the switch is one property; the work is in what it exposes, such as connection pools that become the new limit. Our guide to Java virtual threads covers the patterns and the failure modes.

What Java 25 LTS added

Java 25 reached general availability on 16 September 2025 (OpenJDK). The changes that matter most for application teams:

• Compact source files and instance main methods (JEP 512): a program can start with void main(), with no class around it, and use the new IO class for console input and output. Scripts, tools and teaching code get much shorter.
• Scoped values (JEP 506) share immutable data with the methods a thread calls, and with child threads, at lower cost than ThreadLocal, which matters once a service runs on virtual threads.
• Module import declarations (JEP 511): import module java.sql; imports every package a module exports.
• Compact object headers (JEP 519) cut the header of every object to 64 bits. In the JEP 450 measurements, SPECjbb2015 used 22% less heap. On Java 25 they are switched on with -XX:+UseCompactObjectHeaders; Java 27 turns them on by default (JEP 534).
• Ahead-of-time ergonomics and method profiling (JEP 514, JEP 515): one -XX:AOTCacheOutput option creates a cache of loaded classes and method profiles from a training run, so later runs start and warm up faster.

Our Java end of life guide lists the other Java 25 changes, including the few that add upgrade work.

Java 26, Java 27 and Spring Boot 4

Java 26, a feature release, reached general availability on 17 March 2026 (OpenJDK). It adds HTTP/3 to the standard HTTP client (JEP 517), extends ahead-of-time object caching to every garbage collector (JEP 516), improves G1 throughput (JEP 522), removes the Applet API (JEP 504) and starts warning when code changes final fields through deep reflection (JEP 500).

Java 27, the latest feature release, followed on 15 September 2026 (OpenJDK). It turns compact object headers on by default (JEP 534), makes G1 the default garbage collector on every machine, small ones included (JEP 523), and adds post-quantum hybrid key exchange to TLS 1.3 (JEP 527). Neither 26 nor 27 is an LTS release, so most production systems stay on 25 and pick these features up at the next LTS.

On the framework side, Spring Boot 4.0 shipped in November 2025 on Spring Framework 7 and Jakarta EE 11, with Java 17 as its baseline (release notes), and 4.1 followed in June 2026. Most of the upgrade work is in the libraries it brings along, Jackson 3 and Hibernate 7 among them; our Spring Boot 4 migration guide has the route and a checklist.

Taken together, the releases since Java 21 show where the ecosystem is heading. The runtime is getting cheaper to run in containers, with the ahead-of-time cache, compact object headers and better collector defaults. Concurrency is getting simpler, with virtual threads final and structured concurrency close behind. Security keeps pace with new threats, as the post-quantum key exchange in Java 27 shows. Frameworks follow quickly: Spring Boot has switched on virtual threads with a single property since 3.2. Each six-month step is small, but the distance from Java 8 to Java 27 is large, which is why upgrading an old system feels like a migration.

Why many Java systems now need modernizing

The examples in this post have one thing in common: the companies keep their Java current. Netflix moved 3,000 applications in one programme, Spotify updates dependencies weekly, and Signal builds on a JDK newer than the current LTS. Many enterprise systems are still on Java 8 or 11, Spring Boot 2 and the javax namespace.

Support dates set the deadline

According to Oracle's support roadmap, extended support ends for Java 17 in September 2029, Java 8 in December 2030, Java 21 in September 2031 and Java 11 in January 2032. Oracle JDK 21 updates moved to a licence that is not free in production in October 2026, and open-source support for Spring Boot 3.5 ended in June 2026. The dates and the options are in our Java end of life guide.

What an upgrade looks like in practice

An independent London wine merchant runs its online store and its back-office ERP on one Java codebase built up over more than fifteen years. It still worked, but Spring 5.3, Spring Security 5.8 and Hibernate 5.5 no longer received security fixes, and a dependency scan found 12 critical and 35 high-severity advisories.

We moved both applications from Java 17 and Spring 5 to Java 25 and Spring 6.2 in tested steps. The core upgrade took about four weeks, with no rewrite and no feature freeze, and took the advisories from 47 to zero.

Most Java systems can be modernized the same way, in place and in steps: the JDK first, then the framework, then the parts of the design that hold the system back, with the strangler pattern for the pieces that do need replacing. A full rewrite is rarely the cheapest route for a system that still does its job.

If your Java applications are still on Java 8 or 11, our application modernization service starts with a written inventory of what runs where, the upgrade order and a ballpark estimate, before any code changes. To talk it through, get in touch.