Deploying a Spring Boot App on Deployxa
Spring Boot is the leading Java web framework, and it is a favorite of enterprise teams for building APIs and microservices. It is mature, feature-rich, and has a massive ecosystem. But deploying Spring Boot has traditionally required writing a Dockerfile (to build the JAR and run it with the JVM), configuring the JVM options, and handling the database connection. Deployxa's zero-config engine eliminates all of that, detecting Spring Boot from your pom.xml or build.gradle and configuring the deployment. Here is how to deploy a Spring Boot app on Deployxa.
The direct answer is that Deployxa auto-detects Spring Boot from your pom.xml (which includes spring-boot-starter-web) or build.gradle. It configures the build and start commands: the build command is mvn clean package -DskipTests (or ./gradlew build), the start command is java -jar target/myapp.jar, and the runtime is Java 21. You do not write a Dockerfile, you do not configure the JVM, and you do not manage the build. The platform handles all of it, just as it does for .NET and Go apps.
Why Spring Boot Is a Great Choice for Enterprise Apps
Three reasons explain why Spring Boot is a great choice for enterprise apps. First, it is mature. Spring Boot has been around since 2014 (and Spring since 2003), which means it is battle-tested and has a large ecosystem. For enterprise apps that need reliability and support, Spring Boot is a safe choice. Second, it is feature-rich. Spring Boot includes everything you need for production: security, data access, messaging, caching, monitoring. For enterprise apps that need these features, Spring Boot is a natural fit. Third, it has a large talent pool. Java is one of the most popular programming languages, which means there is a large pool of developers who can maintain Spring Boot apps. For enterprise teams, this is a significant advantage. For more on enterprise deployment, see our article on Deployxa vs Heroku.
The Architecture: Spring Boot + JVM + Container
Here is how Deployxa deploys a Spring Boot app.
The Spring Boot container
The ingestion service detects Spring Boot from your pom.xml or build.gradle. It configures the build and start commands:
- Build command: mvn clean package -DskipTests (Maven) or ./gradlew build (Gradle)
- Start command: java -jar target/myapp.jar (Maven) or java -jar build/libs/myapp.jar (Gradle)
- Runtime: Java 21 (or the version specified in your build file)
The JVM configuration
The JVM options (e.g., heap size, garbage collector) are configured automatically based on the container's resources. You can override them via the JAVA_OPTS environment variable.
The reverse proxy
Traefik v3 routes traffic from your custom domain to the Spring Boot container, with automatic SSL via Let's Encrypt.
Step-by-Step: Deploying a Spring Boot App
Here is the exact workflow for a typical Cursor-generated Spring Boot app.
Step 1: Create your Spring Boot app
Use Spring Initializr (https://start.spring.io/) to generate a new project, or use the Spring Boot CLI:
spring init --dependencies=web,data-jpa,postgresql my-app
cd my-appStep 2: Create a REST controller
// src/main/java/com/example/myapp/UserController.java
package com.example.myapp;
import org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
@RestController
@RequestMapping("/users")
public class UserController {
@Autowired
private UserRepository userRepository;
@GetMapping
public List getAllUsers() {
return userRepository.findAll();
}
@GetMapping("/{id}")
public User getUser(@PathVariable Long id) {
return userRepository.findById(id)
.orElseThrow(() -> new RuntimeException("User not found"));
}
@PostMapping
public User createUser(@RequestBody User user) {
return userRepository.save(user);
}
@GetMapping("/health")
public String health() {
return "OK";
}
} Step 3: Configure application.properties
# src/main/resources/application.properties
spring.datasource.url=${DATABASE_URL:jdbc:postgresql://localhost:5432/mydb}
spring.datasource.username=${DB_USERNAME:postgres}
spring.datasource.password=${DB_PASSWORD:password}
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
server.port=${PORT:8080}Step 4: Push to GitHub
git init
git add .
git commit -m "spring boot app"
git remote add origin https://github.com/yourname/my-app.git
git push -u origin mainStep 5: Connect to Deployxa
In the Deployxa dashboard, connect your repository. Deployxa auto-detects Spring Boot:
[ingest] Detected Java project
[ingest] Framework: spring-boot
[ingest] Runtime: java 21
[ingest] Build command: mvn clean package -DskipTests
[ingest] Start command: java -jar target/myapp.jar
[ingest] Port: $PORTStep 6: Configure environment variables
In the Deployxa dashboard, add:
- DATABASE_URL: your Postgres JDBC URL (e.g., jdbc:postgresql://host:5432/db)
- DB_USERNAME: your database username
- DB_PASSWORD: your database password
The pre-flight scanner will warn you if any are missing. For more on environment variables, see our article on the vibe coder's guide to environment variables.
Step 7: Deploy
Click Deploy. The build runs mvn clean package, which produces a JAR file. The container starts with java -jar target/myapp.jar, and your app is live within 60 to 90 seconds.
Step 8: Add a custom domain
Add a custom domain in the Deployxa dashboard. SSL is provisioned automatically.
Step 9: Verify with deployxa doctor
Run deployxa doctor to verify health. The 14-point readiness engine checks SSL, DNS, environment variables, health endpoints, and container status.
Common Pitfalls and Troubleshooting
The first pitfall is the PORT environment variable. Spring Boot apps typically listen on port 8080 by default, but Deployxa assigns a dynamic port via the PORT environment variable. The fix is to set server.port=${PORT:8080} in application.properties. The second pitfall is the JVM memory. Spring Boot apps can be memory-hungry (typically 256MB to 1GB), which means you need to ensure the container has enough memory. The fix is to set JAVA_OPTS=-Xmx512m (or appropriate value) to limit the JVM heap size. The third pitfall is the build time. Maven (and Gradle) builds can be slow (1 to 5 minutes), especially for the first build. The fix is to use the persistent build cache (which Deployxa provides) and to skip tests during the build (-DskipTests). The fourth pitfall is the database connection pool. Spring Boot uses HikariCP by default, which is a high-performance connection pool. The default pool size (10 connections) is appropriate for most apps, but for high-traffic apps, you might need to adjust it. The fix is to set spring.datasource.hikari.maximum-pool-size in application.properties. The fifth pitfall is graceful shutdown. When Deployxa stops your container, Spring Boot should close the database connection and stop accepting new requests. The fix is to enable graceful shutdown in application.properties: server.shutdown=graceful and spring.lifecycle.timeout-per-shutdown-phase=30s.
Performance: Spring Boot vs .NET vs Go
Spring Boot, .NET, and Go are three leading choices for enterprise APIs. Spring Boot is the most mature (and has the largest ecosystem), but it is also the most resource-hungry (JVM overhead). .NET is nearly as mature (and nearly as fast as Go), with a smaller memory footprint than Spring Boot. Go is the fastest and the most resource-efficient, but it has a smaller ecosystem than Spring Boot and .NET. For enterprise teams that need maturity and ecosystem, Spring Boot is a great choice. For enterprise teams that want better performance, .NET or Go might be better. Deployxa supports all three equally, with the AutoRepairService and the zero-config engine handling each framework automatically. For more on performance, see our article on SPA vs SSR hardware sizing. For more on .NET deployment, see our article on deploying a .NET 8 Web API.
Advanced Spring Boot Patterns
Beyond the basics, Spring Boot apps benefit from several advanced patterns. The first is Spring Data JPA. Spring Data JPA provides a repository abstraction that makes database operations easy (you define an interface, and Spring generates the implementation). The second is Spring Security. Spring Security handles authentication and authorization, which simplifies the auth flow. The third is Spring Actuator. Spring Actuator provides production-ready features (health checks, metrics, info) out of the box, which integrates with the Deployxa readiness engine. The fourth is Spring Profiles. Spring Profiles let you define different configurations for different environments (e.g., application-staging.properties, application-production.properties), which simplifies environment-specific configuration. The fifth is testing. Spring Boot has excellent testing support (via @SpringBootTest, @WebMvcTest, @DataJpaTest), which makes it easy to write unit and integration tests. For more on testing, see our article on the testing void. For more on Spring Boot deployment, see our articles on deploying a Phoenix app with Elixir and deploying a Ruby on Rails app.
Conclusion: Spring Boot Without the Configuration
Spring Boot is the leading Java framework, and deploying it should be as simple as pushing to Git. Deployxa's zero-config engine makes it so: no Dockerfile, no JVM configuration, no build management. Stop configuring the JVM and start shipping.
Ready to deploy your Spring Boot app? Drag your project to Deployxa Drop for an instant live preview, or install the CLI with npm i -g @deployxa/cli and deploy from your terminal. For more on framework deep-dives, see our articles on deploying a Flask app with Gunicorn and deploying an Express app with PM2. Learn about deploying a Phoenix app with Elixir and deploying a Ruby on Rails app in our companion articles. Explore our free developer tools to speed up your workflow.