State of Spring, 2026

2026 is a great year to be a Java developer and a Spring developer using the Spring Framework, and I'm gonna go over why that is. Of course, the most interesting thing going on at the moment is how AI and especially code generation is affecting things, which I'll touch on a little bit.

So there's three things I'm gonna go over. One is that Spring developers are thriving nowadays. There's a lot of activity, probably more than ever, and they're doing great. It's the number one framework used for enterprise applications - the applications running the world. It aligns perfectly with the top CIO priorities, with what organizations are doing, and as always, it's got all the great new features that developers want to use and that are actually useful in the applications you make.

Now, like I said, AI is incredibly popular and "impactful," if you'll pardon the phrase, and this is where Spring is really showing a lot of its worth and its value. I think that a lot of the people doing Spring development are working in private cloud settings. They're running and managing the stacks on their own, as we'll see. In that setting where you're adding AI to your applications, or you're using AI in your tool chain, the way that you're doing development, once again, Spring is very well positioned, especially when you pair it with a proper platform like the Tanzu Platform.

All of that said, something that's very important for people to focus on in 2026 - as it was in 2025 and all the twenties - is making sure that you are upgrading Spring, that you actually are using the newest versions of it. Not only for those new features so that you can do AI stuff, but also so that you're delivering on the security and performance you want to have.

Spring is thriving

Now let's talk about the thriving nature of Spring. Especially if you're watching this and you're a Spring and Java developer, you have a sense of how much Java and Spring are used in the world. And when you actually look at the numbers, these numbers demonstrate it. You can see the amount of downloads from various repos, the number of GitHub projects that are out there, all that kind of stuff that you use to track the momentum of Spring. You can also see the breadth of functionality. As always, Spring has a tremendous amount of libraries.

The goal of Spring, at least in my mind from when I was doing Spring development, is to make it as easy as possible for developers to do the common things they do day after day, and just to let them focus on the actual business logic - the application they're doing, not all that wiring together and framework stuff.

There are other sources for the thriving nature of Spring. Let's look at it by looking at the usage of Java. This is from the RedMonk Programming Language Rankings. I used to work there quite some time ago, and you can see what they've tracked over the years based on conversation on the public internet and some of their own analysis - that is, at Stack Overflow and GitHub. You can see Java has consistently been in the top three for well over a decade. And this matches the intuition you have, right? Everyone uses JavaScript. It makes sense. So it's almost like a secondary language that people have, although it gains in popularity as its own thing in recent years. Java has been up there forever, and only recently in the RedMonk ranking did another language - Python - take over.

Now I still think that if you look at the bulk of Java running out there, that's not on the public internet where RedMonk is basing the survey data on. You'll find that the majority of applications running run on Java, and therefore they run on Spring. And therefore the majority of applications out there are using Spring. If you're using Java, you're probably using Spring, or at the very least, it's the number one framework out there.

And to add credence to that, if we look at another analyst at IDC who focuses more on enterprises, and whose survey methodology doesn't just rely on public sources, what you see is that over the years when they do their surveys, in enterprises and large organizations doing business applications, Java is the language used the most.

Whatever surveys you look at, whatever they're based on, what you'll find is that the surveys match the intuition you have. Especially when it comes to business workloads - as boring as that sounds, but things at banks, insurance companies, manufacturers, retail. Things that aren't basically taking pictures of cats wearing hats eating sandwiches, or people dancing, or things like that. Java is the underpinning of what those applications are, and has been for decades. And again, if you think about the momentum and the importance Spring has - also based on surveys and intuition - Spring is probably the number one framework used in all of these applications. So having that knowledge is not only more relevant, but is gonna allow you to have the widest amount of applications you work on. The biggest, if you'll pardon the phrase again, "impact" - the most importance in what's going on day-to-day in regular application development.

Spring matches CIO priorities

