Spring Boot Interview Questions

What should I focus on for a Spring Boot interview?

Which database topics should I review first?

Start with JPA, ORM, and query performance. JPA and ORM appeared in 41 of 115 interviews. Performance and caching appeared in 32 of 115 interviews. These were the most common topics in these interviews.

The most asked question covered the causes, detection, and prevention of N+1 queries, asked in 14 of 115 interviews. Some reviewed answers missed the pattern: a query loads a list, then an extra query runs for each item.

Check whether you can:

• Explain that query pattern clearly, then describe how you would detect and prevent it in production.
• Say when you would choose an ORM over raw SQL, and when you would avoid it.
• Explain how you would use pagination for a large dataset.
• Name the trade-offs you would consider before adding caching.

Can I explain Spring Boot and how beans work?

The comparison with Spring Framework and the bean scopes question were among the most asked. Can you explain what Spring Boot offers compared with Spring Framework, rather than only define it?

For beans, check whether you can:

• Explain how singleton and prototype scopes differ.
• Say when beans are created and describe their lifecycle.
• Compare constructor, setter, and field injection.
• Explain the differences between @Component, @Service, @Repository, and @Controller.

What details should my API and transaction answers include?

State the annotation relationship directly: @RestController combines @Controller and @ResponseBody. Some reviewed answers did not explicitly mention this.

Then check whether you can explain how you would handle request validation and exceptions in a REST API, and where DTOs fit.

For transactions, can you explain where a transaction starts and ends? Describe how @Transactional uses proxies and what happens with self-invocation. Can you explain propagation and say which rollback rules apply?

What should I check beyond databases and beans?

Use these questions to check the other topics:

• Can you explain the difference between authentication and authorization, then describe how you would protect a REST API?
• Can you explain what service discovery and load balancing do in a microservices application?
• Can you describe how you would call an external API?
• Can you explain how you would prevent regressions and troubleshoot a framework issue?
• Can you describe how you would use Actuator endpoints for health checks?

Who gets asked Spring Boot

The 20 most asked Spring Boot questions

Counted by interview, not by mention: a question asked twice in one conversation counts once.

1. What causes N+1 queries, and how do you detect and prevent them in production?

   Asked in 14 of 115 interviews · last asked Oct 15 · Concept · Mid-level

   Show answer

   N+1 queries happen when one query loads a list, then accessing related data runs another query for each item. Detect them with request traces, query counts, and sampled SQL logs in production. Prevent them with fetch joins, entity graphs, or DTO projections; use batch fetching to reduce extra queries.

   • Lazy loading often triggers this, but eager loading can also produce extra queries.
   • Batch fetching reduces query count; it does not necessarily produce one query.
   • Collection fetch joins can break efficient pagination; page IDs first, then fetch related data.
   • Sample production SQL logs and avoid exposing sensitive values.

   What the interviewer checks: The interviewer checks whether you can recognize repeated database calls and choose a safe, efficient fetching strategy.

   Common mistake (in 3 of 6 reviewed answers): Many answers forget that the pattern is one query for a list followed by an extra query for each item.

   Other ways it was asked

   • “What is the N+1 query problem, and how do you fix it?”
   • “What is the N+1 query problem?”
   • “How can you avoid the N+1 query problem?”

2. How does Spring Boot differ from Spring Framework, and what advantages does it offer?

   Asked in 8 of 115 interviews · last asked Oct 16 · Concept · Junior

   Show answer

   Spring Boot builds on Spring Framework to make applications easier to set up and run. Spring Framework provides core features such as dependency injection and web support. Boot adds auto-configuration, starter dependencies, and embedded servers for web apps. It reduces manual setup and offers health checks and metrics through Actuator.

   • Spring Boot uses Spring Framework; it does not replace it.
   • Auto-configuration applies defaults based on dependencies and settings; you can override them.
   • Starters group common dependencies, while Boot manages compatible dependency versions.
   • Embedded servers let web apps run without a separately installed application server.

   What the interviewer checks: The interviewer checks whether you understand Spring’s core role and how Boot simplifies setup, deployment, and monitoring.

   Other ways it was asked

   • “What is the difference between Spring and Spring Boot?”
   • “What is the difference between the Spring Framework and Spring Boot?”
   • “What is the difference between Spring Framework and Spring Boot?”

