If you’re new to Spring Boot, one of the first things that may confuse you is the “Starter.” You might have thought, “What’s a Starter? A magic box that pulls in everything I need?” That’s half right!
A Spring Boot Starter is a very convenient mechanism that bundles the dependencies required for a specific feature. Let’s walk through what it actually is and how to use it.

Note that this article assumes Spring Boot 3.x (3.2 or later recommended). The Starter name changes introduced in Spring Boot 4.x are covered later in the article under “Target Version of This Article and Starter Name Changes.”

What Is a Spring Boot Starter?

Spring Boot Starters were created to simplify the dependency declarations used in build tools such as Maven and Gradle.

For example, when building a web application, you would normally have to declare many dependencies individually in pom.xml (Maven) or build.gradle (Gradle), such as the Spring Web module, the Servlet API, and JSP.
As the project grows, this becomes tedious to manage, and problems such as version mismatches and dependency conflicts become more likely.

This is where Starters like spring-boot-starter-web come in. A Starter does not refer to a specific library. Rather, it is “a bundle of libraries commonly used in Spring Boot applications.” Simply adding spring-boot-starter-web as a dependency pulls every library needed for Spring Web into your project.

Adding Dependencies with a Spring Boot Starter

For example, in a project that uses Maven, you write the following in pom.xml.

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

It works the same way with Gradle. Write the following in build.gradle.

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

With just this, the major libraries a web application needs, such as Spring MVC, Jackson (JSON processing), and Tomcat (embedded server), are added automatically.

Types of Spring Boot Starters

There is a wide variety of Starters covering many features, including database access (spring-boot-starter-data-jpa and others), security (spring-boot-starter-security), and testing (spring-boot-starter-test).
In addition to the official Spring Boot Starters, there are also community-made Starters (be sure to verify that a Starter is trustworthy before using it).