Another way of looking at that: if you look at surveys about what the priorities of organizations are, based on CIO priorities, you can look at the list and pretty much all of these map to what Spring will deliver for you. (The list I'm showing comes from a Forrester study commissioned by Broadcom, "Modernize Or Fall Behind: Rethinking IT Infrastructure For A Competitive Edge," October 2025.)

Security is always the top ranked one, and we'll get into how Spring - if you keep it upgraded and run it in a proper environment - really addresses the security concerns you have, and has been relied on for decades by large organizations to do that. If we look at these other things, especially things like modernizing applications, figuring out what to do with AI, putting it in applications, taking advantage of it, also getting performance improvements on infrastructure - I would argue each of these things is something Spring really helps with. It will help deliver on these priorities your CIOs have.

So think about this as far as the thriving nature of Spring. By my reckoning, it's the number one framework used for the most enterprise applications - the most real applications out there. This is derived from Java being likely the top language used to run these applications, and Spring being the top framework used there. If you look at what organizations are focused on - what they want to deliver on their priorities - you can see how Spring helps out with every single one of these things.

AI: the existing-Java-codebase flywheel

Now let's get into the AI part. This is where Spring and Java really has strengths, and where you see the nature of Spring, the philosophy it has, and the investment you have taken in learning Spring and doing it - and also as an organization - really starts to pay off. You can see the long-term strategy of Spring demonstrate itself when something new and interesting and very important like AI comes along.

The first thing is what you might call a flywheel effect, a perpetuating source of being good. And that is because Spring has been used for so many decades. And of course, Java. If you look at all those applications out there, there are so many of them written in Java. And more importantly, a Java developer understands the business logic that's codified in Java code, and therefore in Spring code.

What this means is that when you're using software, when you're writing software to run your business, the code you write personifies and does all the operational stuff, the process of your application. We all interact with businesses through software now, and so software is core to the business. If you took away software - if you took away all those Java apps - the business would collapse. And because of the importance of Java, I would say civilization would have a bummer of a time after that, if you just sucked it all out.

Because there's this momentum, this huge amount of Java applications running the world, what you have is an expression of how businesses run. It's codified there. You don't have to discover it and make it up. It's right there in the Java code, and not only is all that business logic in there, but it's actually running. It's performant. It's been road tested and battle hardened. We know how to run those things. And by definition, because it's there running civilization, it works.

That's why I think, when organizations are thinking about applying AI to their applications - putting AI in their applications - a huge amount of them go to Java, because that's what they have. That's where the business logic is. That's the part in their stack, the software they've written that runs their business. They don't wanna just start off writing a brand new thing from scratch in Python, let alone TypeScript, even if they're vibe coding it. Because you've got years of testing it, years of making sure it works, years of day-two operations that you need to do, and that's all taken care of with Java. All you need to do is add AI into your Java workflow. 62% of enterprises are now using Java to power their AI apps - that's not a coincidence; it's where the business logic already lives.

Rod Johnson - the original creator of Spring - said something similar recently: "The critical adjacency for building business apps with LLMs is existing business logic and infrastructure. And the critical skill set is building sophisticated business applications. In both these areas, the JVM is far ahead of Python and likely to remain so."

Spring AI keeps adding what you need

When it comes to AI, this is where the strategy of Spring - the long-term strategic value of Spring - is incredibly important. If you've been watching the project Spring AI over the past two years (and a little bit before that), you've seen it consistently and very rapidly add whatever new AI functionality is there. In the beginning, it was just about doing the classic Spring thing of having an abstraction over accessing whatever models you have, whether they're publicly hosted or locally hosted. Then it adds in support for evals, for tools. When MCP comes along, it adds that. And on and on - multimodal things. If you follow this, it's actually astonishing the rate that they add these new features.

That's the point of Spring: to always be that layer that's gonna be bringing in the new functionality you need to use for your applications, and having that be where you focus what you're doing. Making it as quick as possible for developers to use, so they don't have to figure out how to do all of that integration. I mean, you know this - you're a Spring developer. What you see in the Spring AI reference are all the things Spring AI has been adding, and therefore, when you're using the Spring framework and Spring AI, you just get all of this stuff for free.

Let's look at a specific case. Last year, in 2024, when Anthropic came out with Model Context Protocol - MCP, the way of adding plugins, of adding tools, of adding code to how you use AI - the Spring team's implementation was done very rapidly, and then it became the official implementation for doing MCP in Java. That's evolved over time, going from its own standalone implementation to Spring AI MCP. That's a great example of the strategic value of the Spring framework: the team is constantly adding new things as they become valuable, and you'll keep seeing that in Spring AI - which is why it's great that you've chosen to use it. You don't have to shift over to a new framework to take advantage of AI in your applications. You don't have to learn it, you don't have to test it out. You just gotta upgrade to start using the newer versions of Spring, and you get Spring AI in there.

You need a real platform, not a blinking cursor

Let's look at the next thing that's important. I've talked a lot about the frameworks - the thing at the application layer - but what's really important is to think about the platform you're running things on.

The first orientation here: if you work in a large organization - those kinds of organizations that use Java and that use Spring - chances are very high that the AI stuff you're doing is gonna be running on your private cloud. An IDC survey sponsored by Broadcom shows that a lot of the usage of AI - especially in large organizations - is something they want to own and control. They don't wanna just use the publicly hosted services. They need that control, which makes sense in highly regulated industries: governments, pharmaceuticals, and especially finance. As with any other service, you wanna start off having as much control over it as possible and figure that out.

What this means for a Spring developer is that you will be relying on a platform - something running in your environment, in your private cloud - that's doing a lot of the work to host and provide access to those AI services. Not to mention running your applications.

The issue that comes up with a lot of infrastructure providers in this kind of private cloud environment, in an enterprise setting, is that the infrastructure people - even fancy-pants titles like platform engineering people - they think what they need to do is deliver this to the developers: a blinking cursor. If you've ever just been given like a cluster, or a namespace, or some templates and whatever configuration management stuff you've had, you've experienced this. The infrastructure team - maybe the platform team, if you wanna stretch the definition - has set up and run this, they're managing it. And now it's your responsibility to do all that work between the blinking cursor and how your application runs. All of that work has nothing to do with the applications you're doing, and I (and many other people) would argue it's not worth very much at all to your organization. It's worth it to have it, but to build and customize that on your own is not good. There are all sorts of other reasons why building your own platform - why being given a blinking cursor as your platform - is not good. But let me illustrate what a good platform looks like, especially for the needs of AI.

How Broadcom IT runs MCP and models inside the platform

Our own IT organization at Broadcom - which is a huge company, you might have heard of it - has thousands of developers and they had these needs as well. They're running in a private cloud environment, like most large organizations, and they really wanna take advantage of using AI in the software development process: to run MCP servers, to connect to not only things on our own network but Atlassian and GitHub and all these sorts of things. Of course, because they have the concerns of a regulated industry, they don't wanna just let anyone run these things locally - they don't want their developers to have uncontrolled and unaccounted-for running of MCP, which kind of slows down the ability to take advantage of AI.

What they found with a good platform in place - the Tanzu Platform - and you can see my kind of crude representation of it above - is that you can run these MCP servers in the platform, and this instantly gives them all the controls they need to allow developers to do this. You can also run models, you can broker access to other models you have, meaning that developers can start to - in a very secure, governed way - use AI in their tool chain. This applies, of course, when you're running AI as part of your application as well. You need a platform that provides these services, that allows your infrastructure people - your platform team - to bundle up these services, make them secure, govern them, and provide them to the developers to use. You don't want your developers building on top of that blinking cursor thing.

If you wanna read more details, I'm not really gonna go into it here, but there's a great article written by some of my coworkers - and also some recordings on Cloud Foundry Weekly - that go over the implementation of this. How this kind of way of hosting MCP servers (whether it's for your development tool chain or for actually running your applications) - the architectural pattern they've been using, that Broadcom is using, and others of our customers are using. It's something you can put in place now, and chances are high that you actually have the Tanzu Platform - and even the VMware stack, the VCF stack, a full private cloud stack - that has this right now. Instead of having to build this out, having to test it out - just like the Spring framework, you have this right now and can start using it to get moving and start using AI in that secure, governed way, both when you're doing your development and also in the applications when you're running it.

Upgrading: the part we all need to do better at

Now let's look at a part I think we all suffer from and we all know we could do better at - but is even more important right now in 2026 (and was important in 2025) when it comes to meeting those priorities and especially thinking about how you're using AI in your apps.

Maybe it's not the case for you and your organization, but when you look at the versions of Spring and Java that people are running, it often lags behind. We see this in the numbers - there's a high percentage of people downloading unsupported versions of Spring Boot.

There are tons of people running older versions of Spring, older versions of Java, and they can't quite prioritize and get their organization to focus on upgrading. It seems like a lot of work, a lot of hassle. Usually they're motivated by external forces, like price increases (as the Java world has been seeing), or the need for new functionality. Sometimes they're motivated by good architectural principles, which is what we would like.

But when you look at surveys, there's this tangible feel with executives that the Spring community needs to connect to better. The executives understand they're running on older versions of Spring, and it's really holding them back from features, from evolving their business based on the software they're running. Now this figure is actually from 2020 if you read the footnotes - 76% of executives say legacy software is holding them back, per a 2020 Forrester study commissioned by VMware - but I would challenge you to think: has it really gotten better? Would executives in most organizations say, "Oh yeah, we're totally fine with our IT - it has every single thing we need, we can implement whatever features I can throw at them, and I can change the business on a dime to match what they need"? I don't think so. I think maybe it's gone down zero percentage points. You'd find the same thing if you asked executives today.

Upgrades give you performance and cost wins for free

Let's look at another reason why it's important: performance gains. When it comes to cost and performance, every time you update your Java VM (and Spring along with it), you're just gonna get performance improvements for free. Memory usage is less. CPU usage is less. Things start faster. Which means you can do the same with less, or you can do more with less or the same.

The point is, upgrading - and we see this very frequently with our customers who go through the upgrade process - they start to save money. They start to be more efficient simply because they don't need as much memory, they don't need as much compute. With the price of memory nowadays, it's a very valuable thing to look at. So that's a motivation for upgrading: it's proven that when you upgrade Java, when you upgrade Spring, you're gonna consume less resources, you're gonna have more efficient use of it, and we see that over and over again. Tanzu's internal studies show that on Java 21, organizations have observed up to 20% lower memory consumption and as much as 2x faster startup, with even stronger results on Java 25.

Also on the performance side: when it comes to functionality, if you look at a recent performance test of Spring for MCP, what you'll see is that it's the most efficient (measured by latency and a few other things) MCP implementation out there.

Again, this is showing you that all of the performance improvements - when you're using a newer version of Java, when you're using a proper framework like Spring AI - you're gonna get the most performant thing versus the other languages out there. This is the kind of thing you see with Java, and it shows you again why that long-term strategic bet, not only on Java but on Spring, pays off consistently no matter what's out there.

Tanzu Application Advisor: upgrades in an afternoon

Upgrading is hard. We've observed this over the years, and over the past couple of years we've really refined a tool we have: the Tanzu Application Advisor, to make it as easy as possible to upgrade your applications. This started off in Spring, but it's been changed to be more of a generic application upgrade thing. What it does is look at the applications you have running in the platform, scans them, and using OpenRewrite and some of our own technology, it suggests not only the easy things to upgrade but the more difficult things, and gives you a way to automate as much of your upgrade as possible. As you can see from an example in the slides, it not only shows you dependencies to upgrade but starts to go in using our recipes - and standard OpenRewrite ones - to show you the diffs for upgrading.

This sounds phenomenal, and it actually is. If you look at some of the customers who've talked about using this - here's one from Alight - it sped up their ability to upgrade by 70%, as was mentioned on a panel at our conference, Explore, last year. My colleague DaShaun likes to talk about this - how he's seen other organizations go from a team of five people who have to rove around the organization, probably over the course of years, to being able to do upgrades of applications and services in an afternoon using this tool.

So, the Tanzu Application Advisor: again, a tool you probably have access to already, because most large organizations have the Tanzu Platform - or can easily start running it on top of their VMware stack. You probably have access to start accelerating and speeding up the upgrades. Because that's really what holds a lot of upgrade stuff back: "it's just gonna take us a long time, it's hard to analyze all this code." But you start using these new tools you have - not to mention starting to use AI, which you are now running securely and highly governed in your platform environment, just like Broadcom's IT department is, and others I went over - and you can start to speed up that upgrade process, get those performance improvements, and also get access to new features, including AI things.

You can get access to some of that stuff with Tanzu Spring. It's our support offering around Spring. Not only does it bring you many of these options and support for it, but it's gonna help with that securing and governing side of things. It's gonna help you make sure you're upgraded - and if you're not quite ready to upgrade, it has long-term LTS support around older versions so that you can plan out your upgrading. But I think it's probably important to really focus on upgrading this year, for those performance needs I was going over.

To sum up

To sum up: when I look at all of this, this is the best time to be a Spring developer, a Java developer. And it's kind of always been the best time to be a Spring developer and a Java developer. Sure, there are other languages that are coming in and being helpful in this AI world. But as we apply AI - not only to the development phase (running tools, helping out in the tool chain) but also adding AI to your applications - everything you can do as a Spring developer, as an organization already using Spring with decades of applications in there, is gonna meet the CIO priorities, the priorities of your organization. You're gonna be able to address performance and cost, and security, but at the same time have all of that built-in business logic - that knowledge of how an organization works that's encoded into your applications and that's really doing just fine, now, if you think about it. And you'll be able to add in all of that AI functionality.

I think the best way to do this, as you'll see when you talk with my colleagues, is to run your Spring applications in the Tanzu Platform. We are the people who work on Spring - we're the stewards of the project, we have the most people committing. I've shown you that they're constantly adding new features. We wrote the official implementation for MCP and Java, and now it's in Spring AI. So we have all of the knowledge, the work, the care and stewardship of Spring running in the Tanzu Platform. There's a very tight integration between the two. It's the easiest, the best place for organizations to run their Java apps. And like I keep saying, you probably have access to it already, so you can just start using it.

If you wanna get the slides, there's a link above. Click on those things, look up all these studies yourself. And with that - thanks. I hope you have a good time doing your application development. You've made a wise choice by working with Spring.