3. What bean scopes does Spring support, and how do singleton and prototype scopes work?

   Asked in 8 of 115 interviews · last asked Sep 28 · Concept · Mid-level

   Show answer

   Spring supports singleton, prototype, request, session, application, and websocket scopes, plus custom scopes. Singleton is the default: one instance per bean definition per Spring container. Prototype creates a new instance whenever the container is asked for that bean. A prototype injected into a singleton is not recreated on each use.

   • Request means one instance per HTTP request; session means one instance per HTTP session.
   • Application means one instance per ServletContext; websocket means one instance per WebSocket session.
   • Request, session, application, and websocket scopes require a web-aware application context.
   • Spring initializes prototype beans but does not call their destruction callbacks; cleanup is your responsibility.

   What the interviewer checks: The interviewer checks whether you understand bean lifetimes, instance sharing, and the limits of prototype scope.

   Other ways it was asked

   • “What different scopes can a Spring bean have?”
   • “What scopes are available for Spring beans, and what does each scope mean?”
   • “What bean scopes does Spring support, and how do they affect bean lifecycles?”

4. Why use an ORM instead of raw SQL, and when would you avoid it?

   Asked in 8 of 115 interviews · last asked Oct 7 · Concept · Mid-level

   Show answer

   An ORM maps database rows to objects and reduces repeated code for common database operations. It can make an application easier to build and maintain, but generated queries may be inefficient. I would use raw SQL for complex reports, database-specific features, or queries needing precise performance control. Both can be used in the same application.

   • An ORM handles object mapping and relationships; some also track changes.
   • You still need SQL knowledge and must check generated queries.
   • Lazy loading can cause N+1 queries: one initial query followed by many extra queries.
   • Raw SQL gives direct query control but requires more manual mapping and maintenance.

   What the interviewer checks: The interviewer is checking whether you can balance simpler development with query control and performance.

   Other ways it was asked

   • “What are the differences between using an ORM and writing raw SQL queries?”
   • “Why use an ORM instead of writing only raw SQL?”
   • “What is the advantage of an ORM? Forgetting the technical aspect, why do we need an ORM in the first place?”

5. Can you explain Spring Boot?

   Asked in 7 of 115 interviews · last asked Oct 1 · Concept · Junior

   Show answer

   Spring Boot builds on the Spring Framework to make Java applications easier to set up and run. It provides auto-configuration, starter dependencies, and embedded servers for web applications. This reduces manual setup, so I can focus on application logic.

   • Auto-configuration sets up Spring features based on dependencies, settings, and existing beans.
   • Starters group common dependencies, such as those needed for a web application.
   • Web applications can run as executable JAR files without a separate server installation.
   • You can override the defaults with your own configuration.

   What the interviewer checks: The interviewer checks whether you understand what Spring Boot adds to Spring and why it reduces setup work.

   Other ways it was asked

   • “What is Spring Boot?”
   • “What is Spring Boot? Can you give me an example?”
   • “What is a Spring Boot application?”

6. When are Spring beans created, and what happens during their lifecycle?

   Asked in 5 of 115 interviews · last asked Oct 16 · Concept · Mid-level

   Show answer

   Spring creates non-lazy singleton beans at context startup, lazy beans when first needed, and prototype beans on each request. It creates the instance, injects dependencies, and runs initialization callbacks, with bean post-processors running before and after initialization. When the context closes, Spring runs destruction callbacks for managed singletons.

   • A lazy bean may still be created at startup if an eager bean needs it.
   • Initialization order is @PostConstruct, InitializingBean.afterPropertiesSet(), then a custom init method.
   • Bean post-processors can wrap beans in proxies, such as those used for transactions.
   • Destruction order is @PreDestroy, DisposableBean.destroy(), then a custom destroy method; Spring does not automatically destroy prototype beans.

   What the interviewer checks: The interviewer checks whether you understand creation timing, lifecycle callbacks, and how bean scope affects cleanup.

   Other ways it was asked

   • “What is the lifecycle of a Spring bean?”
   • “What is the Spring bean lifecycle?”
   • “Can you explain the Spring bean life cycle?”

