Spring Boot Interview Questions for Freshers

Your first Spring Boot interview is not testing whether you can memorise the framework — it is testing whether you understand what it quietly does on your behalf. Freshers who can explain the machinery behind three annotations and one main method usually clear the round. This set walks the twelve questions that decide most fresher screenings, each with a fast spoken answer, the mechanism underneath, and the follow-up that catches unprepared candidates.

Why interviewers ask Spring Boot questions to freshers

Almost every fresher Java role in Hyderabad now lists Spring Boot, because it is what teams actually ship. Interviewers use it as a maturity filter: a candidate who has only copied tutorials describes what they typed, while a candidate who understands the framework describes what happened when they ran it.

The questions stay deliberately shallow but demand precision. They are checking that you know Spring Boot is a convenience layer over the Spring container, not magic — and that you can name the pieces. If you can attach a one-line reason to every annotation in a starter project, you are already ahead of most applicants.

How to answer in an interview

Give a two-part answer to every question: the one-sentence definition, then the mechanism — what the classpath, the container, or the auto-configuration actually did. "Starters manage dependencies" is thin; "a starter is a curated set of compatible dependencies pulled in by one coordinate, so I never resolve versions myself" shows understanding.

Bring one concrete project into the room. When you can say "in my project the spring-boot-starter-web pulled in Tomcat, so java -jar just started a server on 8080," abstract questions turn into things you have watched happen. If any concept below feels shaky, refresh with the what is Spring Boot tutorial first.

Q1. What is Spring Boot and what problem does it solve?

Spring Boot is a layer on top of the Spring Framework that removes configuration boilerplate. It gives you auto-configuration, starter dependencies and an embedded server so you can run a production-grade application with a single main method and almost no XML.

The problem it solves is setup cost. Classic Spring MVC needed XML or Java config for the dispatcher servlet, view resolvers, data sources and more before a single endpoint worked. Boot ships opinionated defaults for all of that and lets you override only what you need.

Interview note: Follow-up: "does Spring Boot replace Spring?" No — it uses Spring underneath. Every bean, every injection still runs through the same Spring container; Boot only configures it for you.

Q2. What does the @SpringBootApplication annotation do?

It is a convenience annotation that bundles three others: @Configuration (this class can define beans), @EnableAutoConfiguration (turn on auto-configuration), and @ComponentScan (scan this package and below for components).

@SpringBootApplication
public class ShopApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShopApplication.class, args);
    }
}

Naming all three sub-annotations is the differentiator here — it proves you understand the annotation is not a single magic switch. The @ComponentScan part is also why your controllers and services must live in the same package or a sub-package of this class.

Interview note: Trap: "why do my beans not get picked up if I put them in a sibling package?" Because component scanning starts at the main class's package. Move them under it or add an explicit scanBasePackages.

Q3. What are Spring Boot starters?

Starters are curated dependency bundles named by capability. Adding spring-boot-starter-web pulls in Spring MVC, Jackson and an embedded Tomcat in compatible versions, so you declare one coordinate instead of hand-picking a dozen libraries.

The value is version harmony. The Boot parent POM knows which library versions work together, so you avoid the classic "jar hell" of mismatched dependencies. Common ones freshers should recognise: starter-web, starter-data-jpa, starter-test, starter-security.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

More detail lives in the Spring Boot starters guide.

Interview note: Follow-up: "where do the versions come from if you don't specify them?" From the spring-boot-starter-parent or the Boot dependency-management BOM, which pins a tested version for every managed library.

Q4. How does auto-configuration work?

Auto-configuration inspects the classpath and the beans you have already defined, then configures sensible defaults through conditional annotations. See spring-boot-starter-data-jpa and an H2 jar, and Boot wires a DataSource and an EntityManager for you.

The mechanism is @Conditional logic — annotations like @ConditionalOnClass and @ConditionalOnMissingBean decide whether each auto-configuration applies. Crucially, if you define your own bean, Boot backs off, so your configuration always wins.

Interview note: Trap: "how do you override an auto-configured bean?" Just declare your own bean of that type. @ConditionalOnMissingBean guards most defaults, so yours takes precedence. Read how auto-configuration works for the full flow.

Q5. What is dependency injection and how does Spring Boot do it?

Dependency injection means an object receives its collaborators from the container instead of creating them with new. Spring Boot builds the objects (beans), resolves what each one needs, and passes them in — usually through the constructor.

@Service
public class OrderService {
    private final PaymentClient paymentClient;

    public OrderService(PaymentClient paymentClient) {  // injected
        this.paymentClient = paymentClient;
    }
}

Constructor injection is the recommended style because it makes dependencies explicit and lets you mark fields final. Freshers should be able to explain that the container, not the developer, controls object creation — that inversion is the whole point. The dependency injection tutorial covers the variations.

