Spring Boot Interview Questions: 23 Answers for Boot 4, JPA & Security
23 Spring Boot interview questions with sample answers: auto-configuration, @Transactional pitfalls, JPA N+1, security filter chain, test slices and Boot 4.
Last updated: November 2026
Quick Answer
Spring Boot interviewers test whether you know what the framework does for you and where it bites: how auto-configuration decides which beans exist, how configuration and profiles resolve, how proxies make @Transactional and security work (and when they silently do not), how JPA generates queries, and what changed in Spring Boot 3 and 4. Rehearse the spoken answers in OphyAI Interview Practice, and use OphyAI Coding Copilot for the live coding round. Expect concept questions, a code-reading exercise on a controller or repository, and questions about the services on your resume.
As of November 2026 the current release is Spring Boot 4.1.2 (per spring.io), on Spring Framework 7 and Java 17 or later; many employers still run 3.x.
| # | Question | What it tests |
|---|---|---|
| 1 | Spring Boot vs Spring Framework | What Boot actually adds |
| 2 | How auto-configuration works | Conditions and back-off |
| 3 | What @SpringBootApplication does | The three annotations inside it |
| 4 | What a starter is | Dependency management |
| 5 | Property precedence and @ConfigurationProperties | Externalized config |
| 6 | Profiles and profile groups | Environment-specific config |
| 7 | Constructor injection | DI design |
| 8 | Bean scopes | Prototype-in-singleton trap |
| 9 | When @Transactional silently fails | Proxies and self-invocation |
| 10 | The JPA N+1 problem | Query generation |
The Questions, With Sample Answers
1. “What is Spring Boot, and how is it different from the Spring Framework?”
Why they ask. It shows whether you see Boot as opinions layered on Spring, not a separate framework.
Sample answer. “The Spring Framework gives me the container, dependency injection, transactions, Spring MVC and data access. Spring Boot sits on top and removes the setup work. It adds auto-configuration, which creates sensible beans based on what is on the classpath; starters, which bundle compatible dependencies; an embedded server, so the app runs as an executable jar; externalized configuration with a clear precedence order; and Actuator for health and metrics. None of that replaces Spring concepts. A Boot app is still a Spring application context full of beans, and every default can be overridden by defining my own bean or setting a property. Current Boot 4.x builds on Spring Framework 7, and Boot 3.x built on Framework 6.”
Weak answers. “Spring Boot is a newer version of Spring”, or describing it only as “less XML”.
2. “How does auto-configuration work?”
Why they ask. It is the core Boot concept, and the debugging follow-up separates users from people who understand it.
Sample answer. “Auto-configuration classes are ordinary configuration classes annotated with @AutoConfiguration and listed in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports inside each jar. Boot loads them after my own bean definitions and applies each one only if its conditions match: @ConditionalOnClass checks the classpath, @ConditionalOnMissingBean backs off if I already defined that bean, and @ConditionalOnProperty checks a setting. So adding a JDBC driver and the JPA starter gives me a DataSource, but if I declare my own DataSource, Boot’s version steps aside. To see what was applied and why, I start the app with --debug, which prints the conditions report. To switch one off, I use the exclude attribute or spring.autoconfigure.exclude.”
@AutoConfiguration
@ConditionalOnClass(SomeService.class)
public final class SomeServiceAutoConfiguration {
@Bean
@ConditionalOnMissingBean
SomeService someService() {
return new SomeService();
}
}
Weak answers. “Boot scans everything and wires it automatically”, with no mention of conditions or how to override a default.
Rehearse the auto-configuration follow-ups out loud in Interview Practice, which asks the second question (“so how would you turn it off?”) for you.
3. “What does @SpringBootApplication do?”
Why they ask. It checks whether you know the three annotations hidden inside it and the package-scanning consequence.
Sample answer. “It combines three annotations. @EnableAutoConfiguration turns on the auto-configuration mechanism. @ComponentScan scans for components starting at the package of the class it sits on, which is why the main class belongs in a root package above everything else; a controller in a sibling package will not be found. @SpringBootConfiguration marks the class as a configuration source and helps integration tests find the configuration automatically. I can exclude specific auto-configurations through its exclude attribute. If I want tighter control, I can use the three annotations separately, for example replacing component scanning with explicit @Import of configuration classes.”
Weak answers. “It starts the application”, or not knowing why a bean in another package is missing.
4. “What is a Spring Boot starter?”
Why they ask. It tests whether you understand dependency management and what pulls in what.
Sample answer. “A starter is a dependency descriptor: mostly an empty jar whose job is to bring in a coherent set of libraries plus the matching auto-configuration. Adding the web MVC starter gives me Spring MVC, Jackson and embedded Tomcat at versions Boot has tested together, managed through Boot’s dependency management, so I do not pick versions myself. Spring Boot 4 made the modules more granular: spring-boot-starter-web is deprecated in favor of spring-boot-starter-webmvc, technologies such as Flyway now need their own starter, and each technology has a matching test starter like spring-boot-starter-webmvc-test. If I write a starter for an internal library, it is named acme-spring-boot-starter, never starting with spring-boot, and its properties use my own prefix.”
Weak answers. “A starter is a template project”, or not knowing who manages the versions.
5. “How does Spring Boot resolve configuration properties, and how do you bind them?”
Why they ask. Incidents often come from a property set in two places; can you say which wins?
Sample answer. “Boot reads properties from many sources with a fixed precedence, and later sources override earlier ones. Roughly: defaults, then application.properties or YAML, then OS environment variables, then Java system properties, then command-line arguments, with test properties on top. Within config files, profile-specific files override the base file, and files outside the jar override packaged ones. Binding is relaxed, so MY_APP_TIMEOUT in the environment maps to my-app.timeout. For anything more than one value I use @ConfigurationProperties on a record, which gives me constructor binding and immutability, and I add @Validated so a missing URL fails at startup instead of at the first request.”
@ConfigurationProperties("payments")
@Validated
public record PaymentsProperties(@NotBlank String baseUrl, Duration timeout) {}
Weak answers. Scattering @Value everywhere, or not knowing that an environment variable can override the file.
6. “How do profiles work?”
Why they ask. Every team has dev, test and prod configurations, and misused profiles leak test settings into production.
Sample answer. “A profile is a named slice of configuration. I activate it with spring.profiles.active, for example from an environment variable in the deployment, and Boot then loads application-{profile}.properties on top of the base file. If several profiles are active, the last one wins for conflicting keys. If none is active, the default profile applies. Any @Component or @Configuration can carry @Profile so a bean exists only in that environment, such as a stub payment client in local development. Profile groups let one name like production activate proddb and prodmq together. One rule people trip on: spring.profiles.active cannot be set inside a profile-specific file. I keep secrets out of profile files entirely and inject them from the environment.”
Weak answers. Using profiles to toggle business features, or committing production passwords to application-prod.yml.
7. “What is dependency injection, and why do you prefer constructor injection?”
Why they ask. It checks whether you understand design, not just annotations.
Sample answer. “Dependency injection means a class receives its collaborators instead of creating them, so the container wires the graph and I can swap implementations in tests. I use constructor injection: dependencies are explicit, fields can be final, the object is never half-built, and a unit test can call the constructor with mocks without starting Spring. With a single constructor I do not even need @Autowired. Field injection hides dependencies and makes classes hard to test outside the container. If a constructor grows past five or six parameters, that is a design smell telling me the class does too much. When I have two implementations of one interface, I use @Qualifier or @Primary rather than relying on bean names.”
Weak answers. “I use @Autowired on fields because it is shorter.”
8. “What bean scopes exist, and what happens if you inject a prototype bean into a singleton?”
Why they ask. The prototype-in-singleton trap is a classic follow-up that catches people who memorized the scope list.
Sample answer. “Singleton is the default: one instance per container, shared across all threads, which is why my singleton beans hold no mutable request state. Prototype creates a new instance each time the bean is requested. Web contexts add request, session, application and websocket scopes. The trap is that dependencies are resolved once, when the singleton is created, so a prototype injected into a singleton is created once and reused forever. If I need a fresh instance per call, I inject an ObjectProvider<T> and call getObject(), use @Lookup method injection, or put a scoped proxy in front of the bean. For a request-scoped bean injected into a singleton controller, the scoped proxy is what makes it work at all.”
Weak answers. Listing scopes with no idea of the injection-time problem, or storing per-user data in a singleton field.
Run questions 7 and 8 as a timed back-to-back drill in Interview Practice; interviewers usually chain them.
9. “When does @Transactional silently not work?”
Why they ask. It is the most common Spring production bug, and the answer proves you understand proxies.
Sample answer. “Spring applies @Transactional through a proxy that wraps the bean. Only calls that come in through the proxy are intercepted, so if placeOrder() calls this.saveItems() on the same class, the annotation on saveItems() is ignored, because self-invocation never passes through the proxy. The fixes are to move the method into another bean, inject the bean into itself through the proxy, or switch to AspectJ mode. Other causes: calling the method on an object created with new rather than a Spring bean, an interface-based proxy where the method is not on the interface, catching the exception inside the method so it never reaches the proxy, or doing work on another thread, since the transaction is bound to the calling thread.”
Weak answers. “Just add @Transactional and it works”, or never having heard of self-invocation.
10. “Why didn’t my transaction roll back?”
Why they ask. It extends question 9 into rollback rules and propagation, which matter in payments and banking codebases.
Sample answer. “By default Spring rolls back on RuntimeException and Error, but not on checked exceptions. So if a service throws IOException from a method with a plain @Transactional, the transaction commits. I either declare rollbackFor = Exception.class or use unchecked exceptions for failures that should undo work. Since Spring Framework 6.2, @EnableTransactionManagement(rollbackOn = ALL_EXCEPTIONS) changes the default globally. Propagation matters too: the default, REQUIRED, joins an existing transaction, so an inner method that fails marks the whole outer transaction rollback-only. If I need an audit row to survive even when the main work fails, the audit method uses REQUIRES_NEW in a separate bean. I also mark read paths readOnly = true.”
Weak answers. Assuming every exception rolls back, or using REQUIRES_NEW everywhere “to be safe”.
11. “What is the N+1 query problem in Spring Data JPA, and how do you fix it?”
Why they ask. It is the most common JPA performance bug and appears in nearly every backend loop that uses Hibernate.
Sample answer. “N+1 happens when I load N parent rows with one query and then touching a lazy association on each one fires another query per row: one query for 100 orders, then 100 queries for their customers. I spot it by turning on SQL logging or watching query counts in a test. The fixes depend on the use case: a JOIN FETCH in a JPQL query, an @EntityGraph on the repository method, Hibernate batch fetching so lazy loads happen in batches, or a DTO projection that selects only the columns the endpoint needs. I avoid switching associations to eager fetching globally, because that moves the problem to every other query. I also watch pagination combined with collection fetch joins, because Hibernate may paginate in memory.”
@EntityGraph(attributePaths = "customer")
List<Order> findByStatus(OrderStatus status);
Weak answers. “Make everything EAGER”, or not knowing how to see the generated SQL.
12. “What is open-in-view, and should you turn it off?”
Why they ask. It is a Boot default that hides N+1 bugs and holds database connections longer than people expect.
Sample answer. “In a web application Spring Boot registers OpenEntityManagerInViewInterceptor by default, which keeps the JPA session open for the whole request so lazy associations can load while the response is rendered or serialized. It is convenient, but it means lazy loads can fire queries from the controller or the JSON serializer, outside any transaction I designed, and the connection is tied up for longer. On API services I set spring.jpa.open-in-view=false, load what each endpoint needs inside the service layer with fetch joins or projections, and return DTOs instead of entities. If that causes a LazyInitializationException, it has shown me a query I had not planned for.”
Weak answers. Fixing LazyInitializationException by switching everything to eager fetching.
13. “How do you handle exceptions globally in a REST API?”
Why they ask. Consistent error responses are part of API design, and they want to see more than try/catch in every controller.
Sample answer. “I put a @RestControllerAdvice class in front of the controllers with @ExceptionHandler methods that map domain exceptions to HTTP status codes, for example OrderNotFoundException to 404 and validation failures to 400 with field errors. For the response body I use RFC 9457 Problem Details, which Spring supports through ProblemDetail and the application/problem+json media type; extending ResponseEntityExceptionHandler covers Spring MVC’s own exceptions, and spring.mvc.problemdetails.enabled=true turns on the built-in support. I log the stack trace once, server-side, and never return it to the client. Anything unmapped falls through to Boot’s default /error handling, so I add a catch-all that returns a generic 500.”
@RestControllerAdvice
class ApiErrors {
@ExceptionHandler(OrderNotFoundException.class)
ProblemDetail notFound(OrderNotFoundException ex) {
return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
}
}
Weak answers. Returning 200 with an error flag, or leaking stack traces in the response.
14. “How does the Spring Security filter chain work?”
Why they ask. Security config is often copied blindly; they want to see you reason about it.
Sample answer. “The servlet container knows nothing about Spring beans, so Spring Security registers a DelegatingFilterProxy that hands each request to FilterChainProxy. That bean picks a SecurityFilterChain and runs its filters in order: loading the security context, authentication filters such as bearer-token or form login, then authorization. Only the first chain whose matcher fits the request is used, so I order chains from most specific to least, for example /api/** with JWT first and a browser chain second. ExceptionTranslationFilter turns authentication failures into a 401 or a login redirect, and access-denied into a 403. I configure all of this by declaring SecurityFilterChain beans with HttpSecurity, and I keep each chain small enough to read in one screen.”
Weak answers. Disabling CSRF without knowing why, or not knowing that chain order matters.
Prepare for the security block with OphyAI in a technical-format mock in Interview Practice.
15. “What does Spring Boot Actuator give you, and how do you secure it?”
Why they ask. Production readiness matters for senior roles, and exposed endpoints are a known risk.
Sample answer. “Actuator adds operational endpoints under /actuator: health, info, metrics, environment, loggers, thread dumps and more. By default only health is exposed over HTTP, and I widen that deliberately with management.endpoints.web.exposure.include, never with * on a public service, because endpoints like env and heapdump can leak sensitive data. With Spring Security on the classpath and no custom chain, Boot secures everything except health; once I define my own SecurityFilterChain, I must write the Actuator rules myself, using EndpointRequest.toAnyEndpoint(). For Kubernetes, the health groups /actuator/health/liveness and /actuator/health/readiness map to the two probes, and liveness should not depend on external systems like the database.”
Weak answers. Exposing all endpoints publicly, or wiring the database check into liveness so a database blip restarts every pod.
16. “How do you test a Spring Boot application?”
Why they ask. Test strategy shows seniority, and slice tests are Boot-specific knowledge.
Sample answer. “I layer tests. Plain unit tests with constructor injection and mocks cover business logic without Spring. Slice tests start only part of the context: @WebMvcTest loads controllers, @ControllerAdvice, filters and MVC config but not regular @Component beans, so I mock services with @MockitoBean; @DataJpaTest loads entities and repositories, runs each test in a transaction that rolls back, and uses an embedded database unless I set @AutoConfigureTestDatabase(replace = Replace.NONE) to hit a real one, usually through Testcontainers. A few @SpringBootTest tests check the full wiring. In Boot 4, @MockBean is gone in favor of @MockitoBean, and @SpringBootTest needs @AutoConfigureMockMvc to get MockMvc.”
@WebMvcTest(OrderController.class)
class OrderControllerTests {
@Autowired MockMvcTester mvc;
@MockitoBean OrderService orders;
}
Weak answers. Using @SpringBootTest for every test, which makes the suite slow, or testing repositories only with mocks.
17. “How does the embedded server work, and which servers are supported?”
Why they ask. It checks deployment knowledge and whether you follow version changes.
Sample answer. “A Boot web app packages the servlet container inside the executable jar, so java -jar app.jar starts Tomcat on port 8080 by default, changeable with server.port. The web MVC starter brings Tomcat; to use Jetty I exclude the Tomcat starter and add the Jetty one. Boot 4.1 supports Tomcat 11.0 and Jetty 12.1, both on Servlet 6.1, and I can still build a war for an external Servlet 6.1 container. Undertow support was removed in Boot 4.0, so a team on Undertow has to switch servers as part of that upgrade. Tuning usually means thread pool and connection limits, graceful shutdown and compression.”
Weak answers. Not knowing the app can run without an external application server, or listing Undertow as a current option.
18. “How do virtual threads work in Spring Boot, and when would you enable them?”
Why they ask. It tests whether you follow modern Java and can judge when a feature helps.
Sample answer. “Virtual threads need Java 21 or later, and the Boot docs strongly recommend Java 24 or later. Setting spring.threads.virtual.enabled=true switches Boot’s auto-configured task executor and scheduler, among other components, to virtual threads. They are cheap, so a blocking thread-per-request service can handle many more concurrent requests that spend their time waiting on databases or HTTP calls, without rewriting to reactive code. They do not make CPU-bound work faster. My checklist: confirm the connection pool size, because more concurrent requests now hit the database at once; drop thread-pool tuning, since those properties no longer have an effect; watch for pinned virtual threads, which the docs say can lower throughput and which JDK Flight Recorder can detect; and remember virtual threads are daemon threads, so an app that only runs @Scheduled jobs needs spring.main.keep-alive=true to stay up.”
Weak answers. “Virtual threads make everything faster”, or enabling them without checking the database pool.
19. “What is a GraalVM native image, and what are the trade-offs?”
Why they ask. Native images come up for serverless services, and the trade-offs test judgment.
Sample answer. “A native image compiles the application ahead of time into a platform-specific executable, which typically starts much faster and uses less memory than the JVM. Boot 4.1 supports GraalVM 25 or later. The cost is the closed-world assumption: static analysis runs at build time from the main method, code that cannot be reached is removed, the classpath is fixed, and reflection, resources and proxies must be declared as hints. Spring’s AOT processing generates most of those hints and turns bean definitions into source code. That also means beans cannot change at runtime, so @Profile and @ConditionalOnProperty have limitations. Builds are slower and some libraries need extra hints. I choose native for short-lived or scale-to-zero workloads, and the JVM for long-running services.”
Weak answers. “It is always faster”, or not knowing that profiles behave differently.
20. “How do you add observability to a Spring Boot service?”
Why they ask. Microservice teams expect you to debug across services, not just inside one.
Sample answer. “Spring Boot builds observability on the Micrometer Observation API, introduced with Boot 3.0: one observation produces both a timer metric and a trace span. Much of the framework, such as Spring MVC requests, is instrumented automatically once Actuator and a tracing bridge are present. I export metrics to Prometheus or over OTLP, and traces through Micrometer Tracing to an OpenTelemetry backend; Boot 4 added a dedicated spring-boot-starter-opentelemetry. For custom business operations I create an Observation and keep tag cardinality low on metrics, putting IDs only in traces. Trace IDs go into logs through correlation, so I can jump from a log line to the trace. For @Async and reactive code I make sure context propagation is on, or the trace breaks.”
Weak answers. “We add log statements”, or putting user IDs into metric tags.
21. “What changed between Spring Boot 2 and Spring Boot 3?”
Why they ask. Many companies migrated recently or are still migrating, and they want someone who has done it.
Sample answer. “Spring Boot 3.0, released in November 2022, set Java 17 as the minimum, moved to Spring Framework 6 and Spring Security 6, and migrated from Java EE to Jakarta EE, so every javax.persistence, javax.servlet and javax.validation import became jakarta.*. That namespace change is the bulk of the work, because third-party libraries must also be on Jakarta-compatible versions. Boot 3 also added first-class GraalVM native images and Micrometer Observation. My migration approach: first upgrade to the latest 2.7.x and clear deprecation warnings, move to Java 17, then upgrade Boot, use an automated tool such as OpenRewrite for the import changes, and fix security config to the SecurityFilterChain bean style. A thorough test suite is what makes it safe.”
Weak answers. “We just bumped the version number”, or not knowing about the Jakarta change.
22. “What is new in Spring Boot 4?”
Why they ask. It shows whether you track the platform, and 4.x is now the current line.
Sample answer. “Spring Boot 4.0 shipped on November 20, 2025, built on Spring Framework 7 and Jakarta EE 11, keeping Java 17 as the minimum while fully supporting Java 25. The codebase was split into smaller modules, so starters became more focused, spring-boot-starter-web is deprecated for spring-boot-starter-webmvc, and there are matching test starters. Jackson moved to version 3, with packages changing from com.fasterxml.jackson to tools.jackson. The portfolio adopted JSpecify null-safety annotations, and HTTP Service Clients got auto-configuration, so a plain interface with @HttpExchange becomes a working client. There is built-in REST API versioning. Undertow and @MockBean were removed. Boot 4.1 followed in June 2026 with Spring gRPC support and SSRF protection for HTTP clients. The migration guide says to reach the latest 3.5.x first.”
Weak answers. Not knowing 4.0 exists, or describing it as a renamed 3.x.
23. “How would you design communication between Spring Boot microservices?”
Why they ask. Banks, payment networks and retailers often run Spring Boot microservices.
Sample answer. “I start by asking whether the call must be synchronous. For request-response, I define a typed client: in Boot 4, an @HttpExchange interface backed by RestClient, with timeouts set explicitly, retries only for idempotent operations, and a circuit breaker such as Resilience4j so one slow dependency does not exhaust my threads. For anything that can be eventual, I publish events to Kafka or RabbitMQ, and I use an outbox table so the database write and the event cannot drift apart. Each service owns its data; I avoid shared databases. Every service exposes readiness and liveness probes, propagates trace context, and versions its API. Consistency across services uses sagas with compensating actions, not distributed transactions.”
Weak answers. Synchronous chains of five services with no timeouts, or a shared database “for simplicity”.
For the full design round, see our system design interview questions page.
How to Practice These
Run a voice or text mock in OphyAI Interview Practice, which asks follow-up questions and gives a transcript and per-answer feedback, so you can check whether your @Transactional or auto-configuration answer survives a second “why?”. For the conversational rounds, OphyAI Interview Copilot gives real-time answer suggestions during live Zoom, Microsoft Teams and Google Meet interviews. For the live coding round, Coding Copilot in the desktop app (Premium plan, 15 credits a session) snaps the problem window with Cmd/Ctrl+Shift+A and returns how it read the problem, what to say first, the code, a dry run with edge cases and the Big O, in an overlay left out of screen sharing. Start practicing →
Daily routine: answer four questions aloud, then build one REST endpoint with a @WebMvcTest in 30 minutes. Pair this page with the Java interview questions for the language fundamentals, the SQL interview questions for the database round, and our coding interview patterns page for the algorithm round.
Frequently Asked Questions
Which Spring Boot version should I prepare for?
Prepare for the version in the job posting, and know the current line. As of November 2026, spring.io lists 4.1.2 as the current release, with 4.0.x still under open-source support until December 31, 2026, and 4.2.0 at release-candidate stage. Many enterprise teams still run 3.x, so know the 3.x to 4.x changes as well as the Jakarta migration from 2.x.
Do Spring Boot interviews still ask about Spring Boot 2?
Some do, especially at large banks and insurers with older services. spring.io’s support data lists commercial support for 2.7.x until June 2029, so 2.7 codebases still exist. Expect questions about migrating off it: the Java 17 baseline, the javax to jakarta change and the new security configuration style. New questions mostly assume 3.x or 4.x.
Is Spring Boot covered in the coding round or a separate round?
Usually separate. Most loops have an algorithm round where you pick the language, plus a technical conversation or code review on Spring Boot, JPA and APIs. Some teams give a take-home or a live exercise building a small REST endpoint. Ask the recruiter which format each round uses, then practice that format specifically.
Do I need to know Spring Cloud for a Spring Boot interview?
For microservice-heavy roles, know the concepts: service discovery, centralized configuration, gateways, circuit breakers and distributed tracing. You rarely need deep Spring Cloud API knowledge unless the posting names it. Interviewers care more about timeouts, retries, idempotency and data ownership than about which annotation enables a feature, so lead with the design reasoning.
Should I learn Spring WebFlux for a Spring Boot interview?
Only if the posting mentions reactive programming, WebFlux or Project Reactor. Most Spring Boot services use Spring MVC, and virtual threads on Java 21 give blocking code much of the concurrency benefit without a reactive rewrite. Be ready to explain when you would choose WebFlux, such as streaming or very high connection counts, and why you might not.
How long does it take to prepare for a Spring Boot interview?
If you work with Spring Boot daily, one to two weeks of focused review on auto-configuration, transactions, JPA, security and testing, plus a few timed endpoint builds, is a common plan. Coming from another backend framework, allow three to four weeks. These are typical ranges from prep guides, not a rule; adjust for seniority and the number of rounds.
How does OphyAI work in a Spring Boot interview?
Rehearse the spoken questions, such as @Transactional pitfalls or the security filter chain, in Interview Practice. In the live coding round, Coding Copilot in the desktop app reads the problem from your screen with Cmd/Ctrl+Shift+A, or transcribes a question asked aloud when you press Space or Cmd/Ctrl+Shift+L, and follow-ups remember the problem. Its overlay is left out of screen sharing, though not out of a webcam, keystroke and paste history, tab or focus tracking, or proctoring software.
Related Guides
- Java interview questions
- Fidelity interview guide (Java and Spring Boot live rounds)
- Visa interview guide (Spring Boot with WebFlux)
- Mastercard interview guide (Spring Boot microservices)
- American Express interview guide
- Home Depot interview guide
- Wayfair interview guide
- Nordstrom interview guide
- JPMorgan interview guide
- Goldman Sachs interview guide
- Capital One interview guide
- Oracle interview guide
- Walmart interview guide
- Technical interview prep for software engineers
Sources and verification notes
Sources checked November 2026 by fetching each page in this run. Version numbers and dates come only from these pages. The questions are original templates, not questions published by any employer.
- Spring Boot project page and the spring.io releases and generations API: 4.1.2 current GA; 4.2.0-RC2 prerelease; support dates per line (4.0.x open-source to December 31, 2026; 2.7.x commercial to June 2029).
- Spring Boot System Requirements: Java 17 to 27, Spring Framework 7.0.10+, Tomcat 11.0, Jetty 12.1, Servlet 6.1, GraalVM 25+.
- Spring Boot 4.0.0 available now (November 20, 2025) and Spring Boot 4.1.0 available now (June 10, 2026).
- Spring Boot 4.0 Migration Guide, 4.0 Release Notes, 4.1 Release Notes and 3.0 Release Notes: Jakarta EE 11, Undertow removal, renamed starters, Jackson 3,
@MockitoBean, gRPC; Java 17 and Jakarta in 3.0. - Spring Boot reference: auto-configuration, creating auto-configuration, @SpringBootApplication, externalized configuration, profiles, SQL databases, servlet web, Actuator endpoints, observability, testing, task execution, SpringApplication and native images.
- Spring Framework @Transactional and bean scopes; Spring Security servlet architecture.
- Stack notes in Related Guides are candidate-reported details summarized in this site’s guides.
Tags:
Share this article:
Rehearse your answers, then get live help on the call.
Practice free for up to 15 minutes, then use Interview Copilot in the OphyAI desktop app: real-time answer suggestions on Zoom, Teams and Google Meet, in a window hidden from screen sharing.
On your phone? Practice interview answers in the OphyAI app.
Hidden from screen share and recording; a webcam or a person in the room can still see your screen.
Related Articles
Java Interview Questions: 18 Answers With Code-Level Samples (2026)
Interview Tips
18 Java interview questions with sample answers: equals and hashCode, HashMap internals, JVM memory, concurrency, streams, records and virtual threads.
Read more →
AWS Interview Questions: 16 Sample Answers on EC2, S3, IAM & VPC
Interview Tips
16 AWS interview questions with sample answers: EC2, S3 storage classes, IAM roles, security groups vs NACLs, Lambda limits, Well-Architected and DR.
Read more →
24 Python Interview Questions & Answers (2026): GIL, Decorators, Code
Interview Tips
24 Python interview questions with sample answers: dict hashing, is vs ==, decorators, generators, the GIL vs asyncio, MRO, plus coding tasks and pandas.
Read more →