7. What are Spring stereotype annotations, and how do @Component, @Service, @Repository, and @Controller differ?

   Asked in 5 of 115 interviews · last asked Oct 16 · Concept · Mid-level

   Show answer

   Spring stereotype annotations mark classes for detection and registration as beans during component scanning. @Component is general-purpose, while @Service marks business logic. @Repository marks data access and supports translation of persistence exceptions into Spring data access exceptions. @Controller marks a Spring MVC web controller.

   • @Service, @Repository, and @Controller are specialized forms of @Component.
   • @Service adds meaning but does not automatically add transactions or other behavior.
   • @Repository exception translation requires Spring’s exception translation support to be enabled.
   • @Controller methods can return view names; @ResponseBody makes their return values response bodies instead.

   What the interviewer checks: The interviewer checks whether you understand each annotation’s role and which ones enable behavior beyond bean registration.

   Other ways it was asked

   • “What is the difference between @Component, @Service, and @Repository?”
   • “Can you explain the difference between @Component, @Service, @Repository, and @Controller?”
   • “In Spring, what is the difference between the @Service and @Component annotations?”

8. What are the differences between constructor, setter, and field injection in Spring?

   Asked in 5 of 115 interviews · last asked Oct 16 · Concept · Junior

   Show answer

   Spring supports constructor, setter, and field injection. Constructor injection passes dependencies through a constructor and is recommended for required dependencies because it supports final fields and easy testing. Setter injection passes dependencies through setter methods and suits optional or changeable dependencies. Field injection injects directly into fields but hides dependencies and makes testing without Spring harder.

   • Constructor injection makes required dependencies explicit and ensures they are supplied when the object is created.
   • Setter injection allows later changes; optional dependencies need safe defaults or handling when absent.
   • Field injection usually uses @Autowired.
   • Since Spring 4.3, a single constructor does not need @Autowired.

   What the interviewer checks: The interviewer checks whether you understand the injection styles and why constructor injection is usually preferred.

   Other ways it was asked

   • “What types of dependency injection does Spring support, which type is recommended, and why?”
   • “What are the types of dependency injection in Spring?”
   • “What are the types of dependency injection?”

9. What is the difference between @Controller and @RestController?

   Asked in 5 of 115 interviews · last asked Oct 22 · Concept · Mid-level

   Show answer

   @Controller handles web requests and often returns a view name for an HTML page. @RestController combines @Controller and @ResponseBody, so return values go into the HTTP response body rather than becoming view names. It is commonly used for APIs that return JSON.

   • @Controller methods can use @ResponseBody to return data instead of a view.
   • @RestController returns data through HTTP message converters; the format is not always JSON.
   • A String returned from a @RestController method is response content, not a view name.

   What the interviewer checks: The interviewer checks whether you understand view rendering versus response body handling.

   Common mistake (in 4 of 5 reviewed answers): Many answers forget that @RestController combines @Controller and @ResponseBody, so state this explicitly.

   Other ways it was asked

   • “What is the difference between @Controller and @RestController in Spring?”
   • “Can you tell me the difference between a controller and a REST controller?”
   • “What is the difference between a REST controller and a controller?”

10. How do you use @Transactional to manage database transactions in Spring Boot?

    Asked in 5 of 115 interviews · last asked Oct 12 · Concept · Mid-level

    Show answer

    @Transactional tells Spring to run a method within a database transaction. By default, it joins an existing transaction or starts a new one. Spring commits a new transaction when the method succeeds. Runtime exceptions and errors trigger rollback by default; checked exceptions need a rule such as rollbackFor.

    • Usually place it on public service methods that group related database changes.
    • The object must be Spring-managed, with transaction management enabled and a suitable transaction manager configured.
    • With default proxy-based handling, calls must go through the proxy; calls within the same object bypass it.
    • An existing transaction commits at its outer boundary, not when the annotated method returns.

    What the interviewer checks: The interviewer checks whether you understand transaction boundaries, rollback rules, and the conditions needed for the annotation to work.

    Other ways it was asked

    • “What is the use of the @Transactional annotation?”
    • “Why should we use the @Transactional annotation?”
    • “How would you manage a transaction in a Spring method?”

