DEV Community: kundan kumar

1.Spring Boot Core & Basics

kundan kumar — Mon, 05 Oct 2026 18:03:42 +0000

Demystifying Spring Boot Core & Basics: The Ultimate Deep-Dive Interview Guide

Whether you are preparing for a senior engineering interview or architecting modern enterprise systems, Spring Boot Core & Basics is the foundational filter interviewers use to distinguish developers who merely use annotations from those who understand the framework's runtime mechanics.

1. What is Spring Boot, and how is it different from the Spring Framework?

The Core Philosophy

The traditional Spring Framework is an enterprise-grade Inversion of Control (IoC) and Dependency Injection (DI) framework. While modular and expressive, Spring historically suffered from configuration overhead: developers had to manually wire database drivers, dispatchers, template engines, and transaction managers through hundreds of lines of XML or verbose @Configuration classes, package them as WAR files, and deploy them to external servlet containers.

Spring Boot is not an alternative to the Spring Framework; it is an opinionated, rapid-application-development platform built directly on top of Spring. It provides automatic configuration, production-grade observability, curated dependency sets, and embedded servers to turn multi-day setup pipelines into seconds.

Architectural Comparison

Dimension	Spring Framework	Spring Boot
Primary Goal	Provides core DI, IoC, AOP, and modular enterprise capabilities.	Eliminates boilerplate configuration and accelerates bootstrapping.
Configuration Model	Explicit configuration: Developers must define every `DataSource`, `DispatcherServlet`, and ViewResolver manually.	Convention over Configuration: Applies opinionated defaults automatically via `@EnableAutoConfiguration`.
Server & Deployment	Requires an external application server (Tomcat, Jetty, WildFly). Deployed as a WAR.	Contains an embedded servlet container (Tomcat/Jetty/Undertow). Deployed as an executable fat JAR.
Dependency Management	Manual specification of every library and transitive version; high risk of version conflicts (JAR Hell).	Uses Starters and a centralized Bill of Materials (BOM) to eliminate version incompatibilities.
Production Readiness	Requires custom code or third-party libraries for health checks, metrics, and application telemetry.	Native Actuator endpoints out of the box (`/health`, `/metrics`, `/prometheus`).
Bootstrap Entry Point	`web.xml` or `WebApplicationInitializer` mapped inside an external container.	Standard Java `public static void main(String[] args)` method invoking `SpringApplication.run()`.

Interview Tip: Emphasize that Spring Boot does not generate code or replace Spring APIs. At runtime, it configures the exact same Spring beans you would have configured manually, using conditional evaluation (@Conditional).

2. What are the advantages of using Spring Boot?

When an interviewer asks for advantages, avoid generic phrases like "it's fast." Group your response into structural architectural pillars:

Auto-Configuration (@EnableAutoConfiguration): Analyzes the classpath, system properties, and existing bean definitions to automatically wire the ApplicationContext without boilerplate code.
Curated Starters (spring-boot-starter-*): Single, cohesive dependencies that aggregate compatible transitive libraries tested against a verified BOM.
Embedded Web Servers: Bundles Apache Tomcat, Jetty, or Undertow directly into the application archive. No external container configuration or installation is required.
Production-Ready Observability via Actuator: Provides operational insights (metrics, health indicators, thread dumps, loggers, env variables) via secure HTTP/JMX endpoints.
Zero Code Generation & Zero XML: Relies entirely on runtime reflection, dynamic proxies, and Java metadata. No XML parsing bottlenecks or code synthesis steps.
Cloud-Native & Container Ergonomics: Built-in support for Docker Layered JARs, Cloud-Native Buildpacks, Graceful Shutdown, and GraalVM Ahead-Of-Time (AOT) compilation for near-instant native startup.

3. What is the purpose of the `@SpringBootApplication` annotation?

@SpringBootApplication is the primary meta-annotation placed on the root bootstrap class. It serves as the unified entry point that activates Spring Boot’s auto-configuration engine, initiates component scanning, and defines the root configuration class.

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

Key Attributes Interviewers Expect You to Know:

scanBasePackages / scanBasePackageClasses: Overrides the default component scan root package.
exclude / excludeName: Excludes specific auto-configuration classes (e.g., exclude = {DataSourceAutoConfiguration.class}).
proxyBeanMethods (inherited from @SpringBootConfiguration): Controls whether @Bean methods inside the class are wrapped in CGLIB dynamic proxies to enforce singleton lifecycle semantics (defaults to true).

4. Which annotations does `@SpringBootApplication` combine internally?

