How to Slash Spring Boot Startup Time by 70% with 7 Proven Optimizations

1. Lazy Initialization – Load Beans on Demand

Enable Spring Boot’s lazy initialization by setting spring.main.lazy-initialization=true in application.properties. This defers the creation of all beans until they are first needed, cutting I/O and dependency resolution during startup.

# application.properties
spring.main.lazy-initialization=true

For beans that must be eager, annotate them with @Lazy(false):

@Bean
@Lazy(false)
public CriticalBean criticalBean() {
    return new CriticalBean();
}

Typical impact: e‑commerce app startup drops from 8.2 s to 5.1 s (‑38%).

2. Precise Component Scanning – Exclude Unnecessary Packages

Limit the scan base packages in @SpringBootApplication to only the required modules:

@SpringBootApplication(
    scanBasePackages = {"com.your.package.service", "com.your.package.controller"}
)
public class Application {}

Further exclude patterns or annotations via @ComponentScan:

@ComponentScan(excludeFilters = {
    @Filter(type = FilterType.REGEX, pattern = "com.external.*"),
    @Filter(type = FilterType.ANNOTATION, classes = Repository.class)
})
public class AppConfig {}

Result: a financial system reduced its startup from 12 s to 7.3 s (‑39%).

3. JVM Parameter Tuning – Faster VM Boot

Apply a set of JVM flags that skip heavyweight compilation and pre‑allocate memory:

java -XX:TieredStopAtLevel=1 \
     -Xverify:none \
     -XX:+AlwaysPreTouch \
     -XX:MetaspaceSize=128m \
     -XX:MaxMetaspaceSize=128m \
     -jar your-app.jar

Key flag meanings: -XX:TieredStopAtLevel=1 – disables C2 JIT compilation. -Xverify:none – turns off byte‑code verification (trusted environments). -XX:+AlwaysPreTouch – touches all memory pages at startup (production). -XX:MetaspaceSize/MaxMetaspaceSize=128m – prevents frequent metaspace expansion.

Measured gains: logistics system startup improves from 9 s to 5.4 s (‑40%).

4. Auto‑Configuration Slimming – Drop Unused Boot Starters

Print the auto‑configuration report and disable unnecessary classes:

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(MyApp.class);
        app.setBannerMode(Banner.Mode.OFF);
        app.setAdditionalProfiles("debug"); // prints report
        app.run(args);
    }
}

Exclude specific auto‑configurations:

@EnableAutoConfiguration(exclude = {
    DataSourceAutoConfiguration.class,
    HibernateJpaAutoConfiguration.class,
    RabbitAutoConfiguration.class
})
public class AppConfig {}

Example: an IoT platform removed 15 auto‑config classes, cutting startup from 7.8 s to 4.6 s (‑41%).

5. Class‑Loading Optimization – Reduce Load Overhead

Analyze class loading with the JDK tool:

# Use JDK built‑in tool
java -verbose:class -jar your-app.jar | grep "loaded"

Trim dependencies by excluding transitive starters (e.g., Tomcat) and enable Jar indexing in Maven:

<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>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>
            <index>true</index>
        </archive>
    </configuration>
</plugin>

Result: a social app reduced class‑load count from 8,732 to 5,211 (‑40%) and startup from 2.3 s to 1.1 s (‑52%).

6. Database Connection Optimization – Lazy DataSource

Declare the datasource bean as lazy so the connection is established only when first used:

@Configuration
public class LazyDataSourceConfig {
    @Bean
    @Lazy
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
}

Adjust HikariCP pool settings for faster fail‑fast behavior:

# HikariCP settings
spring.datasource.hikari.initialization-fail-timeout=30000
spring.datasource.hikari.connection-timeout=5000
spring.datasource.hikari.maximum-pool-size=5

Impact: CRM system startup drops from 4.2 s to 1.3 s (‑69%).

7. Compilation Optimizations – GraalVM Native Image & Layered Compilation

Build a native image with GraalVM:

# Install GraalVM native‑image tool
gu install native-image
# Package as native image
mvn -Pnative package

Use Spring’s AOT flag for layered compilation:

# Development (fast compile)
-Dspring.aot.enabled=false -XX:TieredStopAtLevel=1

# Production (full optimization)
-Dspring.aot.enabled=true -XX:TieredStopAtLevel=4

Result: payment service cold start improves from 8 s to 2.3 s (‑71%).

8. Comprehensive Case Study – End‑to‑End E‑Commerce Optimization

Before optimization:

Startup time: 14.6 s

Memory usage: 1.2 GB

Classes loaded: 8,732

Optimization steps applied:

Enable lazy initialization (‑3.2 s)

Fine‑tune component scan range (‑2.8 s)

Apply JVM flags (‑1.9 s)

Exclude 12 auto‑configuration classes (‑2.1 s)

Trim unnecessary dependencies (‑1.3 s)

Lazy datasource (‑0.9 s)

Adopt layered compilation (‑2.4 s)

After optimization:

Startup time: 4.3 s (‑70.5%)

Memory usage: 680 MB (‑43%)

Classes loaded: 5,211 (‑40%)

9. Checklist for Spring Boot Startup Tuning

Enable lazy initialization.

Configure component scan to include only required packages.

Apply performance‑oriented JVM startup flags.

Exclude unnecessary auto‑configuration classes.

Analyze and prune transitive dependencies.

Delay non‑critical resource connections (e.g., datasource).

Consider AOT or layered compilation for production.

By applying these seven “magic” techniques, most Spring Boot services can achieve a startup‑time reduction exceeding 70 %, but continuous profiling and adjustment are essential for each specific application.