11. How does ORM change tracking work, and when should you use tracking versus no-tracking queries?

    Asked in 4 of 115 interviews · last asked Sep 10 · Concept · Mid-level

    Show answer

    ORM change tracking remembers loaded entities and detects changes, often by comparing values with saved snapshots. Use tracking when you will update entities and save through the same context or session. Use no-tracking queries for read-only results to reduce memory use and tracking work.

    • EF Core tracks entity queries by default; AsNoTracking() disables tracking for the query.
    • Changes to untracked entities require attaching them or using an explicit update operation.
    • Long-lived contexts can hold stale entities and consume extra memory.
    • Hibernate read-only entities can remain managed; read-only mode is not the same as EF Core's AsNoTracking().

    What the interviewer checks: The interviewer checks whether you understand automatic updates, tracking costs, and the difference between read and write operations.

    Other ways it was asked

    • “What is change tracking in Entity Framework, and when would you use it?”
    • “What is change tracking in Entity Framework, and what problems can it cause?”
    • “When should repositories use entity tracking versus no-tracking queries, and why?”

12. What is inversion of control, and how does Spring implement it through dependency injection?

    Asked in 3 of 115 interviews · last asked Oct 7 · Concept · Mid-level

    Show answer

    Inversion of control means the framework manages object creation and wiring instead of your code doing it. Spring implements this through dependency injection: its container creates objects called beans and supplies the dependencies they need. Dependency injection is a way to achieve inversion of control.

    • Spring's ApplicationContext is the container that creates, wires, and manages beans.
    • Beans can be registered through component scanning or @Bean methods in configuration classes.
    • Constructor injection makes required dependencies clear and makes classes easier to test.

    What the interviewer checks: The interviewer checks whether you understand who creates objects and how Spring supplies their dependencies.

    Other ways it was asked

    • “What does inversion of control mean in a Spring application?”
    • “What is inversion of control in Spring Boot?”
    • “What is the relationship between inversion of control and dependency injection, and how does Spring illustrate inversion of control?”

13. How do you handle exceptions globally in a Spring application?

    Asked in 3 of 115 interviews · last asked Sep 22 · Tooling · Junior

    Show answer

    Use @RestControllerAdvice with @ExceptionHandler methods to handle exceptions across REST controllers. Each method maps an exception type to an HTTP status and a consistent error body, often using ResponseEntity. For MVC views, use @ControllerAdvice instead.

    • Use specific exception handlers for expected errors, such as missing resources or invalid input.
    • Log unexpected errors and return a safe message without internal details.
    • Controller advice does not automatically catch exceptions from filters, background jobs, or every application layer.

    CodeCopy

    import org.springframework.http.ResponseEntity;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    @RestControllerAdvice
    class GlobalExceptionHandler {
        @ExceptionHandler(IllegalArgumentException.class)
        ResponseEntity<String> handleInvalidArgument(IllegalArgumentException ex) {
            return ResponseEntity.badRequest().body("Invalid request");
        }
    }

    What the interviewer checks: The interviewer checks whether you can centralize web error handling, choose suitable HTTP statuses, and understand its limits.

    Other ways it was asked

    • “How would you implement global exception handling in Spring to catch exceptions from across an application?”
    • “How does Spring Boot handle global exception handling?”

