Spring Boot is a marvel of developer productivity. It hides the plumbing and gets you up and running fast. Components are miraculously autowired, properties are magically resolved, and database connections materialize seemingly without explicit configuration.But when something goes wrong, the magic becomes a mystery, and debugging becomes a deep dive into the frameworks internal mechanics.Regular debuggers handle plain Java classes and objects, lacking framework-specific context. To inspect a property, track a bean, or examine an entity state, you need to dig into the internals of Spring Boot. (Remember how to access the application context from the debugger evaluator? Neither do we.)The rabbit was always in the hat you just had to know where to look. IntelliJ IDEA has long allowed you to inspect loaded beans or trace the source of a property value using the debugger, but doing so wasnt exactly straightforward. Our goal is to change that to make debugging Spring applications as comfortable and productive as the rest of your development experience in IntelliJ IDEA. The first step was an additional structure view, and now were going further.Lets pull back the curtain on the Spring Boot magic and see how the Spring Debugger plugin makes the invisible visible.The bean that wasnt thereSpring Debugger is built with a focus on real-world tasks, helping you uncover whats really happening inside your Spring application.Youve written the class. Youve annotated it as a bean. But its not doing anything.Maybe its not in the right package. Maybe its excluded by a conditional. Maybe its overridden in a test.Spring Debugger exposes the full bean landscape:You can see all Spring-managed beans directly in the Project view.Grayed-out entries tell you which ones were scanned but not instantiated.Using Mockito in tests? All mocked beans are clearly marked in orange.And it goes deeper.While stepping through the code, you can inspect a beans metadata, including the scope, profile, context, and even originating factory method. No more guesswork bean definitions are now first-class citizens in your debugging workflow.The property mazeYou set a property in application.properties, but your app uses a different value. Why?Spring Boots property resolution is layered: file values, profiles, environment variables, system properties, command-line args, post-processors Its a maze. Even professional developers need additional tools to get through.Spring Debugger flattens the hierarchy:It shows the effective runtime value inline in .properties and .yaml files.It highlights overridden values and source locations.For environment-based or external values, the evaluator reveals the origin clearly.For values from environment variables or external sources, it still shows where they came from in the debugger evaluator. Since you no longer need to trace values back manually, you save time and reduce the number of misconfigurations.The missing transactionYou annotated your method with @Transactional, but it is not committing. Even worse, youre getting a LazyInitializationException. What happened?Spring Debugger helps you understand whats going on:It shows inline indicators for methods executing inside active transactions.It displays full transaction details, including isolation, propagation, and the method that started it all.A visual hierarchy for nested transactions helps you understand call chains and propagation effects.For JPA, it shows the L1 cache state and updates it in real time.Now you know whether your method is inside the transaction you expected and where it actually began.The database client that configured itselfYour app connects to a database but how? From which config? Which JDBC URL is used? In tests, is it using a Testcontainer? Or is it perhaps an in-memory database like H2?Spring Debugger makes all of this explicit:It detects all active DataSource connections automatically.It groups them under their corresponding run/debug configurations.It integrates with IntelliJ IDEAs Database tool window for inspection.No need to manually register database connections or dig through logs. You can see every live DataSource and explore it interactively. In-memory databases are currently shown, but browsing data is not supported.Reading beans from thin airThe debugger is paused. You want to trigger a service, add test data, or inspect a Spring bean. Can you do this the normal way? No.Spring Debugger changes that by letting you:Auto-complete all loaded beans in the expression evaluator.Invoke any method on any bean on the fly.The process of bean evaluation is getting better: We can evaluate any configuration property value right in the debugger. All we need to do is select the evaluator on the right side.Its like a REPL for your Spring context. You can poke, prod, simulate, and confirm behavior without restarting the app or adding test code.For curious developers: How it works internallySpring Debugger doesnt require Spring Boot Actuator or any additional runtime agent. All data is analyzed locally without any network calls, data sharing, or risks of leakage, ensuring full privacy. Under the hood, the plugin uses non-suspending breakpoints set inside the Spring Boot framework libraries. During application startup, after the context is loaded, Spring Debugger gathers information from the debug session, memory heap, and stack trace. This lets it access raw internal application data without relying on external libraries.Thanks to the IntelliJ IDEA Debugger API, we were able to invoke required methods from Spring Boot libraries, build an application runtime model, and display it in the IDE.The Spring Debugger project also led to an extension of the debuggers evaluator API, allowing us to add property evaluators alongside the standard Java one. In the future, we may extend this further to evaluate not just properties but also SpEL, SQL, or similar expressions.SummarySpring Boot is powerful, but its abstractions can be hard to debug. Spring Debugger turns IntelliJ IDEA into a lens that sees through those layers. Its designed to keep you productive, improve code quality, and clarify real-world problems, all while offering ultimate comfort in your daily workflow.Beans, configs, and contexts visually decoded.Transactions made traceable.Properties unmasked and source-mapped.Databases auto-detected and accessible.Evaluator context-aware and interactive.The debugger doesnt undermine the magic of the Spring. It lets you understand and control it. Simply run your app in debug mode and see whats really happening.Try it now! Install Spring Debugger and make Spring internals visible. Documentation is available to help you get started.We value your feedback! Feel free to share your thoughts via plugin reviews or in the comments.Happy coding!