@SpringBootApplication is composed of three fundamental annotations (the "Spring Boot Trinity"):

1. `@SpringBootConfiguration`

A specialization of Spring's standard @Configuration. It marks the class as a source of bean definitions for the ApplicationContext. The distinction is that @SpringBootConfiguration allows Spring's testing infrastructure (@SpringBootTest) to automatically locate the primary configuration root.

2. `@EnableAutoConfiguration`

Enables Spring Boot's auto-configuration discovery mechanism. Under the hood, it imports AutoConfigurationImportSelector, which reads auto-configuration candidates from:

META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports (Spring Boot 3.x)
META-INF/spring.factories (Spring Boot 2.x)

3. `@ComponentScan`

Directs Spring to scan for classes annotated with @Component, @Service, @Repository, @Controller, and @RestController. By default, scanning starts from the package of the annotated class and scans downward through all sub-packages.

5. What is the role of the `SpringApplication.run()` method?

SpringApplication.run() is not just a helper method; it is the orchestrator of the entire application bootstrap pipeline.

ConfigurableApplicationContext context = SpringApplication.run(MyApplication.class, args);

Step-by-Step Execution Sequence

Instantiation of SpringApplication:
- Deduces the application type: WebApplicationType.SERVLET, REACTIVE, or NONE (batch/worker) based on classpath markers.
- Loads BootstrapRegistryInitializer and ApplicationContextInitializer candidates.
- Loads ApplicationListener instances from imports.
- Determines the main application entry-point class.
Environment Preparation:
- Creates the ConfigurableEnvironment (resolving OS environment variables, JVM system properties, command-line arguments, and application.yml/.properties).
- Binds the environment to the Spring application.
Banner Printing: Prints the ASCII art banner unless explicitly suppressed (Banner.Mode.OFF).
Context Creation:
- Instantiates the matching ApplicationContext (e.g., AnnotationConfigServletWebServerApplicationContext for servlet-based web apps).
Context Preparation:
- Applies initializers, attaches the prepared environment, registers command-line arguments, and fires the ApplicationEnvironmentPreparedEvent.
Context Refresh (The Core Step):
- Executes refresh() from AbstractApplicationContext.
- Evaluates BeanFactoryPostProcessors, registers BeanPostProcessors.
- Starts the embedded web server (e.g., binds Tomcat to port 8080).
- Eagerly instantiates all singleton beans.
Post-Refresh & Runner Execution:
- Locates and invokes all beans implementing ApplicationRunner and CommandLineRunner.
Event Publication: Publishes the ApplicationReadyEvent. The application is now fully initialized.

6. What is the significance of the `main` method in a Spring Boot application?

In traditional Java EE architectures, the servlet container was the host process: Tomcat started first, parsed web.xml, and loaded the application WAR into its memory space.

In Spring Boot, this model is inverted (Inversion of Deployment):

The Java main method is the driver of the entire operating system process.
The application runs as a standalone Java process (java -jar my-service.jar).
The embedded Tomcat/Jetty server is treated as an internal Spring bean inside the ApplicationContext rather than an external supervisor.

When packaged as an executable Fat JAR, the Main-Class entry in META-INF/MANIFEST.MF points to Spring Boot's internal loader class: org.springframework.boot.loader.launch.JarLauncher. This launcher sets up an isolated class loader capable of reading nested JARs and finally delegates execution to your application's main() method.

7. Explain the concept of "opinionated defaults" in Spring Boot.

"Opinionated Defaults" embodies the Convention over Configuration pattern. Spring Boot makes educated, opinionated assumptions about how a modern production backend should be constructed, providing pre-configured sensible defaults:

Default Server: Assumes you need Apache Tomcat listening on port 8080.
Default Database Connection Pool: Assumes HikariCP is the best connection pool for performance.
Default JSON Parser: Assumes Jackson (ObjectMapper) is the serialization engine.
Default Logging Engine: Assumes SLF4J with Logback, pre-configured for console output with ANSI color-coding and timestamp formatting.
Default ORM Provider: Assumes Hibernate when Spring Data JPA is present.

The "Escape Hatch" Principle

Spring Boot is opinionated, but not stubborn. Every single default can be overridden. If you define your own custom bean, Spring Boot's conditional logic (@ConditionalOnMissingBean) detects it and steps back.

8. What is the difference between Spring Boot and Spring MVC?

This is one of the most frequently asked basic questions in junior to mid-level interviews. Many developers confuse the two because spring-boot-starter-web pulls in Spring MVC.

Tabular Comparison