14. What is an ORM?

    Asked in 3 of 115 interviews · last asked Jul 30 · Concept · Junior

    Show answer

    ORM means Object-Relational Mapping. It maps application objects to tables in a relational database, so you can work with objects instead of writing SQL for every operation. Hibernate is a common ORM framework used with Spring Boot.

    • Classes usually map to tables, fields to columns, and objects to rows.
    • An ORM can handle saving, loading, updating, and deleting data.
    • JPA defines a Java persistence standard; Hibernate implements it.
    • You still need SQL knowledge to understand queries and fix performance problems.

    What the interviewer checks: The interviewer checks whether you understand how objects map to relational data and can name an ORM framework.

    Other ways it was asked

    • “What is ORM?”
    • “What is an ORM? Can you name one?”

15. In Spring, does @Transactional work when one method calls another @Transactional method in the same class?

    Asked in 3 of 115 interviews · last asked Sep 1 · Concept · Senior

    Show answer

    Not for the inner call in Spring's default proxy mode. A call within the same object bypasses the proxy, so the inner method's @Transactional settings are ignored. If the outer method already has a transaction, the inner method uses it; otherwise, the inner annotation does not start one.

    • The outer method's annotation applies when its call goes through the Spring proxy.
    • Inner settings such as REQUIRES_NEW are ignored during a same-object call.
    • Move the inner method to another Spring bean and call it through that bean's proxy.
    • AspectJ transaction mode can support same-object calls, but requires weaving.

    What the interviewer checks: The interviewer checks whether you understand proxy-based transactions and why same-object calls bypass transaction handling.

    Other ways it was asked

    • “If a method annotated with @Transactional is called from another method in the same class, will a transaction start?”
    • “What happens in Spring when one transactional method calls another transactional method?”

16. How would you diagnose and fix intermittent EF Core query slowdowns without changing the database schema?

    Asked in 3 of 115 interviews · last asked Oct 16 · Scenario · Senior

    Show answer

    I would compare fast and slow requests using EF Core command logs and request traces. I would check SQL, parameter values, database execution plans, blocking, and connection pool waits. Based on the cause, I would reduce query count, select fewer columns, or remove unnecessary tracking. I would verify the fix under realistic load without changing the schema.

    • Use EF Core logging or a command interceptor; compare database time with total request time.
    • Use database-specific tools to inspect execution plans, blocking, and parameter-sensitive performance.
    • Fix N+1 queries, project needed fields, and use AsNoTracking for read-only entity queries.
    • Test representative parameters and concurrent requests; avoid logging sensitive parameter values in production.

    What the interviewer checks: The interviewer checks whether you can isolate intermittent bottlenecks and choose evidence-based fixes rather than guess.

    Other ways it was asked

    • “How would you approach diagnosing an intermittent performance regression in an Entity Framework Core query without changing the database schema?”
    • “How would you approach diagnosing an intermittent performance regression in an EF Core query without changing the database schema?”
    • “Could you elaborate on any specific tools or techniques you use to track performance metrics or diagnose issues in EF Core queries?”

17. What are eager and lazy loading, and how does lazy loading work in Hibernate?

    Asked in 3 of 115 interviews · last asked Oct 1 · Concept · Mid-level

    Show answer

    Eager loading fetches related data when an entity is loaded. Lazy loading waits until that data is accessed. Hibernate usually uses proxies or collection wrappers to detect access and fetch the data. If unfetched data is accessed after the Hibernate session closes, a LazyInitializationException can occur.

    • Eager loading does not always mean one SQL join; Hibernate may run separate queries.
    • Lazy loading avoids unnecessary fetching, but accessing many relationships can cause the N+1 query problem.
    • JPA defaults to eager for to-one relationships and lazy for to-many relationships.
    • Use a fetch join or entity graph when an operation needs related data.

    What the interviewer checks: The interviewer checks whether you understand fetch timing, Hibernate sessions, and the performance trade-offs.

    Other ways it was asked

    • “What is the difference between lazy loading and eager loading in Entity Framework?”
    • “What is lazy loading in Hibernate?”
    • “What are eager loading and lazy loading?”