With Spring Initializr (https://start.spring.io/), you can select the Starters you need and easily generate a project skeleton.

Practical Rules for Choosing Starters Without Regret

Adding too many Starters just because they are convenient can increase startup time and configuration complexity.
In practice, narrowing your initial dependencies with the following rules leads to a more stable setup.

  • Start with a minimal configuration (for example, web + actuator + test)
  • Add Starters you have no concrete plan to use only when you actually need them
  • Separate Starters not needed in production (development aids) using profiles or dependency scopes
  • Let the Spring Boot BOM manage versions rather than specifying them individually

Not going “all-in from the start” is the shortest route to fewer problems.

Common Pitfalls

1. Assuming No Configuration Is Needed Just Because You Added a Starter

A Starter is a mechanism for “gathering the necessary libraries.” It does not automatically configure things to match your business requirements.
For example, once you add the Security Starter, you still need to explicitly design your authorization rules and public endpoints.

What Happens When You Add spring-boot-starter-security

spring-boot-starter-security is the classic example of a Starter that “dramatically changes behavior just by being added,” so it is worth a closer look.

implementation 'org.springframework.boot:spring-boot-starter-security'

Add this one line and start the application, and the following happens automatically.

  • Every endpoint now requires authentication (opening / in a browser redirects to a login form, and API clients receive a 401)
  • You can log in with the username user and a random password printed in the startup log
  • CSRF protection and security headers (such as X-Content-Type-Options) are enabled

Many people are surprised that “the page that was working suddenly turned into a login screen,” but this is the expected behavior. In a real application, you need to define a SecurityFilterChain Bean and explicitly design “which paths are public and which require authentication.”

How to write authorization rules in a minimal setup, and how to fix the username and password in application.properties, are covered in How to Implement Basic Authentication with Spring Security.

2. Ignoring Dependency Conflicts Until the Cause Is Hidden

If you keep manually overriding versions, the application may suddenly fail to start one day.
When something feels off about your dependencies, visualize them early with mvn dependency:tree or ./gradlew dependencies.

3. Adopting Overlapping Starters of the Same Kind

For example, unintentionally mixing spring-boot-starter-web and spring-boot-starter-webflux makes your design direction prone to drift.
It is important to decide up front whether you are going with synchronous MVC or the reactive stack.

Not Sure What to Add First?

For learning or a small API, the following is enough to begin with.

  • spring-boot-starter-web
  • spring-boot-starter-validation
  • spring-boot-starter-test

Adding dependencies incrementally is easier to manage: add spring-boot-starter-data-jpa only when you use a database, and add spring-boot-starter-security once you need authentication.

The following articles are good entry points for how to actually use each Starter.

Quick Reference of Commonly Used Starters

Here is a summary of the Starters that typically come up first, organized by purpose. To let you quickly check “what exactly gets pulled in when I add this,” the main bundled libraries are listed as well. The groupId is org.springframework.boot in every case, so the coordinates take the form org.springframework.boot:<artifactId>. Versions are managed by the Spring Boot BOM, so there is no need to specify them individually.

PurposeStarter (artifactId)Main bundled libraries
Foundation for all Startersspring-boot-starterspring-boot, spring-boot-autoconfigure, spring-boot-starter-logging (Logback), snakeyaml, jakarta.annotation-api
REST APIspring-boot-starter-webspring-boot-starter, spring-web, spring-webmvc, spring-boot-starter-json (Jackson), spring-boot-starter-tomcat
Reactive Webspring-boot-starter-webfluxspring-boot-starter, spring-webflux, spring-boot-starter-reactor-netty, spring-boot-starter-json
Input validationspring-boot-starter-validationspring-boot-starter, hibernate-validator, tomcat-embed-el
Relational DB accessspring-boot-starter-data-jpaspring-boot-starter-jdbc (HikariCP), hibernate-core, spring-data-jpa, spring-boot-starter-aop
Authentication / authorizationspring-boot-starter-securityspring-boot-starter, spring-security-config, spring-security-web, spring-aop
Monitoring / health checksspring-boot-starter-actuatorspring-boot-starter, spring-boot-actuator-autoconfigure, micrometer-observation, micrometer-core
Testingspring-boot-starter-testspring-boot-test, spring-test, JUnit Jupiter, Mockito, AssertJ, Hamcrest, JSONassert, json-path

For example, when you add spring-boot-starter-web, the foundational spring-boot-starter is pulled in along with it. As a result, you almost never need to declare the foundational Starter explicitly on its own.

The exact list of bundled libraries varies by Spring Boot version, so when in doubt, refer to the Starter list in the official reference. For guidance on when reactive web (WebFlux) is a good fit, see Introduction to Spring Boot WebFlux.

What Is the Difference Between a Starter and AutoConfiguration?

Beginners often confuse the relationship between Starters and AutoConfiguration. Their roles are clearly separated.

  • Starter: “A set of dependencies that bundles the required libraries.” It contains almost no code of its own. Its job is to shorten what you write in pom.xml / build.gradle.
  • AutoConfiguration: “A mechanism that looks at the libraries on the classpath and registers Beans automatically.” This is handled by spring-boot-autoconfigure and is activated by conditions such as @ConditionalOnClass.

It is a two-stage arrangement: adding spring-boot-starter-web puts Tomcat and Spring MVC on the classpath, and the AutoConfiguration that detects them automatically configures the DispatcherServlet and the embedded Tomcat. The details of this mechanism are explained in How Spring Boot AutoConfiguration Works.

What If I Want to Use Jetty or Undertow Instead of Tomcat?

spring-boot-starter-web includes Tomcat as the embedded server. If you want to swap in a different server, exclude the Tomcat Starter and add the alternative Starter.

For Maven, it looks like this.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

For Gradle, it looks like this.

dependencies {
    implementation('org.springframework.boot:spring-boot-starter-web') {
        exclude group: 'org.springframework.boot', module: 'spring-boot-starter-tomcat'
    }
    implementation 'org.springframework.boot:spring-boot-starter-jetty'
}

Because “a Starter only bundles things,” you can exclude and replace just part of it like this.

Why Don’t I Need to Specify a Version?

Starter declarations have no version because spring-boot-starter-parent (Maven) or the Spring Boot Gradle plugin manages compatible versions collectively through a BOM (Bill of Materials). Once you decide the Spring Boot version in one place, a verified combination of Spring Framework, Hibernate, Jackson, Tomcat, and the rest is selected automatically.

Overriding versions individually breaks this consistency and tends to cause startup errors. The basic rule is “leave versions to the BOM.”

Target Version of This Article and Starter Name Changes

If you are migrating from 2.x to 3.x, there are breaking changes such as the Java 17 requirement and the javax → jakarta replacement, so refer to the Spring Boot 2.x to 3.x Migration Guide.

Note that Spring Boot 4.x, as part of its module reorganization, introduces a Starter named spring-boot-starter-webmvc for Web MVC. Check the official release notes for the version you adopt to see whether the existing spring-boot-starter-web can still be used. The core idea covered in this article, that “a Starter bundles dependencies,” remains the same regardless of version.

Practical Commands for Inspecting Dependencies

To understand “why is this library in my project,” inspecting the dependency tree is effective.

Maven

./mvnw dependency:tree

Gradle

./gradlew dependencies

Once your dependencies start to bloat, simply removing unneeded Starters can improve startup speed and maintainability.

Summary

As we have seen, Spring Boot Starters are a powerful tool for simplifying dependency management and improving development efficiency. Understanding Starters is essential when learning Spring Boot.
Try out a variety of Starters and experience the convenience for yourself!

Next Steps

Once you understand how Starters work, moving on to the following articles will reveal what goes on “behind the scenes” in Spring Boot.