Dimension	Spring MVC	Spring Boot
Framework Type	Presentation-tier Web & REST framework.	Application bootstrapping and auto-configuration framework.
Architectural Scope	Focuses strictly on HTTP handling: `DispatcherServlet`, Controllers, Request Mappings, and Model/View binding.	Focuses on the entire application lifecycle: dependency packaging, configuration, metrics, embedded runtimes, and persistence wiring.
Servlet Setup	Requires manual registration of `DispatcherServlet` in `web.xml` or via `WebApplicationInitializer`.	Automatically creates, configures, and registers `DispatcherServlet` at `/` out of the box.
Server Requirement	Cannot run on its own; must be deployed onto an external servlet container (Tomcat, Jetty).	Runs independently as a standalone JVM process using an embedded web server.
Relation to Each Other	Built within the core Spring Framework.	Packages, auto-configures, and manages Spring MVC via `spring-boot-starter-web`.

9. What are the different ways to create a Spring Boot application?

There are 4 standard mechanisms to scaffold a Spring Boot application:

Spring Initializr Web UI (start.spring.io): The official web generator allowing developers to select build tools (Maven/Gradle), language (Java/Kotlin/Groovy), Spring Boot version, packaging (JAR/WAR), Java baseline, and dependencies.
IDE Built-in Wizards: IntelliJ IDEA Ultimate, Eclipse (STS - Spring Tool Suite), and VS Code (Spring Boot Extension Pack) integrate directly with the Spring Initializr API.
Spring Boot CLI (spring init): A terminal-based tool enabling fast CLI scaffolding (e.g., spring init -d=web,data-jpa --build=gradle my-app).
Manual Build Configuration: Writing a pom.xml or build.gradle file manually by adding spring-boot-starter-parent and desired starters, then creating a @SpringBootApplication entry point.

10. What is Spring Initializr, and how do you use it?

Spring Initializr is an extensible web service and open-source project (spring-io/initializr) that generates the skeleton structure for Spring Boot applications.

How it Works Internally

Initializr exposes a RESTful metadata API endpoint at https://start.spring.io. When you interact with the UI, IDE, or CLI, it sends an HTTP GET/POST request with query parameters describing the project requirements. The service returns a dynamically assembled .zip archive containing:

Standard Maven/Gradle directory structure (src/main/java, src/main/resources, src/test/java).
Pre-configured pom.xml or build.gradle containing correct starters and BOM definitions.
Maven Wrapper (mvnw, .mvn/) or Gradle Wrapper (gradlew) to ensure consistent builds without local tool installations.
Default application.properties or application.yml.
A baseline @SpringBootApplication class and a passing context-load test.

Using Spring Initializr via cURL

curl https://start.spring.io/starter.zip \
  -d dependencies=web,data-jpa,postgresql \
  -d javaVersion=21 \
  -d bootVersion=3.3.0 \
  -d artifactId=order-service \
  -d name=order-service \
  -o order-service.zip && unzip order-service.zip

11. What is the minimum Java version required for Spring Boot 3.x?

Direct Answer

The minimum requirement for Spring Boot 3.x is Java 17 LTS.

Deep Architectural Rationale (Senior Interview Perspective)

When interviewers ask this question, they are testing whether you understand the structural ecosystem changes that occurred between Spring Boot 2.x and 3.x:

Jakarta EE 9/10 Namespace Migration:
- Oracle transferred Java EE to the Eclipse Foundation. Due to trademark restrictions on the javax name, all enterprise packages changed from javax.* to jakarta.* (e.g., jakarta.persistence, jakarta.servlet, jakarta.annotation).
- Spring Boot 3 completely dropped support for javax.* web/persistence specifications.
Modern Java Language Features in Framework Internals:
- Spring Framework 6.x and Spring Boot 3.x internally leverage modern Java features including Java Records for immutable DTOs/projections, sealed classes, pattern matching, and enhanced switch expressions.
GraalVM Native Image Compilation:
- Spring Boot 3 introduced first-class Ahead-Of-Time (AOT) engine support powered by GraalVM. AOT requires Java 17+ bytecode semantics to generate optimized native binaries with sub-50ms startup times.
Virtual Threads (Project Loom):
- Beginning in Spring Boot 3.2+ (on Java 21 LTS), applications can execute high-throughput blocking I/O using lightweight Virtual Threads by setting a single property:

   spring.threads.virtual.enabled=true

12. What are the key components of Spring Boot?

Spring Boot is constructed around five foundational subsystems:

