Spring Developer Roadmap 2026: What You Need to Know

 

Transcript:

Spring is almighty. Maybe not completely almighty, but it’s really, really powerful. And I’m not only speaking about the Spring Framework. I’m also speaking about Spring Boot, for example, and of course all the libraries from the ecosystem. Some of them are supported by the Spring team, some are maintained by the community, which is amazing. It’s no surprise that Spring can cover you everywhere, from deep backend to the frontier of frontend. And obviously, since it’s that powerful, it maps directly to what we discussed last time: the backend developer roadmap.

Hi, my name is Pasha Finkelshteyn. I’m a Developer Advocate at BellSoft, and I used to be a backend developer and software architect. My main technology throughout my career was, of course, Spring. I saw the rise of Spring, and I see its golden years right now. There are so many projects and so many tasks you can solve with Spring. Let’s look at them.

Let’s start with probably the hardest part of our Spring roadmap: data mastery. I talked a lot about SQL, and you probably expect me to talk about Spring Data now, right? Because Spring Data is your entry point for anything data-related in Spring.

When we talk about SQL, many people think that Spring Data with Hibernate is the way to go. And it is. It’s probably one of the most popular parts of Spring Boot and of the whole Spring ecosystem. However, to truly master SQL, you need to write queries much more complicated than the ones you can write with plain Hibernate, HQL, or the Criteria API. You need window functions, common table expressions, recursive CTEs, analytical functions, and so on. And all of this is very hard, sometimes impossible, to do in plain Hibernate.

Of course, you can use native queries with Hibernate. It’s a perfectly valid use case. But did you know that you can use Spring with jOOQ and jOOQ code generation? It makes writing complex SQL queries much easier. They become type-checked, and it’s still simple to map results to your JPA entities if you need them. Personally, I almost don’t use JPA or Hibernate in my projects anymore. My favorite library in the whole ecosystem is jOOQ. When I need to work with SQL, I go with jOOQ. But obviously, it’s not a solution for every problem. Some things are harder to solve with jOOQ and easier with Hibernate. Just know your tools, know your stack, and use them properly.

Unsurprisingly, Spring knows about ACID and supports transactions. And of course, Spring supports all kinds of storage. For key-value storage, you can use Spring Data Redis. For graph storage, you can use Spring Data Neo4j. For document storage, Spring Data MongoDB. For vector storage, Spring AI provides APIs to work with vector databases.

As a side note, we mentioned specific data types in Postgres. Vlad Mihalcea has a library called Hibernate Types, which creates bridges between Postgres-specific types and Hibernate types. There are also Spring Data converters that convert Postgres-specific types into Spring types. Potentially, this might close the gap between native SQL and JPA for you. Take a look at them.

But even the best database is useless if you can’t make your application reliable and maintainable, which brings us to architecture.

Let’s start with architecture patterns. The first one is modular monolith. I’m a huge proponent of this idea. I think we should start with a monolith and split into services only when we truly need it. But how do we do it correctly? There is an answer in the Spring ecosystem: Spring Modulith. It’s a beautiful project that allows you to enforce boundaries between your modules. When the time comes, you can split a module into a separate service and scale it without rewriting the whole application because your modules were too tightly integrated.

Before advocating modular monoliths, I was an advocate of microservices. Now I think that starting with microservices is often disastrous, but that’s for you to decide. I even have a video on this topic. Of course, Spring supports microservices too. There’s a whole set of projects called Spring Cloud that help you build microservices for Amazon, Kubernetes, Google Cloud, and more. They provide solutions for secret management, configuration, and much more.

For serverless architecture, there are Spring Cloud Functions, which integrate nicely with platforms like AWS Lambda.

Now let’s talk about communication protocols, especially if you build microservices. First, REST. It’s the most popular choice, whether in microservices or a monolith. You can implement it with Spring Web MVC or Spring WebFlux. Then we have GraphQL, which is less popular but still widely used, supported by Spring GraphQL. Regarding gRPC, there is no official module from the Spring team, but companies like LogNet and Salesforce provide modules to support gRPC in Spring applications. Personally, for me, gRPC is often the best of the three, but it heavily depends on the use case.

Asynchronous communication is vital for larger systems. Spring provides everything you need. For message queues, there is Spring AMQP for RabbitMQ and Spring JMS for brokers like Apache ActiveMQ. For event streaming, there is Spring for Apache Kafka and Spring Cloud Stream, which provide the machinery to work with event streams and handle events. Spring can even make Kafka transactional, which is a beautiful built-in capability.

Spring also supports WebSockets through Spring WebSocket, including STOMP support, which is important for browsers.

Now let’s move to system design concepts. First, load balancing. Spring Cloud LoadBalancer provides a client-side load balancer, where the client decides which server instance to call. Then rate limiting: Spring Cloud Gateway has a built-in request rate limiter, which is crucial when you want to control traffic from clients.

There’s also Spring Cloud Circuit Breaker, which supports backends like Resilience4j. It mimics the operation of an electrical circuit breaker. It can be closed, open, or half-open. When downstream calls fail, it opens and fails fast until conditions improve.

As systems scale, they become larger targets for hackers. So let’s talk about security. When we mention OWASP Top 10, you must know Spring Security. It provides everything you need: CORS support, secure filters, authentication and authorization mechanisms, support for OAuth2, passkeys, and more. And of course, there’s the famous PreAuthorize annotation to protect specific methods.

For encryption, Java and Spring provide everything necessary. For secret management, there’s Spring Cloud Vault with multiple backend integrations. Spring also supports SSL and custom SSL keys, allowing you to encrypt data with your own keys.

When we talk about infrastructure as code, Spring has first-class support for Docker Compose through Spring Boot dev services. There’s also a way to build secure container images using the Spring Boot build-image task, which uses Liberica JDK under the hood. For Kubernetes, there’s Spring Cloud Kubernetes. And one of my favorite projects is Spring Cloud Config, which allows you to push new configuration settings to running applications without restarting them. You can change log levels or other properties live.

Finally, observability. Spring Boot integrates with Micrometer and Spring Boot Actuator. Micrometer allows you to collect metrics and traces, add spans and trace IDs to calls, including Kafka and message queues. Actuator exposes operational data that you can export to Prometheus and visualize in Grafana. This helps you detect bottlenecks before users even notice a problem.

And this is how Spring maps to the backend roadmap. I know it was short, but it’s impossible to cover all these topics in one video. If you’re interested in any of them, drop a comment below. If you liked the video, like it. Watch the backend developer roadmap video if you haven’t yet. And see you next time. Bye.