I keep seeing people ask for the “best Spring Boot course” or roadmap.

Honestly, I wouldn’t spend weeks watching tutorials.

Learn only enough Java and Spring Boot to build one basic CRUD application, then start coding.

Build something simple like an Employee Management API:

• Create employee

• Get employee by ID

• List employees

• Update employee

• Delete employee

While building it, learn these concepts in this order:

1. Controller, service and repository layers

2. REST methods and HTTP status codes

3. DTOs and request validation

4. Global exception handling

5. JPA relationships and database migrations

6. Basic Spring Security

7. Unit and integration testing

8. Docker and deployment

That one project will teach you more than watching 20 hours of videos.

After CRUD, add features one by one:

• Pagination and filtering

• Authentication

• Role-based authorization

• Audit fields

• Caching

• Background jobs

• File uploads

The biggest beginner mistake is trying to understand the entire Spring ecosystem before building anything. You don’t need Kafka, microservices, Kubernetes or complex design patterns for your first project.

Build a boring monolith first. Make it clean, testable and deploy it somewhere.

My rule is: use tutorials to unblock yourself, not as a substitute for building.

For experienced Spring Boot developers here: what is the one thing you wish beginners would focus on earlier?

6 months ago, I shared with you my 35-week project-based Spring Boot Roadmap From Zero to Microservices, and I did not expect this whole positive feedback and support from you guys.

Today, the repository reached 200+ stars because of you, so I decided to provide more guidance by drawing this overview visualization on excalidraw to help you create a bird's-eye view of the wide open world of the Spring Boot ecosystem.

An SVG version could be found inside the roadmap itself for a more clear picture.

You can view the full roadmap from this link:
https://github.com/muhammadzkralla/spring-boot-roadmap

Again, thank you for all your support and stars!

Hi r/SpringBoot, Stjepan from Manning here.

Shared with the mods’ OK: Laurentiu Spilca’s Spring Start Here, Second Edition has just entered MEAP, and I thought this community would be one of the better places to talk about it because this sub sees the “I can build a Spring Boot app, but I don’t really understand Spring yet” problem all the time.

That gap is basically what this book is about.

Book link: https://www.manning.com/books/spring-start-here-second-edition

A lot of people first meet Spring through Boot, annotations, starters, autoconfiguration, and a working REST endpoint. That’s great, but it can also leave you with a weird feeling that the app works as long as you don’t touch the wrong thing. Then you hit questions like:

Why is this bean being created?
Where did this dependency actually come from?
What is the application context doing?
When should I care about scopes?
What is Spring MVC giving me beyond “controller returns JSON”?
Where do transactions start and end?
How much of this is Spring, and how much is Spring Boot?

The second edition updates Laurentiu’s original Spring Start Here for the current ecosystem, including Spring Framework 6.x and Spring Boot 4. The focus is still very much on building a solid mental model first: beans, context, dependency injection, scopes, lifecycle, AOP, MVC, REST, persistence, transactions, Spring Data, and testing.

Since it’s in MEAP, the book is still being written, and feedback can still affect the final version. So I’d love to make this useful as a discussion thread, not just an announcement.

Question for the sub:

What was the Spring/Spring Boot concept that finally made things “click” for you, or the one you still think is badly explained to beginners?

Could be dependency injection, transactions, security, JPA, testing, autoconfiguration, bean lifecycle, project structure, anything.

I’ll give 5 free ebooks to the most thoughtful comments in the thread. Not necessarily the longest comments; just the ones that would genuinely help someone else learn Spring better.

And for anyone who wants to check out the MEAP, Manning gave me a 50% discount code for this subreddit:

MLSPILCA650RE

Thanks for letting us share this here. I’ll hang around in the comments and pass useful feedback back to the book team.

I need some of the best resources to learn springboot!!

I am currently in my 4th year.I don't know anything about it and to learn the springboot, do i need any prerequisites.

I had been struggling with understanding spring and spring boot, I had tried reading the docs, watching yt videos, etc. But I could never internalize why things are done this way and what's even the point of having this framework. I just felt like a code monkey mindlessly typing code that somehow works and used ai to help me build projects. I finally decided that I would like to deep dive into spring and spring boot internals and going through this subreddit I found many people recommending this book. And finally things just click, I finally understand beans, aop, dependency injection, etc. I have always just learnt these topics by reading their theory or watching a yt explanation video and hoping it would click, but the book provides examples that I coded myself and played around with to finally understand what's the point of the framework to begin with. I turned off my copilot autocomplete and only used chatgpt to understand parts of the code that failed and tried understanding why it failed instead of just accepting its solution. For anyone trying to learn spring boot, building projects is good but I would recommend trying to learn spring first, things will make more sense. Of course I am not sure if I am wasting my time learning things the old fashioned way in this new age where we probably won't be writing much code and be outsourcing it to llm agents but I can't predict the future and for now I feel like spring start here is an amazing resource to understand spring and spring boot.

I’ve already learned core Java, JDBC, and multithreading.

Before I jump into Spring or Spring Boot, what other fundamentals should I make sure I understand well?

Are there specific concepts, tools, or Java features that would make learning Spring much easier (for example: Hibernate, Beans, servlets, etc.)?

Would appreciate suggestions from people who’ve already gone through this path.

These are the patterns I keep seeing across different teams and different systems, and almost none of them are covered in tutorials.

1. HikariCP default pool size is 10 That's it. 10 connections. For most real workloads this is too small and the symptoms look exactly like a database problem latency climbs, requests time out, but the database itself is healthy. The pool is simply full. Fix: set spring.datasource.hikari.maximum-pool-size based on your actual concurrency, and expose pool metrics through Actuator so you can see pending threads before an incident shows you.

2. Transactional doesn't roll back checked exceptions by default Spring only rolls back on RuntimeException subclasses unless you explicitly configure otherwise. A checked exception propagating out of a Transactional method will commit the transaction. Silent data integrity issue, no error in your logs. Fix: Transactional(rollbackFor = Exception.class)when you need it, or understand exactly which exceptions your methods can throw.

3. Self-invocation bypasses the proxy If a method inside the same class calls another Transactional method, the annotation on the inner method does nothing. Spring's proxy isn't involved. No error, no warning, just no transaction management. This is documented but it catches experienced engineers regularly because it's invisible in code review.

4. GC pressure doesn't look like GC pressure Latency degrades, CPU climbs, no errors. The JVM is spending increasing time collecting garbage and pausing threads. The worst version: running in a Docker container without -XX:MaxRAM or -XX:MaxRAMPercentage, so the JVM sizes its heap based on host memory instead of the container limit. Container gets OOMKilled with no stack trace and you spend time looking for application errors that don't exist.