Spring Boot Starters: Curated dependency descriptors grouping functional dependencies under a unified version management umbrella.
Auto-Configuration Engine: The conditional configuration subsystem driven by @EnableAutoConfiguration and @Conditional* annotations.
Spring Boot Actuator: The operations management module exposing runtime telemetry, health indicators, audit hooks, and metric scrapers.
Spring Boot DevTools: The developer productivity engine providing classloader-isolated live reloads, automatic server restarts, and cache invalidation during development.
Spring Boot CLI: The command-line interface leveraging Groovy and Grape for rapid prototyping and executable scripting.

13. What is `spring-boot-starter-parent` and why is it used?

spring-boot-starter-parent is a special parent POM in Maven that enterprise applications can inherit from to establish a standardized build and runtime baseline.

What It Configures Under the Hood:

Centralized Dependency Management: Inherits from spring-boot-dependencies (the master BOM). It manages compatible versions for over 200 common third-party libraries (Hibernate, Jackson, Logback, Mockito, etc.). You do not need to specify <version> tags in your own dependencies.
Default Compiler Configuration: Sets default Java version source/target flags and enforces UTF-8 character encoding.
Resource Filtering: Configures Maven resource filtering on application.properties and application.yml files, allowing property interpolation using the @..@ delimiter syntax (e.g., app.version=@project.version@).
Plugin Configurations: Pre-configures plugins like spring-boot-maven-plugin, maven-surefire-plugin, and maven-failsafe-plugin with repackaging goals to produce executable fat JARs.

What if You Cannot Inherit from `spring-boot-starter-parent`?

Many enterprises require projects to inherit from an internal corporate parent POM (corp-parent-pom). In Maven, multiple inheritance is illegal.

The Solution: Import the BOM directly in the <dependencyManagement> section using scope=import:

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>3.3.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

14. How does Spring Boot simplify dependency management?

Traditional Java projects frequently suffer from "JAR Hell"—runtime ClassNotFoundException or NoSuchMethodError caused by transitive dependency collisions (e.g., Library A pulls Jackson 2.12, while Library B pulls Jackson 2.15).

Spring Boot resolves this using a two-tier strategy:

1. Bill of Materials (BOM) Pattern

Through spring-boot-dependencies, the Spring team rigorously tests and curates an exact matrix of compatible versions across the entire Java backend ecosystem. When you declare dependencies:

<dependencies>
    <!-- Notice: NO <version> tag! -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
</dependencies>

The version is automatically resolved to the exact compatible version defined by the BOM, completely eliminating manual version coordination.

2. Functional Aggregation (Starters)

Instead of searching for and adding separate dependencies for Spring Web, Tomcat, Jackson Core, Jackson Databind, and Jakarta Validation, you add one starter: spring-boot-starter-web. The starter brings in the entire cohesive stack.

15. What is the Spring Boot CLI and what can you do with it?

The Spring Boot CLI is a lightweight command-line interface designed for rapid prototyping, system automation, and script execution using Groovy.

Key Capabilities:

Run Standalone Groovy Scripts (spring run): Allows you to write concise Groovy files without explicit package declarations, imports, or build files. The CLI uses Groovy Grape (@Grab) to automatically resolve missing imports (like @RestController, @GetMapping) and download corresponding starters on the fly:

@RestController
class HelloController {
    @GetMapping("/")
    String home() {
        "Hello from Spring Boot CLI!"
    }
}

Executing spring run HelloController.groovy compiles the script, downloads Spring Web, spins up an embedded Tomcat server, and serves the endpoint on port 8080.

Project Scaffolding (spring init): Generates new Spring Boot skeletons from the terminal:

spring init --dependencies=web,data-jpa --build=maven my-project

Packaging Executables (spring jar): Packages Groovy scripts into standard executable fat JARs (spring jar app.jar HelloController.groovy).

series navigation

⬅️ Previous: Series Introduction & Roadmap
➡️ Next: Part 02 — Auto-Configuration & Configuration
📌 View the Complete Series Roadmap

Spring Boot & Java Backend Interview Preparation: Complete Roadmap

kundan kumar — Mon, 05 Oct 2026 17:55:27 +0000

250+ real & frequently asked questions covering the entire Spring Boot ecosystem, from basics to advanced. Organized by topic with difficulty indicators.

🟢 Basic | 🟡 Intermediate | 🔴 Advanced

Spring Boot Core & Basics
Auto-Configuration
Configuration & Properties
Profiles
Embedded Servers & Deployment

To be published ...