18. Which Spring modules are commonly used, and what are they used for?

    Asked in 2 of 115 interviews · last asked Jul 16 · Concept · Mid-level

    Show answer

    Common Spring modules include Core, Beans, and Context for dependency injection and bean management. AOP handles shared behavior, such as logging, across methods. JDBC and ORM support database access, while the transaction module manages transactions. Web MVC supports servlet-based web apps, WebFlux supports reactive web apps, and Test supports unit and integration testing.

    • The core container creates, configures, and connects application objects called beans.
    • ORM integrates persistence tools such as Hibernate; transaction support includes @Transactional.
    • Spring MVC and WebFlux are alternative web frameworks with different execution models.
    • Spring Boot, Spring Data, and Spring Security are separate Spring projects, not Spring Framework modules.

    What the interviewer checks: The interviewer checks whether you can name the main modules and explain where each is used.

    Other ways it was asked

    • “What are some of the main modules in Spring?”

19. What is the process through which a Spring Boot application starts?

    Asked in 2 of 115 interviews · last asked Sep 18 · Concept · Mid-level

    Show answer

    A Spring Boot application starts when `main()` calls `SpringApplication.run()`. Spring Boot prepares the environment, creates the application context, and processes configuration, including auto-configuration. It creates and wires beans, and starts an embedded server for a typical web application. It then calls `ApplicationRunner` and `CommandLineRunner` beans before publishing `ApplicationReadyEvent`.

    • `@SpringBootApplication` enables component scanning and auto-configuration, and marks the class as configuration.
    • Auto-configuration uses conditions based on available classes, properties, and existing beans.
    • Non-lazy singleton beans are normally created during context refresh; lazy beans can be created later.
    • Non-web applications do not need an embedded server.

    What the interviewer checks: The interviewer is checking whether you understand the startup order and how Spring Boot builds the application context.

    Other ways it was asked

    • “What happens internally when a Spring Boot application starts?”

20. How do you manage Spring Boot configuration using profiles?

    Asked in 2 of 115 interviews · last asked Sep 22 · Tooling · Mid-level

    Show answer

    Spring profiles let me use different settings and beans for different environments. I keep shared settings in application.properties and environment-specific settings in files like application-dev.properties and application-prod.properties. I activate the required profile with spring.profiles.active, using an environment variable or a command-line argument.

    • Profile-specific files override matching settings in the shared configuration.
    • Use @Profile on components or configuration classes to load beans only for selected profiles.
    • Environment variables and command-line arguments can override settings from configuration files.
    • Keep secrets outside the application, such as in environment variables or a secret manager.

    CodeCopy

    java -jar app.jar --spring.profiles.active=prod

    What the interviewer checks: The interviewer checks whether you can separate environment settings, activate profiles, and control which beans load.

    Other ways it was asked

    • “How do you manage configuration and profiles in Spring Boot?”
    • “How do Spring profiles work?”

Live coding round next? Coding mode in the MeetAssist desktop app solves the problem on your screen, with your phone as the remote.

Related interview questions

• Software Engineer interview questions
• AI Engineer interview questions
• Data Engineer interview questions
• DevOps Engineer interview questions
• Solutions Architect interview questions
• React interview questions
• Angular interview questions
• Node.js interview questions
• Next.js interview questions
• HTML and CSS interview questions
• Android and Kotlin interview questions
• iOS and Swift interview questions

How this list is made

Every question here was asked by a real interviewer in a real job interview that a candidate ran MeetAssist in. After the call, the interviewer's questions are pulled from the transcript. Practice sessions, tests, exams and anything that was not a job interview are dropped.

Questions are rewritten so they make sense on their own: names of people, employers and clients are removed, and speech-to-text mistakes are fixed. Small talk, logistics and questions about one candidate's own résumé are left out. Rephrasings of the same question are merged, and the count is the number of different interviews it came up in.

The interviews come from candidates who use MeetAssist, so they lean towards software, data and AI roles: the shares describe these interviews, not every Spring Boot interview. Answers to the most asked questions are written and checked by an editor; a "common mistake" is shown only when reviews of real answers in these interviews show it, with the count.

115 interviews, 75 candidates, Dec 2025 to Oct 2026. Updated every month with new interviews.