7 Proven Spring Boot Startup Hacks to Slash Over 70% of Boot Time

1. Lazy Initialization

Set spring.main.lazy-initialization=true in application.properties to defer bean creation until first use, reducing I/O and dependency resolution at startup.

// Disable lazy init for a specific bean
@Bean
@Lazy(false)
public CriticalBean criticalBean() {
    return new CriticalBean();
}

Benchmarks:

e‑commerce app: startup 8.2 s → 5.1 s (‑38%)

micro‑service gateway: startup 12 s → 7.3 s (‑39%)

2. Precise Component Scan

Limit scanning to required packages:

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

Exclude unwanted packages or annotations:

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

Case study: a financial system removed 20 unnecessary auto‑configuration classes, reducing startup from 6.5 s to 4.2 s (‑35%).

3. JVM Parameter Tuning

Typical launch command (development):

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

Key flags and applicable scenarios: -XX:TieredStopAtLevel=1 – disables C2 compilation (development) -Xverify:none – turns off bytecode verification (trusted environment) -noverify – equivalent to -Xverify:none on JDK 8‑ and below -XX:+AlwaysPreTouch – allocates all memory at startup (production) -XX:MetaspaceSize=128m – avoids frequent metaspace expansion (metadata‑heavy apps)

Result: a logistics system reduced launch time from 9 s to 5.4 s (‑40%).

4. Auto‑Configuration Slimming

Print the auto‑configuration report by enabling the debug profile and turn off the banner:

@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 unnecessary auto‑configuration classes:

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

Case study: an IoT platform excluded 15 auto‑configuration classes, cutting startup from 7.8 s to 4.6 s (‑41%).

5. Class‑Loading Optimization

Enable JAR indexing in Maven to speed up class lookup:

<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‑loading time from 2.3 s to 1.1 s (‑52%).

6. Database Connection Optimization

Declare the datasource bean as lazy:

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

Fine‑tune HikariCP parameters:

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

Run post‑startup data work with a @PostConstruct runner:

@Bean
public CommandLineRunner initData(MyRepository repo) {
    return args -> {
        // execute data operations after startup
    };
}

Case study: a CRM system reduced database‑related startup time from 4.2 s to 1.3 s (‑69%).

7. Compilation Optimization (AOT & Layered)

Build a GraalVM native image:

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

Layered compilation flags:

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

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

Case study: an API gateway’s cold start dropped from 6 s to 0.05 s (‑99%). Payment service cold start improved from 8 s to 2.3 s (‑71%).

Comprehensive Case Study

Initial state of an e‑commerce platform:

Startup time: 14.6 s

Memory usage: 1.2 GB

Classes loaded: 8,732

Applying the seven tactics sequentially saved:

Lazy init: 3.2 s

Precise component scan: 2.8 s

JVM tuning: 1.9 s

Auto‑config exclusion: 2.1 s

Dependency trimming: 1.3 s

Lazy DB connection: 0.9 s

Layered compilation: 2.4 s

Final state:

Startup time: 4.3 s (‑70.5%)

Memory usage: 680 MB (‑43%)

Classes loaded: 5,211 (‑40%)

Optimization Checklist

Enable lazy initialization

Configure component‑scan ranges precisely

Apply JVM startup flags appropriate to environment

Exclude unnecessary auto‑configuration classes

Analyze and trim dependencies

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

Consider AOT native image or layered compilation for production