Interview note: Follow-up: "constructor vs field injection — which and why?" Constructor, because it supports immutability, makes missing dependencies fail fast at startup, and keeps classes testable without reflection.

Q6. What is Inversion of Control?

IoC is the principle that a framework controls the flow and object lifecycle instead of your code. You declare what you need; the Spring container decides when to create it, wire it and destroy it. Dependency injection is one way IoC is implemented.

The mental shift is "don't call us, we'll call you." Your class no longer constructs its dependencies or manages their lifecycle — the container does. This is why the ApplicationContext is often called the IoC container.

Interview note: Trap: "is IoC the same as DI?" No. IoC is the broad principle; DI is a specific technique to achieve it. Keeping that hierarchy straight signals real understanding.

Q7. Where does the embedded server come from, and why does it matter?

spring-boot-starter-web bundles an embedded Tomcat, so your build produces a self-contained JAR you run with java -jar. There is no external server to install or a WAR to deploy into.

This is a genuine shift from older Java web apps that were packaged as WARs and dropped into a standalone Tomcat. The embedded model makes deployment and containerisation far simpler — one artifact, one command. You can swap Tomcat for Jetty or Undertow by changing the starter.

Interview note: Follow-up: "how do you change the default port 8080?" Set server.port=9090 in application.properties. Knowing that file is the right answer for most 'how do I configure X' questions.

Q8. What is application.properties used for?

It is the central place for externalised configuration — port, database URL, logging levels, custom app settings. Spring Boot reads it automatically at startup and binds values into beans, so the same JAR runs in different environments by changing this file.

server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/shop
logging.level.org.springframework=INFO

You can also use application.yml for the same purpose with nested syntax. The key idea to state is externalised configuration: code stays fixed, behaviour changes per environment. See application properties explained.

Interview note: Trap: "how do you have different settings for dev and prod?" Profiles — application-dev.properties and application-prod.properties, activated with spring.profiles.active.

Q9. What is a Spring bean?

A bean is any object the Spring container creates, wires and manages. You mark a class with a stereotype like @Component, @Service or @Repository, and the container instantiates it once (by default) and injects it wherever it is needed.

The word "managed" is the crux — beans are not new-ed by you, so the container can control their scope and lifecycle. The default scope is singleton: one shared instance per context.

Interview note: Follow-up: "difference between @Component, @Service and @Repository?" Functionally they are all components; the specialised ones document intent, and @Repository additionally translates persistence exceptions.

Q10. How do you create a simple REST endpoint in Spring Boot?

Annotate a class with @RestController, then map a method to a URL and HTTP verb with @GetMapping. The returned object is serialised to JSON automatically by Jackson.

@RestController
public class GreetingController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello from Spring Boot";
    }
}

@RestController is @Controller plus @ResponseBody, meaning every method returns data rather than a view name. This is the single most common hands-on task in a fresher round.

Interview note: Trap: "why does my endpoint return a whitelabel error page?" Usually the controller is outside the scanned package, or you used @Controller without @ResponseBody.

Q11. How do you run and test a Spring Boot application?

Run it with mvn spring-boot:run or java -jar target/app.jar after packaging. For tests, spring-boot-starter-test brings JUnit, Mockito and @SpringBootTest, which boots a context so you can test wiring end to end.

@SpringBootTest
class OrderServiceTest {
    @Autowired OrderService service;

    @Test
    void contextLoads() {
        assertNotNull(service);
    }
}

Even the trivial "context loads" test is valuable — it proves your beans wire together without errors, catching most misconfiguration at build time.

Interview note: Follow-up: "difference between @SpringBootTest and a plain unit test?" @SpringBootTest starts the whole container (slower, integration-style); a plain JUnit test with Mockito needs no context and is fast.

Q12. What is the difference between Spring and Spring Boot in one line?

Spring is the core framework providing the IoC container, MVC and data access; Spring Boot is an opinionated layer on top that auto-configures Spring, bundles dependencies via starters, and embeds a server so you skip the setup.

Freshers are expected to state that Boot does not add new fundamentals — beans, DI and MVC all come from Spring. It removes ceremony, not concepts. The full comparison lives in Spring vs Spring Boot.

Interview note: Trap: "can you use Spring without Spring Boot?" Absolutely — Boot is optional convenience. Many legacy apps run pure Spring with XML config.

How to prepare

Build one small REST project — a task list, a book catalogue, anything — with a controller, a service, a repository and an application.properties. Then break it deliberately: rename a package so scanning fails, remove the web starter, delete a constructor argument. Every error message you read teaches a mechanism that a question above is testing.

Rehearse the three-annotation breakdown of @SpringBootApplication (Q2) and the one-line Spring-vs-Boot answer (Q12) until they are automatic — both are asked almost verbatim. When you are comfortable here, move up to the Spring Boot annotations questions and skim the wider Spring Boot interview questions for 2026. Freshers who can defend their own project this way are exactly what our Java Full Stack with AI program prepares candidates to be.