Spring Boot Starters
Spring Boot Actuator
Spring Boot DevTools
Spring Core — IoC & Dependency Injection
Bean Lifecycle & Scopes
Spring Annotations Deep Dive
Aspect-Oriented Programming (AOP)
Spring MVC & Web Layer
REST API Design & Best Practices
Exception Handling
Request Validation
Filters & Interceptors
Spring Data JPA & Hibernate
JPA Entity Relationships & Mapping
Querying & Performance (JPA)
Transaction Management
Spring Security
JWT, OAuth2 & Authentication
Spring Boot Testing
Microservices Architecture
Microservices Design Patterns
Spring Cloud
Messaging — Kafka, RabbitMQ, JMS
Caching — Redis, Spring Cache
Java Concurrency & Async
Reactive Programming & WebFlux
Database, Migrations & Connection Pooling
Logging & Monitoring
Docker, Kubernetes & Cloud Deployment
Performance Tuning
Miscellaneous & Scenario-Based

SlumberSafe: An AI-Led Bedside Companion to Park Your Worries

kundan kumar — Mon, 05 Oct 2026 06:19:02 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built SlumberSafe, a voice-first, AI-led bedside companion designed for a close friend who struggles with late-night anxiety and "doomscrolling" before bed.

Whenever they try to sleep, their brain starts reminding them of unfinished tasks, emails they forgot to send, and worries about tomorrow. SlumberSafe solves this by acting as a calm, empathetic listener. You simply lie in bed, tap "Start Wind-Down", and dictate your worries. The AI listens, naturally responds with comforting reassurance, and quietly extracts any actionable tasks you mention, safely "parking" them in a MongoDB database for the next morning. Finally, it gently guides you to sleep with a whispered bedtime story.

Demo

slumber-safe-x8cd.vercel.app

Code

kundan424 / slumberSafe

🌙 SlumberSafe: Bedside Debrief & Doomscroll Deterrent

Built for Hacktoberfest 2026 (#hf26challenge) — DEV Challenge #1: "Build for a Friend"
A private, voice-first bedtime decompression companion designed to break the late-night racing thoughts and doomscrolling cycle.

🌟 The Story & Problem Statement

Late at night around 11:00 PM, unfinished to-dos, racing thoughts, and tomorrow's stresses create bedtime friction. To cope with bedtime anxiety, many people turn to blue light feeds and social media, doomscrolling past 1:00 or 2:00 AM.

Commercial AI chatbots fail at this use case:

They require staring into bright text chat UIs.
They do not automatically lock away to-dos for the next morning.
They log intimate vulnerable thoughts onto closed commercial cloud servers.

SlumberSafe solves this with an OLED screen-free voice companion powered by open-weight AI (Meta's Llama 3.3 via Groq) and soft whispered bedside audio (ElevenLabs).

✨ Features (MVP Scope)

Late-Night Doomscroll Interceptor Banner
- Active bedtime…

View on GitHub

How I Built It

I wanted SlumberSafe to be lightning fast and completely hands-free. To achieve this, I built the app using Next.js 14 (App Router) and relied heavily on open-weight AI models.

json
{
  "assistant_response": "1-2 warm conversational sentences.",
  "tasks": [{"text": "Finish the report tomorrow morning", "priority": "normal"}],
  "next_question": "A short natural follow-up question.",
  "session_complete": false,
  "should_offer_story": false
}

the Llama 3.3 70B open-weight model via the Groq SDK. Llama 3.3 is incredibly fast and capable of deep empathy and structured JSON extraction in a single pass.

I engineered a prompt that forces the LLM to output a strict JSON schema on every conversational turn:

This allows the backend to automatically map the extracted tasks into MongoDB Atlas, while streaming the assistant_response back to the frontend to be spoken aloud using the native Web Speech API (webkitSpeechRecognition) and ElevenLabs for realistic whispered TTS.

The frontend implements a strict state machine (LISTENING → PROCESSING → AI_SPEAKING) to prevent the microphone from picking up the AI's own voice and creating an echo loop.

Why Does Open Innovation Matter?

Open innovation made this project possible by providing access to world-class, open-weight models like Llama 3.3. If I had to rely on a slow, closed API, the conversational latency would ruin the relaxing, bedside experience. Because Llama is open and hosted on ultra-fast inference hardware like Groq, the responses feel instantaneous and natural. Open innovation also allows us to run these powerful models locally or on edge devices in the future, meaning sensitive, late-night personal thoughts wouldn't even need to leave the user's bedroom network.

Prize Categories

Best Use of Open-Weight AI: For leveraging Llama 3.3 to handle empathy and data extraction simultaneously.
Accessibility & UX: For building a completely hands-free, dark-themed voice interface designed for tired eyes.